diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/__pycache__/test_base.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/__pycache__/test_base.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6b8ab6576c228c6c07a8c90b223e5d23005030f9
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/__pycache__/test_base.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/__pycache__/test_common.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/__pycache__/test_common.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5ce744ee7f19ccddb14e77c460ca34636bfa370f
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/__pycache__/test_common.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/__pycache__/test_indexing.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/__pycache__/test_indexing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1a1cefa0f1b7b5e96ea4b13292e4af2bc2017440
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/__pycache__/test_indexing.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/__pycache__/test_numpy_compat.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/__pycache__/test_numpy_compat.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0031ed7511e77f94ad9d11690f98056addf7e02d
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/__pycache__/test_numpy_compat.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/__pycache__/test_setops.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/__pycache__/test_setops.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8f60af2212077ac06735bfdc54fa774b879b7e60
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/__pycache__/test_setops.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__init__.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/__init__.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1ba619eaee858a21bdc96b4d8cad095f6f2843f3
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/__init__.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_constructors.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_constructors.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f13ee9f2ab3a986c6c7dfe1248bd9b15638bfecd
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_constructors.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_formats.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_formats.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..25e0f1c9cb10e37a02a8828da31fe7b7ed5f6e4a
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_formats.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_indexing.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_indexing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b6d6f78688727ed9ef919d0b7ddf0985e36b9b77
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_indexing.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_pickle.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_pickle.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4b411ab93c051aaab6cec7aca41d740cd2b32e07
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_pickle.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_reshape.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_reshape.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bf5ee46c80ae6aad6abe005da62476026f148f96
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_reshape.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_setops.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_setops.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..41112ddf4261d9a3211944251df47fec2eb72cae
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_setops.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_where.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_where.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0e850910071ea705fd8a10676809a8918404bd3a
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/__pycache__/test_where.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_constructors.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_constructors.py
new file mode 100644
index 0000000000000000000000000000000000000000..338509dd239e63f7fde17fe377a697429f1405e2
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_constructors.py
@@ -0,0 +1,80 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Index,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestIndexConstructor:
+    # Tests for the Index constructor, specifically for cases that do
+    #  not return a subclass
+
+    @pytest.mark.parametrize("value", [1, np.int64(1)])
+    def test_constructor_corner(self, value):
+        # corner case
+        msg = (
+            r"Index\(\.\.\.\) must be called with a collection of some "
+            f"kind, {value} was passed"
+        )
+        with pytest.raises(TypeError, match=msg):
+            Index(value)
+
+    @pytest.mark.parametrize("index_vals", [[("A", 1), "B"], ["B", ("A", 1)]])
+    def test_construction_list_mixed_tuples(self, index_vals):
+        # see gh-10697: if we are constructing from a mixed list of tuples,
+        # make sure that we are independent of the sorting order.
+        index = Index(index_vals)
+        assert isinstance(index, Index)
+        assert not isinstance(index, MultiIndex)
+
+    def test_constructor_cast(self):
+        msg = "could not convert string to float"
+        with pytest.raises(ValueError, match=msg):
+            Index(["a", "b", "c"], dtype=float)
+
+    @pytest.mark.parametrize("tuple_list", [[()], [(), ()]])
+    def test_construct_empty_tuples(self, tuple_list):
+        # GH #45608
+        result = Index(tuple_list)
+        expected = MultiIndex.from_tuples(tuple_list)
+
+        tm.assert_index_equal(result, expected)
+
+    def test_index_string_inference(self):
+        # GH#54430
+        pytest.importorskip("pyarrow")
+        dtype = "string[pyarrow_numpy]"
+        expected = Index(["a", "b"], dtype=dtype)
+        with pd.option_context("future.infer_string", True):
+            ser = Index(["a", "b"])
+        tm.assert_index_equal(ser, expected)
+
+        expected = Index(["a", 1], dtype="object")
+        with pd.option_context("future.infer_string", True):
+            ser = Index(["a", 1])
+        tm.assert_index_equal(ser, expected)
+
+    def test_inference_on_pandas_objects(self):
+        # GH#56012
+        idx = Index([pd.Timestamp("2019-12-31")], dtype=object)
+        with tm.assert_produces_warning(FutureWarning, match="Dtype inference"):
+            result = Index(idx)
+        assert result.dtype != np.object_
+
+        ser = Series([pd.Timestamp("2019-12-31")], dtype=object)
+
+        with tm.assert_produces_warning(FutureWarning, match="Dtype inference"):
+            result = Index(ser)
+        assert result.dtype != np.object_
+
+    def test_constructor_not_read_only(self):
+        # GH#57130
+        ser = Series([1, 2], dtype=object)
+        with pd.option_context("mode.copy_on_write", True):
+            idx = Index(ser)
+            assert idx._values.flags.writeable
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_formats.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_formats.py
new file mode 100644
index 0000000000000000000000000000000000000000..f30b578cfcf566ac577d15a1bc15880bea5d7af0
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_formats.py
@@ -0,0 +1,163 @@
+import numpy as np
+import pytest
+
+from pandas._config import using_pyarrow_string_dtype
+import pandas._config.config as cf
+
+from pandas import Index
+import pandas._testing as tm
+
+
+class TestIndexRendering:
+    def test_repr_is_valid_construction_code(self):
+        # for the case of Index, where the repr is traditional rather than
+        # stylized
+        idx = Index(["a", "b"])
+        res = eval(repr(idx))
+        tm.assert_index_equal(res, idx)
+
+    @pytest.mark.xfail(using_pyarrow_string_dtype(), reason="repr different")
+    @pytest.mark.parametrize(
+        "index,expected",
+        [
+            # ASCII
+            # short
+            (
+                Index(["a", "bb", "ccc"]),
+                """Index(['a', 'bb', 'ccc'], dtype='object')""",
+            ),
+            # multiple lines
+            (
+                Index(["a", "bb", "ccc"] * 10),
+                "Index(['a', 'bb', 'ccc', 'a', 'bb', 'ccc', 'a', "
+                "'bb', 'ccc', 'a', 'bb', 'ccc',\n"
+                "       'a', 'bb', 'ccc', 'a', 'bb', 'ccc', 'a', "
+                "'bb', 'ccc', 'a', 'bb', 'ccc',\n"
+                "       'a', 'bb', 'ccc', 'a', 'bb', 'ccc'],\n"
+                "      dtype='object')",
+            ),
+            # truncated
+            (
+                Index(["a", "bb", "ccc"] * 100),
+                "Index(['a', 'bb', 'ccc', 'a', 'bb', 'ccc', 'a', 'bb', 'ccc', 'a',\n"
+                "       ...\n"
+                "       'ccc', 'a', 'bb', 'ccc', 'a', 'bb', 'ccc', 'a', 'bb', 'ccc'],\n"
+                "      dtype='object', length=300)",
+            ),
+            # Non-ASCII
+            # short
+            (
+                Index(["あ", "いい", "ううう"]),
+                """Index(['あ', 'いい', 'ううう'], dtype='object')""",
+            ),
+            # multiple lines
+            (
+                Index(["あ", "いい", "ううう"] * 10),
+                (
+                    "Index(['あ', 'いい', 'ううう', 'あ', 'いい', 'ううう', "
+                    "'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう',\n"
+                    "       'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう', "
+                    "'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう',\n"
+                    "       'あ', 'いい', 'ううう', 'あ', 'いい', "
+                    "'ううう'],\n"
+                    "      dtype='object')"
+                ),
+            ),
+            # truncated
+            (
+                Index(["あ", "いい", "ううう"] * 100),
+                (
+                    "Index(['あ', 'いい', 'ううう', 'あ', 'いい', 'ううう', "
+                    "'あ', 'いい', 'ううう', 'あ',\n"
+                    "       ...\n"
+                    "       'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい', "
+                    "'ううう', 'あ', 'いい', 'ううう'],\n"
+                    "      dtype='object', length=300)"
+                ),
+            ),
+        ],
+    )
+    def test_string_index_repr(self, index, expected):
+        result = repr(index)
+        assert result == expected
+
+    @pytest.mark.xfail(using_pyarrow_string_dtype(), reason="repr different")
+    @pytest.mark.parametrize(
+        "index,expected",
+        [
+            # short
+            (
+                Index(["あ", "いい", "ううう"]),
+                ("Index(['あ', 'いい', 'ううう'], dtype='object')"),
+            ),
+            # multiple lines
+            (
+                Index(["あ", "いい", "ううう"] * 10),
+                (
+                    "Index(['あ', 'いい', 'ううう', 'あ', 'いい', "
+                    "'ううう', 'あ', 'いい', 'ううう',\n"
+                    "       'あ', 'いい', 'ううう', 'あ', 'いい', "
+                    "'ううう', 'あ', 'いい', 'ううう',\n"
+                    "       'あ', 'いい', 'ううう', 'あ', 'いい', "
+                    "'ううう', 'あ', 'いい', 'ううう',\n"
+                    "       'あ', 'いい', 'ううう'],\n"
+                    "      dtype='object')"
+                    ""
+                ),
+            ),
+            # truncated
+            (
+                Index(["あ", "いい", "ううう"] * 100),
+                (
+                    "Index(['あ', 'いい', 'ううう', 'あ', 'いい', "
+                    "'ううう', 'あ', 'いい', 'ううう',\n"
+                    "       'あ',\n"
+                    "       ...\n"
+                    "       'ううう', 'あ', 'いい', 'ううう', 'あ', "
+                    "'いい', 'ううう', 'あ', 'いい',\n"
+                    "       'ううう'],\n"
+                    "      dtype='object', length=300)"
+                ),
+            ),
+        ],
+    )
+    def test_string_index_repr_with_unicode_option(self, index, expected):
+        # Enable Unicode option -----------------------------------------
+        with cf.option_context("display.unicode.east_asian_width", True):
+            result = repr(index)
+            assert result == expected
+
+    def test_repr_summary(self):
+        with cf.option_context("display.max_seq_items", 10):
+            result = repr(Index(np.arange(1000)))
+            assert len(result) < 200
+            assert "..." in result
+
+    def test_summary_bug(self):
+        # GH#3869
+        ind = Index(["{other}%s", "~:{range}:0"], name="A")
+        result = ind._summary()
+        # shouldn't be formatted accidentally.
+        assert "~:{range}:0" in result
+        assert "{other}%s" in result
+
+    def test_index_repr_bool_nan(self):
+        # GH32146
+        arr = Index([True, False, np.nan], dtype=object)
+        msg = "Index.format is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            exp1 = arr.format()
+        out1 = ["True", "False", "NaN"]
+        assert out1 == exp1
+
+        exp2 = repr(arr)
+        out2 = "Index([True, False, nan], dtype='object')"
+        assert out2 == exp2
+
+    def test_format_different_scalar_lengths(self):
+        # GH#35439
+        idx = Index(["aaaaaaaaa", "b"])
+        expected = ["aaaaaaaaa", "b"]
+        msg = r"Index\.format is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert idx.format() == expected
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_indexing.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_indexing.py
new file mode 100644
index 0000000000000000000000000000000000000000..2988fa7d1baa1e0bc0f6cc4b6dc32e5d12f332cf
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_indexing.py
@@ -0,0 +1,104 @@
+import numpy as np
+import pytest
+
+from pandas._libs import index as libindex
+
+import pandas as pd
+from pandas import (
+    Index,
+    NaT,
+)
+import pandas._testing as tm
+
+
+class TestGetSliceBounds:
+    @pytest.mark.parametrize("side, expected", [("left", 4), ("right", 5)])
+    def test_get_slice_bounds_within(self, side, expected):
+        index = Index(list("abcdef"))
+        result = index.get_slice_bound("e", side=side)
+        assert result == expected
+
+    @pytest.mark.parametrize("side", ["left", "right"])
+    @pytest.mark.parametrize(
+        "data, bound, expected", [(list("abcdef"), "x", 6), (list("bcdefg"), "a", 0)]
+    )
+    def test_get_slice_bounds_outside(self, side, expected, data, bound):
+        index = Index(data)
+        result = index.get_slice_bound(bound, side=side)
+        assert result == expected
+
+    def test_get_slice_bounds_invalid_side(self):
+        with pytest.raises(ValueError, match="Invalid value for side kwarg"):
+            Index([]).get_slice_bound("a", side="middle")
+
+
+class TestGetIndexerNonUnique:
+    def test_get_indexer_non_unique_dtype_mismatch(self):
+        # GH#25459
+        indexes, missing = Index(["A", "B"]).get_indexer_non_unique(Index([0]))
+        tm.assert_numpy_array_equal(np.array([-1], dtype=np.intp), indexes)
+        tm.assert_numpy_array_equal(np.array([0], dtype=np.intp), missing)
+
+    @pytest.mark.parametrize(
+        "idx_values,idx_non_unique",
+        [
+            ([np.nan, 100, 200, 100], [np.nan, 100]),
+            ([np.nan, 100.0, 200.0, 100.0], [np.nan, 100.0]),
+        ],
+    )
+    def test_get_indexer_non_unique_int_index(self, idx_values, idx_non_unique):
+        indexes, missing = Index(idx_values).get_indexer_non_unique(Index([np.nan]))
+        tm.assert_numpy_array_equal(np.array([0], dtype=np.intp), indexes)
+        tm.assert_numpy_array_equal(np.array([], dtype=np.intp), missing)
+
+        indexes, missing = Index(idx_values).get_indexer_non_unique(
+            Index(idx_non_unique)
+        )
+        tm.assert_numpy_array_equal(np.array([0, 1, 3], dtype=np.intp), indexes)
+        tm.assert_numpy_array_equal(np.array([], dtype=np.intp), missing)
+
+
+class TestGetLoc:
+    @pytest.mark.slow  # to_flat_index takes a while
+    def test_get_loc_tuple_monotonic_above_size_cutoff(self, monkeypatch):
+        # Go through the libindex path for which using
+        # _bin_search vs ndarray.searchsorted makes a difference
+
+        with monkeypatch.context():
+            monkeypatch.setattr(libindex, "_SIZE_CUTOFF", 100)
+            lev = list("ABCD")
+            dti = pd.date_range("2016-01-01", periods=10)
+
+            mi = pd.MultiIndex.from_product([lev, range(5), dti])
+            oidx = mi.to_flat_index()
+
+            loc = len(oidx) // 2
+            tup = oidx[loc]
+
+            res = oidx.get_loc(tup)
+        assert res == loc
+
+    def test_get_loc_nan_object_dtype_nonmonotonic_nonunique(self):
+        # case that goes through _maybe_get_bool_indexer
+        idx = Index(["foo", np.nan, None, "foo", 1.0, None], dtype=object)
+
+        # we dont raise KeyError on nan
+        res = idx.get_loc(np.nan)
+        assert res == 1
+
+        # we only match on None, not on np.nan
+        res = idx.get_loc(None)
+        expected = np.array([False, False, True, False, False, True])
+        tm.assert_numpy_array_equal(res, expected)
+
+        # we don't match at all on mismatched NA
+        with pytest.raises(KeyError, match="NaT"):
+            idx.get_loc(NaT)
+
+
+def test_getitem_boolean_ea_indexer():
+    # GH#45806
+    ser = pd.Series([True, False, pd.NA], dtype="boolean")
+    result = ser.index[ser]
+    expected = Index([0])
+    tm.assert_index_equal(result, expected)
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_pickle.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_pickle.py
new file mode 100644
index 0000000000000000000000000000000000000000..c670921decb78808fa54a35c45e3d2d15ab57a67
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_pickle.py
@@ -0,0 +1,11 @@
+from pandas import Index
+import pandas._testing as tm
+
+
+def test_pickle_preserves_object_dtype():
+    # GH#43188, GH#43155 don't infer numeric dtype
+    index = Index([1, 2, 3], dtype=object)
+
+    result = tm.round_trip_pickle(index)
+    assert result.dtype == object
+    tm.assert_index_equal(index, result)
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_reshape.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_reshape.py
new file mode 100644
index 0000000000000000000000000000000000000000..814a6a516904b6c31d3ef38fa91f23f69fa6ed7e
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_reshape.py
@@ -0,0 +1,95 @@
+"""
+Tests for ndarray-like method on the base Index class
+"""
+import numpy as np
+import pytest
+
+from pandas import Index
+import pandas._testing as tm
+
+
+class TestReshape:
+    def test_repeat(self):
+        repeats = 2
+        index = Index([1, 2, 3])
+        expected = Index([1, 1, 2, 2, 3, 3])
+
+        result = index.repeat(repeats)
+        tm.assert_index_equal(result, expected)
+
+    def test_insert(self):
+        # GH 7256
+        # validate neg/pos inserts
+        result = Index(["b", "c", "d"])
+
+        # test 0th element
+        tm.assert_index_equal(Index(["a", "b", "c", "d"]), result.insert(0, "a"))
+
+        # test Nth element that follows Python list behavior
+        tm.assert_index_equal(Index(["b", "c", "e", "d"]), result.insert(-1, "e"))
+
+        # test loc +/- neq (0, -1)
+        tm.assert_index_equal(result.insert(1, "z"), result.insert(-2, "z"))
+
+        # test empty
+        null_index = Index([])
+        tm.assert_index_equal(Index(["a"], dtype=object), null_index.insert(0, "a"))
+
+    def test_insert_missing(self, nulls_fixture, using_infer_string):
+        # GH#22295
+        # test there is no mangling of NA values
+        expected = Index(["a", nulls_fixture, "b", "c"], dtype=object)
+        result = Index(list("abc"), dtype=object).insert(
+            1, Index([nulls_fixture], dtype=object)
+        )
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "val", [(1, 2), np.datetime64("2019-12-31"), np.timedelta64(1, "D")]
+    )
+    @pytest.mark.parametrize("loc", [-1, 2])
+    def test_insert_datetime_into_object(self, loc, val):
+        # GH#44509
+        idx = Index(["1", "2", "3"])
+        result = idx.insert(loc, val)
+        expected = Index(["1", "2", val, "3"])
+        tm.assert_index_equal(result, expected)
+        assert type(expected[2]) is type(val)
+
+    def test_insert_none_into_string_numpy(self):
+        # GH#55365
+        pytest.importorskip("pyarrow")
+        index = Index(["a", "b", "c"], dtype="string[pyarrow_numpy]")
+        result = index.insert(-1, None)
+        expected = Index(["a", "b", None, "c"], dtype="string[pyarrow_numpy]")
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "pos,expected",
+        [
+            (0, Index(["b", "c", "d"], name="index")),
+            (-1, Index(["a", "b", "c"], name="index")),
+        ],
+    )
+    def test_delete(self, pos, expected):
+        index = Index(["a", "b", "c", "d"], name="index")
+        result = index.delete(pos)
+        tm.assert_index_equal(result, expected)
+        assert result.name == expected.name
+
+    def test_delete_raises(self):
+        index = Index(["a", "b", "c", "d"], name="index")
+        msg = "index 5 is out of bounds for axis 0 with size 4"
+        with pytest.raises(IndexError, match=msg):
+            index.delete(5)
+
+    def test_append_multiple(self):
+        index = Index(["a", "b", "c", "d", "e", "f"])
+
+        foos = [index[:2], index[2:4], index[4:]]
+        result = foos[0].append(foos[1:])
+        tm.assert_index_equal(result, index)
+
+        # empty
+        result = index.append([])
+        tm.assert_index_equal(result, index)
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_setops.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_setops.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ef3f3ad4d3a20bd2e6303d781590396cbc00ae0
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_setops.py
@@ -0,0 +1,266 @@
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Index,
+    Series,
+)
+import pandas._testing as tm
+from pandas.core.algorithms import safe_sort
+
+
+def equal_contents(arr1, arr2) -> bool:
+    """
+    Checks if the set of unique elements of arr1 and arr2 are equivalent.
+    """
+    return frozenset(arr1) == frozenset(arr2)
+
+
+class TestIndexSetOps:
+    @pytest.mark.parametrize(
+        "method", ["union", "intersection", "difference", "symmetric_difference"]
+    )
+    def test_setops_sort_validation(self, method):
+        idx1 = Index(["a", "b"])
+        idx2 = Index(["b", "c"])
+
+        with pytest.raises(ValueError, match="The 'sort' keyword only takes"):
+            getattr(idx1, method)(idx2, sort=2)
+
+        # sort=True is supported as of GH#??
+        getattr(idx1, method)(idx2, sort=True)
+
+    def test_setops_preserve_object_dtype(self):
+        idx = Index([1, 2, 3], dtype=object)
+        result = idx.intersection(idx[1:])
+        expected = idx[1:]
+        tm.assert_index_equal(result, expected)
+
+        # if other is not monotonic increasing, intersection goes through
+        #  a different route
+        result = idx.intersection(idx[1:][::-1])
+        tm.assert_index_equal(result, expected)
+
+        result = idx._union(idx[1:], sort=None)
+        expected = idx
+        tm.assert_numpy_array_equal(result, expected.values)
+
+        result = idx.union(idx[1:], sort=None)
+        tm.assert_index_equal(result, expected)
+
+        # if other is not monotonic increasing, _union goes through
+        #  a different route
+        result = idx._union(idx[1:][::-1], sort=None)
+        tm.assert_numpy_array_equal(result, expected.values)
+
+        result = idx.union(idx[1:][::-1], sort=None)
+        tm.assert_index_equal(result, expected)
+
+    def test_union_base(self):
+        index = Index([0, "a", 1, "b", 2, "c"])
+        first = index[3:]
+        second = index[:5]
+
+        result = first.union(second)
+
+        expected = Index([0, 1, 2, "a", "b", "c"])
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize("klass", [np.array, Series, list])
+    def test_union_different_type_base(self, klass):
+        # GH 10149
+        index = Index([0, "a", 1, "b", 2, "c"])
+        first = index[3:]
+        second = index[:5]
+
+        result = first.union(klass(second.values))
+
+        assert equal_contents(result, index)
+
+    def test_union_sort_other_incomparable(self):
+        # https://github.com/pandas-dev/pandas/issues/24959
+        idx = Index([1, pd.Timestamp("2000")])
+        # default (sort=None)
+        with tm.assert_produces_warning(RuntimeWarning):
+            result = idx.union(idx[:1])
+
+        tm.assert_index_equal(result, idx)
+
+        # sort=None
+        with tm.assert_produces_warning(RuntimeWarning):
+            result = idx.union(idx[:1], sort=None)
+        tm.assert_index_equal(result, idx)
+
+        # sort=False
+        result = idx.union(idx[:1], sort=False)
+        tm.assert_index_equal(result, idx)
+
+    def test_union_sort_other_incomparable_true(self):
+        idx = Index([1, pd.Timestamp("2000")])
+        with pytest.raises(TypeError, match=".*"):
+            idx.union(idx[:1], sort=True)
+
+    def test_intersection_equal_sort_true(self):
+        idx = Index(["c", "a", "b"])
+        sorted_ = Index(["a", "b", "c"])
+        tm.assert_index_equal(idx.intersection(idx, sort=True), sorted_)
+
+    def test_intersection_base(self, sort):
+        # (same results for py2 and py3 but sortedness not tested elsewhere)
+        index = Index([0, "a", 1, "b", 2, "c"])
+        first = index[:5]
+        second = index[:3]
+
+        expected = Index([0, 1, "a"]) if sort is None else Index([0, "a", 1])
+        result = first.intersection(second, sort=sort)
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize("klass", [np.array, Series, list])
+    def test_intersection_different_type_base(self, klass, sort):
+        # GH 10149
+        index = Index([0, "a", 1, "b", 2, "c"])
+        first = index[:5]
+        second = index[:3]
+
+        result = first.intersection(klass(second.values), sort=sort)
+        assert equal_contents(result, second)
+
+    def test_intersection_nosort(self):
+        result = Index(["c", "b", "a"]).intersection(["b", "a"])
+        expected = Index(["b", "a"])
+        tm.assert_index_equal(result, expected)
+
+    def test_intersection_equal_sort(self):
+        idx = Index(["c", "a", "b"])
+        tm.assert_index_equal(idx.intersection(idx, sort=False), idx)
+        tm.assert_index_equal(idx.intersection(idx, sort=None), idx)
+
+    def test_intersection_str_dates(self, sort):
+        dt_dates = [datetime(2012, 2, 9), datetime(2012, 2, 22)]
+
+        i1 = Index(dt_dates, dtype=object)
+        i2 = Index(["aa"], dtype=object)
+        result = i2.intersection(i1, sort=sort)
+
+        assert len(result) == 0
+
+    @pytest.mark.parametrize(
+        "index2,expected_arr",
+        [(Index(["B", "D"]), ["B"]), (Index(["B", "D", "A"]), ["A", "B"])],
+    )
+    def test_intersection_non_monotonic_non_unique(self, index2, expected_arr, sort):
+        # non-monotonic non-unique
+        index1 = Index(["A", "B", "A", "C"])
+        expected = Index(expected_arr)
+        result = index1.intersection(index2, sort=sort)
+        if sort is None:
+            expected = expected.sort_values()
+        tm.assert_index_equal(result, expected)
+
+    def test_difference_base(self, sort):
+        # (same results for py2 and py3 but sortedness not tested elsewhere)
+        index = Index([0, "a", 1, "b", 2, "c"])
+        first = index[:4]
+        second = index[3:]
+
+        result = first.difference(second, sort)
+        expected = Index([0, "a", 1])
+        if sort is None:
+            expected = Index(safe_sort(expected))
+        tm.assert_index_equal(result, expected)
+
+    def test_symmetric_difference(self):
+        # (same results for py2 and py3 but sortedness not tested elsewhere)
+        index = Index([0, "a", 1, "b", 2, "c"])
+        first = index[:4]
+        second = index[3:]
+
+        result = first.symmetric_difference(second)
+        expected = Index([0, 1, 2, "a", "c"])
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "method,expected,sort",
+        [
+            (
+                "intersection",
+                np.array(
+                    [(1, "A"), (2, "A"), (1, "B"), (2, "B")],
+                    dtype=[("num", int), ("let", "S1")],
+                ),
+                False,
+            ),
+            (
+                "intersection",
+                np.array(
+                    [(1, "A"), (1, "B"), (2, "A"), (2, "B")],
+                    dtype=[("num", int), ("let", "S1")],
+                ),
+                None,
+            ),
+            (
+                "union",
+                np.array(
+                    [(1, "A"), (1, "B"), (1, "C"), (2, "A"), (2, "B"), (2, "C")],
+                    dtype=[("num", int), ("let", "S1")],
+                ),
+                None,
+            ),
+        ],
+    )
+    def test_tuple_union_bug(self, method, expected, sort):
+        index1 = Index(
+            np.array(
+                [(1, "A"), (2, "A"), (1, "B"), (2, "B")],
+                dtype=[("num", int), ("let", "S1")],
+            )
+        )
+        index2 = Index(
+            np.array(
+                [(1, "A"), (2, "A"), (1, "B"), (2, "B"), (1, "C"), (2, "C")],
+                dtype=[("num", int), ("let", "S1")],
+            )
+        )
+
+        result = getattr(index1, method)(index2, sort=sort)
+        assert result.ndim == 1
+
+        expected = Index(expected)
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize("first_list", [["b", "a"], []])
+    @pytest.mark.parametrize("second_list", [["a", "b"], []])
+    @pytest.mark.parametrize(
+        "first_name, second_name, expected_name",
+        [("A", "B", None), (None, "B", None), ("A", None, None)],
+    )
+    def test_union_name_preservation(
+        self, first_list, second_list, first_name, second_name, expected_name, sort
+    ):
+        first = Index(first_list, name=first_name)
+        second = Index(second_list, name=second_name)
+        union = first.union(second, sort=sort)
+
+        vals = set(first_list).union(second_list)
+
+        if sort is None and len(first_list) > 0 and len(second_list) > 0:
+            expected = Index(sorted(vals), name=expected_name)
+            tm.assert_index_equal(union, expected)
+        else:
+            expected = Index(vals, name=expected_name)
+            tm.assert_index_equal(union.sort_values(), expected.sort_values())
+
+    @pytest.mark.parametrize(
+        "diff_type, expected",
+        [["difference", [1, "B"]], ["symmetric_difference", [1, 2, "B", "C"]]],
+    )
+    def test_difference_object_type(self, diff_type, expected):
+        # GH 13432
+        idx1 = Index([0, 1, "A", "B"])
+        idx2 = Index([0, 2, "A", "C"])
+        result = getattr(idx1, diff_type)(idx2)
+        expected = Index(expected)
+        tm.assert_index_equal(result, expected)
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_where.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_where.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c8969735e14e2741bc029b499024af3ec378a92
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/base_class/test_where.py
@@ -0,0 +1,13 @@
+import numpy as np
+
+from pandas import Index
+import pandas._testing as tm
+
+
+class TestWhere:
+    def test_where_intlike_str_doesnt_cast_ints(self):
+        idx = Index(range(3))
+        mask = np.array([True, False, True])
+        res = idx.where(mask, "2")
+        expected = Index([0, "2", 2])
+        tm.assert_index_equal(res, expected)
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/__init__.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5817c33ac4420b483c48b3a306c63285b98a4214
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/__init__.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/test_astype.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/test_astype.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..822ca48a92d44d615faf3ff2ce1efbbe7890a4fc
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/test_astype.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/test_constructors.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/test_constructors.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c9e30fb4c464ea91a6848cbf666293612127f0f1
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/test_constructors.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/test_fillna.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/test_fillna.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7b412e95c6df0a3f4abcb1cafe8138ca89a14f01
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/test_fillna.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/test_formats.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/test_formats.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..43b27b7ef1d46ac72a2e79fedb3f2ed226c793da
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/test_formats.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/test_indexing.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/test_indexing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..873ff09e68cdeecd953566dd77c457fbd6070136
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/test_indexing.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/test_reindex.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/test_reindex.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3ce2c08ca7e615a6ae768292672ed504fe7de432
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/__pycache__/test_reindex.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/test_reindex.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/test_reindex.py
new file mode 100644
index 0000000000000000000000000000000000000000..5b1f2b9fb159a6873c83e0a0a4e777913bb99fee
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/categorical/test_reindex.py
@@ -0,0 +1,78 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Categorical,
+    CategoricalIndex,
+    Index,
+    Interval,
+)
+import pandas._testing as tm
+
+
+class TestReindex:
+    def test_reindex_list_non_unique(self):
+        # GH#11586
+        msg = "cannot reindex on an axis with duplicate labels"
+        ci = CategoricalIndex(["a", "b", "c", "a"])
+        with pytest.raises(ValueError, match=msg):
+            ci.reindex(["a", "c"])
+
+    def test_reindex_categorical_non_unique(self):
+        msg = "cannot reindex on an axis with duplicate labels"
+        ci = CategoricalIndex(["a", "b", "c", "a"])
+        with pytest.raises(ValueError, match=msg):
+            ci.reindex(Categorical(["a", "c"]))
+
+    def test_reindex_list_non_unique_unused_category(self):
+        msg = "cannot reindex on an axis with duplicate labels"
+        ci = CategoricalIndex(["a", "b", "c", "a"], categories=["a", "b", "c", "d"])
+        with pytest.raises(ValueError, match=msg):
+            ci.reindex(["a", "c"])
+
+    def test_reindex_categorical_non_unique_unused_category(self):
+        msg = "cannot reindex on an axis with duplicate labels"
+        ci = CategoricalIndex(["a", "b", "c", "a"], categories=["a", "b", "c", "d"])
+        with pytest.raises(ValueError, match=msg):
+            ci.reindex(Categorical(["a", "c"]))
+
+    def test_reindex_duplicate_target(self):
+        # See GH25459
+        cat = CategoricalIndex(["a", "b", "c"], categories=["a", "b", "c", "d"])
+        res, indexer = cat.reindex(["a", "c", "c"])
+        exp = Index(["a", "c", "c"])
+        tm.assert_index_equal(res, exp, exact=True)
+        tm.assert_numpy_array_equal(indexer, np.array([0, 2, 2], dtype=np.intp))
+
+        res, indexer = cat.reindex(
+            CategoricalIndex(["a", "c", "c"], categories=["a", "b", "c", "d"])
+        )
+        exp = CategoricalIndex(["a", "c", "c"], categories=["a", "b", "c", "d"])
+        tm.assert_index_equal(res, exp, exact=True)
+        tm.assert_numpy_array_equal(indexer, np.array([0, 2, 2], dtype=np.intp))
+
+    def test_reindex_empty_index(self):
+        # See GH16770
+        c = CategoricalIndex([])
+        res, indexer = c.reindex(["a", "b"])
+        tm.assert_index_equal(res, Index(["a", "b"]), exact=True)
+        tm.assert_numpy_array_equal(indexer, np.array([-1, -1], dtype=np.intp))
+
+    def test_reindex_categorical_added_category(self):
+        # GH 42424
+        ci = CategoricalIndex(
+            [Interval(0, 1, closed="right"), Interval(1, 2, closed="right")],
+            ordered=True,
+        )
+        ci_add = CategoricalIndex(
+            [
+                Interval(0, 1, closed="right"),
+                Interval(1, 2, closed="right"),
+                Interval(2, 3, closed="right"),
+                Interval(3, 4, closed="right"),
+            ],
+            ordered=True,
+        )
+        result, _ = ci.reindex(ci_add)
+        expected = ci_add
+        tm.assert_index_equal(expected, result)
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/__init__.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/__pycache__/__init__.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fc491525738830ce76245948583d900e1a7d6daa
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/__pycache__/__init__.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/__pycache__/test_drop_duplicates.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/__pycache__/test_drop_duplicates.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bad4f669ffb02dddd479dc37178680c1a32e5533
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/__pycache__/test_drop_duplicates.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/__pycache__/test_equals.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/__pycache__/test_equals.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c820e376f3361efb1e03508b2c604a5484977b9b
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/__pycache__/test_equals.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/__pycache__/test_indexing.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/__pycache__/test_indexing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3f1eafd553782a99dabc6d7fa8e9a54bcb5fd517
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/__pycache__/test_indexing.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/__pycache__/test_is_monotonic.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/__pycache__/test_is_monotonic.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..823fa63cd8c9a67f161593e87231ebb943ca80a1
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/__pycache__/test_is_monotonic.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/test_drop_duplicates.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/test_drop_duplicates.py
new file mode 100644
index 0000000000000000000000000000000000000000..61a79c4ceabf9d68aab73ffd69e0f15ad842ff74
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/test_drop_duplicates.py
@@ -0,0 +1,89 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    PeriodIndex,
+    Series,
+    date_range,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+
+
+class DropDuplicates:
+    def test_drop_duplicates_metadata(self, idx):
+        # GH#10115
+        result = idx.drop_duplicates()
+        tm.assert_index_equal(idx, result)
+        assert idx.freq == result.freq
+
+        idx_dup = idx.append(idx)
+        result = idx_dup.drop_duplicates()
+
+        expected = idx
+        if not isinstance(idx, PeriodIndex):
+            # freq is reset except for PeriodIndex
+            assert idx_dup.freq is None
+            assert result.freq is None
+            expected = idx._with_freq(None)
+        else:
+            assert result.freq == expected.freq
+
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "keep, expected, index",
+        [
+            (
+                "first",
+                np.concatenate(([False] * 10, [True] * 5)),
+                np.arange(0, 10, dtype=np.int64),
+            ),
+            (
+                "last",
+                np.concatenate(([True] * 5, [False] * 10)),
+                np.arange(5, 15, dtype=np.int64),
+            ),
+            (
+                False,
+                np.concatenate(([True] * 5, [False] * 5, [True] * 5)),
+                np.arange(5, 10, dtype=np.int64),
+            ),
+        ],
+    )
+    def test_drop_duplicates(self, keep, expected, index, idx):
+        # to check Index/Series compat
+        idx = idx.append(idx[:5])
+
+        tm.assert_numpy_array_equal(idx.duplicated(keep=keep), expected)
+        expected = idx[~expected]
+
+        result = idx.drop_duplicates(keep=keep)
+        tm.assert_index_equal(result, expected)
+
+        result = Series(idx).drop_duplicates(keep=keep)
+        expected = Series(expected, index=index)
+        tm.assert_series_equal(result, expected)
+
+
+class TestDropDuplicatesPeriodIndex(DropDuplicates):
+    @pytest.fixture(params=["D", "3D", "h", "2h", "min", "2min", "s", "3s"])
+    def freq(self, request):
+        return request.param
+
+    @pytest.fixture
+    def idx(self, freq):
+        return period_range("2011-01-01", periods=10, freq=freq, name="idx")
+
+
+class TestDropDuplicatesDatetimeIndex(DropDuplicates):
+    @pytest.fixture
+    def idx(self, freq_sample):
+        return date_range("2011-01-01", freq=freq_sample, periods=10, name="idx")
+
+
+class TestDropDuplicatesTimedeltaIndex(DropDuplicates):
+    @pytest.fixture
+    def idx(self, freq_sample):
+        return timedelta_range("1 day", periods=10, freq=freq_sample, name="idx")
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/test_value_counts.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/test_value_counts.py
new file mode 100644
index 0000000000000000000000000000000000000000..069e354a364c9343c595da9d18ee7c04eec04f43
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/test_value_counts.py
@@ -0,0 +1,103 @@
+import numpy as np
+
+from pandas import (
+    DatetimeIndex,
+    NaT,
+    PeriodIndex,
+    Series,
+    TimedeltaIndex,
+    date_range,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+
+
+class TestValueCounts:
+    # GH#7735
+
+    def test_value_counts_unique_datetimeindex(self, tz_naive_fixture):
+        tz = tz_naive_fixture
+        orig = date_range("2011-01-01 09:00", freq="h", periods=10, tz=tz)
+        self._check_value_counts_with_repeats(orig)
+
+    def test_value_counts_unique_timedeltaindex(self):
+        orig = timedelta_range("1 days 09:00:00", freq="h", periods=10)
+        self._check_value_counts_with_repeats(orig)
+
+    def test_value_counts_unique_periodindex(self):
+        orig = period_range("2011-01-01 09:00", freq="h", periods=10)
+        self._check_value_counts_with_repeats(orig)
+
+    def _check_value_counts_with_repeats(self, orig):
+        # create repeated values, 'n'th element is repeated by n+1 times
+        idx = type(orig)(
+            np.repeat(orig._values, range(1, len(orig) + 1)), dtype=orig.dtype
+        )
+
+        exp_idx = orig[::-1]
+        if not isinstance(exp_idx, PeriodIndex):
+            exp_idx = exp_idx._with_freq(None)
+        expected = Series(range(10, 0, -1), index=exp_idx, dtype="int64", name="count")
+
+        for obj in [idx, Series(idx)]:
+            tm.assert_series_equal(obj.value_counts(), expected)
+
+        tm.assert_index_equal(idx.unique(), orig)
+
+    def test_value_counts_unique_datetimeindex2(self, tz_naive_fixture):
+        tz = tz_naive_fixture
+        idx = DatetimeIndex(
+            [
+                "2013-01-01 09:00",
+                "2013-01-01 09:00",
+                "2013-01-01 09:00",
+                "2013-01-01 08:00",
+                "2013-01-01 08:00",
+                NaT,
+            ],
+            tz=tz,
+        )
+        self._check_value_counts_dropna(idx)
+
+    def test_value_counts_unique_timedeltaindex2(self):
+        idx = TimedeltaIndex(
+            [
+                "1 days 09:00:00",
+                "1 days 09:00:00",
+                "1 days 09:00:00",
+                "1 days 08:00:00",
+                "1 days 08:00:00",
+                NaT,
+            ]
+        )
+        self._check_value_counts_dropna(idx)
+
+    def test_value_counts_unique_periodindex2(self):
+        idx = PeriodIndex(
+            [
+                "2013-01-01 09:00",
+                "2013-01-01 09:00",
+                "2013-01-01 09:00",
+                "2013-01-01 08:00",
+                "2013-01-01 08:00",
+                NaT,
+            ],
+            freq="h",
+        )
+        self._check_value_counts_dropna(idx)
+
+    def _check_value_counts_dropna(self, idx):
+        exp_idx = idx[[2, 3]]
+        expected = Series([3, 2], index=exp_idx, name="count")
+
+        for obj in [idx, Series(idx)]:
+            tm.assert_series_equal(obj.value_counts(), expected)
+
+        exp_idx = idx[[2, 3, -1]]
+        expected = Series([3, 2, 1], index=exp_idx, name="count")
+
+        for obj in [idx, Series(idx)]:
+            tm.assert_series_equal(obj.value_counts(dropna=False), expected)
+
+        tm.assert_index_equal(idx.unique(), exp_idx)
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__init__.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/__init__.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..963ec42f7fb1fd497fead0acc74cef57c3229a81
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/__init__.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_astype.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_astype.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0ea2be8198366c4aa08eb93dd49046abb26072af
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_astype.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_constructors.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_constructors.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a4f574adda495bdd3c6f9884bdf47956b70335f8
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_constructors.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_equals.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_equals.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5e82b8bcc5f34c64ce863cd43f95a0c1a30edd8f
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_equals.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_formats.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_formats.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6f96a16e125b615089fcd44eec9bb318657788dd
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_formats.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_indexing.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_indexing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..957bed886e0600f1504568559e67dc7c672128e2
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_indexing.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_interval.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_interval.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..98ff8500c9f9ef45c25416da3d07cbc50cfc308e
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_interval.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_interval_range.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_interval_range.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1ca67c454abf11f0649328ca5b7c0865c624a783
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_interval_range.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_interval_tree.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_interval_tree.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e4112a3fc82ce333e9319ae0416fb14139070232
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_interval_tree.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_join.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_join.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3e758f8d0ef03c6734a82a83b27196db2ae942c8
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_join.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_pickle.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_pickle.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c411f6d6fb3ee50ee128ba99973dfaee086532e0
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_pickle.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_setops.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_setops.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..33d00faa48a4375245a8e85750d377166f7ac855
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/__pycache__/test_setops.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_astype.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_astype.py
new file mode 100644
index 0000000000000000000000000000000000000000..59c555b9644a1230dc60d622fb5fdb80a1743afe
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_astype.py
@@ -0,0 +1,248 @@
+import re
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.dtypes import (
+    CategoricalDtype,
+    IntervalDtype,
+)
+
+from pandas import (
+    CategoricalIndex,
+    Index,
+    IntervalIndex,
+    NaT,
+    Timedelta,
+    Timestamp,
+    interval_range,
+)
+import pandas._testing as tm
+
+
+class AstypeTests:
+    """Tests common to IntervalIndex with any subtype"""
+
+    def test_astype_idempotent(self, index):
+        result = index.astype("interval")
+        tm.assert_index_equal(result, index)
+
+        result = index.astype(index.dtype)
+        tm.assert_index_equal(result, index)
+
+    def test_astype_object(self, index):
+        result = index.astype(object)
+        expected = Index(index.values, dtype="object")
+        tm.assert_index_equal(result, expected)
+        assert not result.equals(index)
+
+    def test_astype_category(self, index):
+        result = index.astype("category")
+        expected = CategoricalIndex(index.values)
+        tm.assert_index_equal(result, expected)
+
+        result = index.astype(CategoricalDtype())
+        tm.assert_index_equal(result, expected)
+
+        # non-default params
+        categories = index.dropna().unique().values[:-1]
+        dtype = CategoricalDtype(categories=categories, ordered=True)
+        result = index.astype(dtype)
+        expected = CategoricalIndex(index.values, categories=categories, ordered=True)
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype",
+        [
+            "int64",
+            "uint64",
+            "float64",
+            "complex128",
+            "period[M]",
+            "timedelta64",
+            "timedelta64[ns]",
+            "datetime64",
+            "datetime64[ns]",
+            "datetime64[ns, US/Eastern]",
+        ],
+    )
+    def test_astype_cannot_cast(self, index, dtype):
+        msg = "Cannot cast IntervalIndex to dtype"
+        with pytest.raises(TypeError, match=msg):
+            index.astype(dtype)
+
+    def test_astype_invalid_dtype(self, index):
+        msg = "data type [\"']fake_dtype[\"'] not understood"
+        with pytest.raises(TypeError, match=msg):
+            index.astype("fake_dtype")
+
+
+class TestIntSubtype(AstypeTests):
+    """Tests specific to IntervalIndex with integer-like subtype"""
+
+    indexes = [
+        IntervalIndex.from_breaks(np.arange(-10, 11, dtype="int64")),
+        IntervalIndex.from_breaks(np.arange(100, dtype="uint64"), closed="left"),
+    ]
+
+    @pytest.fixture(params=indexes)
+    def index(self, request):
+        return request.param
+
+    @pytest.mark.parametrize(
+        "subtype", ["float64", "datetime64[ns]", "timedelta64[ns]"]
+    )
+    def test_subtype_conversion(self, index, subtype):
+        dtype = IntervalDtype(subtype, index.closed)
+        result = index.astype(dtype)
+        expected = IntervalIndex.from_arrays(
+            index.left.astype(subtype), index.right.astype(subtype), closed=index.closed
+        )
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "subtype_start, subtype_end", [("int64", "uint64"), ("uint64", "int64")]
+    )
+    def test_subtype_integer(self, subtype_start, subtype_end):
+        index = IntervalIndex.from_breaks(np.arange(100, dtype=subtype_start))
+        dtype = IntervalDtype(subtype_end, index.closed)
+        result = index.astype(dtype)
+        expected = IntervalIndex.from_arrays(
+            index.left.astype(subtype_end),
+            index.right.astype(subtype_end),
+            closed=index.closed,
+        )
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.xfail(reason="GH#15832")
+    def test_subtype_integer_errors(self):
+        # int64 -> uint64 fails with negative values
+        index = interval_range(-10, 10)
+        dtype = IntervalDtype("uint64", "right")
+
+        # Until we decide what the exception message _should_ be, we
+        #  assert something that it should _not_ be.
+        #  We should _not_ be getting a message suggesting that the -10
+        #  has been wrapped around to a large-positive integer
+        msg = "^(?!(left side of interval must be <= right side))"
+        with pytest.raises(ValueError, match=msg):
+            index.astype(dtype)
+
+
+class TestFloatSubtype(AstypeTests):
+    """Tests specific to IntervalIndex with float subtype"""
+
+    indexes = [
+        interval_range(-10.0, 10.0, closed="neither"),
+        IntervalIndex.from_arrays(
+            [-1.5, np.nan, 0.0, 0.0, 1.5], [-0.5, np.nan, 1.0, 1.0, 3.0], closed="both"
+        ),
+    ]
+
+    @pytest.fixture(params=indexes)
+    def index(self, request):
+        return request.param
+
+    @pytest.mark.parametrize("subtype", ["int64", "uint64"])
+    def test_subtype_integer(self, subtype):
+        index = interval_range(0.0, 10.0)
+        dtype = IntervalDtype(subtype, "right")
+        result = index.astype(dtype)
+        expected = IntervalIndex.from_arrays(
+            index.left.astype(subtype), index.right.astype(subtype), closed=index.closed
+        )
+        tm.assert_index_equal(result, expected)
+
+        # raises with NA
+        msg = r"Cannot convert non-finite values \(NA or inf\) to integer"
+        with pytest.raises(ValueError, match=msg):
+            index.insert(0, np.nan).astype(dtype)
+
+    @pytest.mark.parametrize("subtype", ["int64", "uint64"])
+    def test_subtype_integer_with_non_integer_borders(self, subtype):
+        index = interval_range(0.0, 3.0, freq=0.25)
+        dtype = IntervalDtype(subtype, "right")
+        result = index.astype(dtype)
+        expected = IntervalIndex.from_arrays(
+            index.left.astype(subtype), index.right.astype(subtype), closed=index.closed
+        )
+        tm.assert_index_equal(result, expected)
+
+    def test_subtype_integer_errors(self):
+        # float64 -> uint64 fails with negative values
+        index = interval_range(-10.0, 10.0)
+        dtype = IntervalDtype("uint64", "right")
+        msg = re.escape(
+            "Cannot convert interval[float64, right] to interval[uint64, right]; "
+            "subtypes are incompatible"
+        )
+        with pytest.raises(TypeError, match=msg):
+            index.astype(dtype)
+
+    @pytest.mark.parametrize("subtype", ["datetime64[ns]", "timedelta64[ns]"])
+    def test_subtype_datetimelike(self, index, subtype):
+        dtype = IntervalDtype(subtype, "right")
+        msg = "Cannot convert .* to .*; subtypes are incompatible"
+        with pytest.raises(TypeError, match=msg):
+            index.astype(dtype)
+
+
+class TestDatetimelikeSubtype(AstypeTests):
+    """Tests specific to IntervalIndex with datetime-like subtype"""
+
+    indexes = [
+        interval_range(Timestamp("2018-01-01"), periods=10, closed="neither"),
+        interval_range(Timestamp("2018-01-01"), periods=10).insert(2, NaT),
+        interval_range(Timestamp("2018-01-01", tz="US/Eastern"), periods=10),
+        interval_range(Timedelta("0 days"), periods=10, closed="both"),
+        interval_range(Timedelta("0 days"), periods=10).insert(2, NaT),
+    ]
+
+    @pytest.fixture(params=indexes)
+    def index(self, request):
+        return request.param
+
+    @pytest.mark.parametrize("subtype", ["int64", "uint64"])
+    def test_subtype_integer(self, index, subtype):
+        dtype = IntervalDtype(subtype, "right")
+
+        if subtype != "int64":
+            msg = (
+                r"Cannot convert interval\[(timedelta64|datetime64)\[ns.*\], .*\] "
+                r"to interval\[uint64, .*\]"
+            )
+            with pytest.raises(TypeError, match=msg):
+                index.astype(dtype)
+            return
+
+        result = index.astype(dtype)
+        new_left = index.left.astype(subtype)
+        new_right = index.right.astype(subtype)
+
+        expected = IntervalIndex.from_arrays(new_left, new_right, closed=index.closed)
+        tm.assert_index_equal(result, expected)
+
+    def test_subtype_float(self, index):
+        dtype = IntervalDtype("float64", "right")
+        msg = "Cannot convert .* to .*; subtypes are incompatible"
+        with pytest.raises(TypeError, match=msg):
+            index.astype(dtype)
+
+    def test_subtype_datetimelike(self):
+        # datetime -> timedelta raises
+        dtype = IntervalDtype("timedelta64[ns]", "right")
+        msg = "Cannot convert .* to .*; subtypes are incompatible"
+
+        index = interval_range(Timestamp("2018-01-01"), periods=10)
+        with pytest.raises(TypeError, match=msg):
+            index.astype(dtype)
+
+        index = interval_range(Timestamp("2018-01-01", tz="CET"), periods=10)
+        with pytest.raises(TypeError, match=msg):
+            index.astype(dtype)
+
+        # timedelta -> datetime raises
+        dtype = IntervalDtype("datetime64[ns]", "right")
+        index = interval_range(Timedelta("0 days"), periods=10)
+        with pytest.raises(TypeError, match=msg):
+            index.astype(dtype)
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_constructors.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_constructors.py
new file mode 100644
index 0000000000000000000000000000000000000000..e47a014f18045ae20fe27805a31b819b4ad229b9
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_constructors.py
@@ -0,0 +1,535 @@
+from functools import partial
+
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas.core.dtypes.common import is_unsigned_integer_dtype
+from pandas.core.dtypes.dtypes import IntervalDtype
+
+from pandas import (
+    Categorical,
+    CategoricalDtype,
+    CategoricalIndex,
+    Index,
+    Interval,
+    IntervalIndex,
+    date_range,
+    notna,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+from pandas.core.arrays import IntervalArray
+import pandas.core.common as com
+
+
+@pytest.fixture(params=[None, "foo"])
+def name(request):
+    return request.param
+
+
+class ConstructorTests:
+    """
+    Common tests for all variations of IntervalIndex construction. Input data
+    to be supplied in breaks format, then converted by the subclass method
+    get_kwargs_from_breaks to the expected format.
+    """
+
+    @pytest.fixture(
+        params=[
+            ([3, 14, 15, 92, 653], np.int64),
+            (np.arange(10, dtype="int64"), np.int64),
+            (Index(np.arange(-10, 11, dtype=np.int64)), np.int64),
+            (Index(np.arange(10, 31, dtype=np.uint64)), np.uint64),
+            (Index(np.arange(20, 30, 0.5), dtype=np.float64), np.float64),
+            (date_range("20180101", periods=10), "<M8[ns]"),
+            (
+                date_range("20180101", periods=10, tz="US/Eastern"),
+                "datetime64[ns, US/Eastern]",
+            ),
+            (timedelta_range("1 day", periods=10), "<m8[ns]"),
+        ]
+    )
+    def breaks_and_expected_subtype(self, request):
+        return request.param
+
+    def test_constructor(self, constructor, breaks_and_expected_subtype, closed, name):
+        breaks, expected_subtype = breaks_and_expected_subtype
+
+        result_kwargs = self.get_kwargs_from_breaks(breaks, closed)
+
+        result = constructor(closed=closed, name=name, **result_kwargs)
+
+        assert result.closed == closed
+        assert result.name == name
+        assert result.dtype.subtype == expected_subtype
+        tm.assert_index_equal(result.left, Index(breaks[:-1], dtype=expected_subtype))
+        tm.assert_index_equal(result.right, Index(breaks[1:], dtype=expected_subtype))
+
+    @pytest.mark.parametrize(
+        "breaks, subtype",
+        [
+            (Index([0, 1, 2, 3, 4], dtype=np.int64), "float64"),
+            (Index([0, 1, 2, 3, 4], dtype=np.int64), "datetime64[ns]"),
+            (Index([0, 1, 2, 3, 4], dtype=np.int64), "timedelta64[ns]"),
+            (Index([0, 1, 2, 3, 4], dtype=np.float64), "int64"),
+            (date_range("2017-01-01", periods=5), "int64"),
+            (timedelta_range("1 day", periods=5), "int64"),
+        ],
+    )
+    def test_constructor_dtype(self, constructor, breaks, subtype):
+        # GH 19262: conversion via dtype parameter
+        expected_kwargs = self.get_kwargs_from_breaks(breaks.astype(subtype))
+        expected = constructor(**expected_kwargs)
+
+        result_kwargs = self.get_kwargs_from_breaks(breaks)
+        iv_dtype = IntervalDtype(subtype, "right")
+        for dtype in (iv_dtype, str(iv_dtype)):
+            result = constructor(dtype=dtype, **result_kwargs)
+            tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "breaks",
+        [
+            Index([0, 1, 2, 3, 4], dtype=np.int64),
+            Index([0, 1, 2, 3, 4], dtype=np.uint64),
+            Index([0, 1, 2, 3, 4], dtype=np.float64),
+            date_range("2017-01-01", periods=5),
+            timedelta_range("1 day", periods=5),
+        ],
+    )
+    def test_constructor_pass_closed(self, constructor, breaks):
+        # not passing closed to IntervalDtype, but to IntervalArray constructor
+        iv_dtype = IntervalDtype(breaks.dtype)
+
+        result_kwargs = self.get_kwargs_from_breaks(breaks)
+
+        for dtype in (iv_dtype, str(iv_dtype)):
+            with tm.assert_produces_warning(None):
+                result = constructor(dtype=dtype, closed="left", **result_kwargs)
+            assert result.dtype.closed == "left"
+
+    @pytest.mark.parametrize("breaks", [[np.nan] * 2, [np.nan] * 4, [np.nan] * 50])
+    def test_constructor_nan(self, constructor, breaks, closed):
+        # GH 18421
+        result_kwargs = self.get_kwargs_from_breaks(breaks)
+        result = constructor(closed=closed, **result_kwargs)
+
+        expected_subtype = np.float64
+        expected_values = np.array(breaks[:-1], dtype=object)
+
+        assert result.closed == closed
+        assert result.dtype.subtype == expected_subtype
+        tm.assert_numpy_array_equal(np.array(result), expected_values)
+
+    @pytest.mark.parametrize(
+        "breaks",
+        [
+            [],
+            np.array([], dtype="int64"),
+            np.array([], dtype="uint64"),
+            np.array([], dtype="float64"),
+            np.array([], dtype="datetime64[ns]"),
+            np.array([], dtype="timedelta64[ns]"),
+        ],
+    )
+    def test_constructor_empty(self, constructor, breaks, closed):
+        # GH 18421
+        result_kwargs = self.get_kwargs_from_breaks(breaks)
+        result = constructor(closed=closed, **result_kwargs)
+
+        expected_values = np.array([], dtype=object)
+        expected_subtype = getattr(breaks, "dtype", np.int64)
+
+        assert result.empty
+        assert result.closed == closed
+        assert result.dtype.subtype == expected_subtype
+        tm.assert_numpy_array_equal(np.array(result), expected_values)
+
+    @pytest.mark.parametrize(
+        "breaks",
+        [
+            tuple("0123456789"),
+            list("abcdefghij"),
+            np.array(list("abcdefghij"), dtype=object),
+            np.array(list("abcdefghij"), dtype="<U1"),
+        ],
+    )
+    def test_constructor_string(self, constructor, breaks):
+        # GH 19016
+        msg = (
+            "category, object, and string subtypes are not supported "
+            "for IntervalIndex"
+        )
+        with pytest.raises(TypeError, match=msg):
+            constructor(**self.get_kwargs_from_breaks(breaks))
+
+    @pytest.mark.parametrize("cat_constructor", [Categorical, CategoricalIndex])
+    def test_constructor_categorical_valid(self, constructor, cat_constructor):
+        # GH 21243/21253
+
+        breaks = np.arange(10, dtype="int64")
+        expected = IntervalIndex.from_breaks(breaks)
+
+        cat_breaks = cat_constructor(breaks)
+        result_kwargs = self.get_kwargs_from_breaks(cat_breaks)
+        result = constructor(**result_kwargs)
+        tm.assert_index_equal(result, expected)
+
+    def test_generic_errors(self, constructor):
+        # filler input data to be used when supplying invalid kwargs
+        filler = self.get_kwargs_from_breaks(range(10))
+
+        # invalid closed
+        msg = "closed must be one of 'right', 'left', 'both', 'neither'"
+        with pytest.raises(ValueError, match=msg):
+            constructor(closed="invalid", **filler)
+
+        # unsupported dtype
+        msg = "dtype must be an IntervalDtype, got int64"
+        with pytest.raises(TypeError, match=msg):
+            constructor(dtype="int64", **filler)
+
+        # invalid dtype
+        msg = "data type [\"']invalid[\"'] not understood"
+        with pytest.raises(TypeError, match=msg):
+            constructor(dtype="invalid", **filler)
+
+        # no point in nesting periods in an IntervalIndex
+        periods = period_range("2000-01-01", periods=10)
+        periods_kwargs = self.get_kwargs_from_breaks(periods)
+        msg = "Period dtypes are not supported, use a PeriodIndex instead"
+        with pytest.raises(ValueError, match=msg):
+            constructor(**periods_kwargs)
+
+        # decreasing values
+        decreasing_kwargs = self.get_kwargs_from_breaks(range(10, -1, -1))
+        msg = "left side of interval must be <= right side"
+        with pytest.raises(ValueError, match=msg):
+            constructor(**decreasing_kwargs)
+
+
+class TestFromArrays(ConstructorTests):
+    """Tests specific to IntervalIndex.from_arrays"""
+
+    @pytest.fixture
+    def constructor(self):
+        return IntervalIndex.from_arrays
+
+    def get_kwargs_from_breaks(self, breaks, closed="right"):
+        """
+        converts intervals in breaks format to a dictionary of kwargs to
+        specific to the format expected by IntervalIndex.from_arrays
+        """
+        return {"left": breaks[:-1], "right": breaks[1:]}
+
+    def test_constructor_errors(self):
+        # GH 19016: categorical data
+        data = Categorical(list("01234abcde"), ordered=True)
+        msg = (
+            "category, object, and string subtypes are not supported "
+            "for IntervalIndex"
+        )
+        with pytest.raises(TypeError, match=msg):
+            IntervalIndex.from_arrays(data[:-1], data[1:])
+
+        # unequal length
+        left = [0, 1, 2]
+        right = [2, 3]
+        msg = "left and right must have the same length"
+        with pytest.raises(ValueError, match=msg):
+            IntervalIndex.from_arrays(left, right)
+
+    @pytest.mark.parametrize(
+        "left_subtype, right_subtype", [(np.int64, np.float64), (np.float64, np.int64)]
+    )
+    def test_mixed_float_int(self, left_subtype, right_subtype):
+        """mixed int/float left/right results in float for both sides"""
+        left = np.arange(9, dtype=left_subtype)
+        right = np.arange(1, 10, dtype=right_subtype)
+        result = IntervalIndex.from_arrays(left, right)
+
+        expected_left = Index(left, dtype=np.float64)
+        expected_right = Index(right, dtype=np.float64)
+        expected_subtype = np.float64
+
+        tm.assert_index_equal(result.left, expected_left)
+        tm.assert_index_equal(result.right, expected_right)
+        assert result.dtype.subtype == expected_subtype
+
+    @pytest.mark.parametrize("interval_cls", [IntervalArray, IntervalIndex])
+    def test_from_arrays_mismatched_datetimelike_resos(self, interval_cls):
+        # GH#55714
+        left = date_range("2016-01-01", periods=3, unit="s")
+        right = date_range("2017-01-01", periods=3, unit="ms")
+        result = interval_cls.from_arrays(left, right)
+        expected = interval_cls.from_arrays(left.as_unit("ms"), right)
+        tm.assert_equal(result, expected)
+
+        # td64
+        left2 = left - left[0]
+        right2 = right - left[0]
+        result2 = interval_cls.from_arrays(left2, right2)
+        expected2 = interval_cls.from_arrays(left2.as_unit("ms"), right2)
+        tm.assert_equal(result2, expected2)
+
+        # dt64tz
+        left3 = left.tz_localize("UTC")
+        right3 = right.tz_localize("UTC")
+        result3 = interval_cls.from_arrays(left3, right3)
+        expected3 = interval_cls.from_arrays(left3.as_unit("ms"), right3)
+        tm.assert_equal(result3, expected3)
+
+
+class TestFromBreaks(ConstructorTests):
+    """Tests specific to IntervalIndex.from_breaks"""
+
+    @pytest.fixture
+    def constructor(self):
+        return IntervalIndex.from_breaks
+
+    def get_kwargs_from_breaks(self, breaks, closed="right"):
+        """
+        converts intervals in breaks format to a dictionary of kwargs to
+        specific to the format expected by IntervalIndex.from_breaks
+        """
+        return {"breaks": breaks}
+
+    def test_constructor_errors(self):
+        # GH 19016: categorical data
+        data = Categorical(list("01234abcde"), ordered=True)
+        msg = (
+            "category, object, and string subtypes are not supported "
+            "for IntervalIndex"
+        )
+        with pytest.raises(TypeError, match=msg):
+            IntervalIndex.from_breaks(data)
+
+    def test_length_one(self):
+        """breaks of length one produce an empty IntervalIndex"""
+        breaks = [0]
+        result = IntervalIndex.from_breaks(breaks)
+        expected = IntervalIndex.from_breaks([])
+        tm.assert_index_equal(result, expected)
+
+    def test_left_right_dont_share_data(self):
+        # GH#36310
+        breaks = np.arange(5)
+        result = IntervalIndex.from_breaks(breaks)._data
+        assert result._left.base is None or result._left.base is not result._right.base
+
+
+class TestFromTuples(ConstructorTests):
+    """Tests specific to IntervalIndex.from_tuples"""
+
+    @pytest.fixture
+    def constructor(self):
+        return IntervalIndex.from_tuples
+
+    def get_kwargs_from_breaks(self, breaks, closed="right"):
+        """
+        converts intervals in breaks format to a dictionary of kwargs to
+        specific to the format expected by IntervalIndex.from_tuples
+        """
+        if is_unsigned_integer_dtype(breaks):
+            pytest.skip(f"{breaks.dtype} not relevant IntervalIndex.from_tuples tests")
+
+        if len(breaks) == 0:
+            return {"data": breaks}
+
+        tuples = list(zip(breaks[:-1], breaks[1:]))
+        if isinstance(breaks, (list, tuple)):
+            return {"data": tuples}
+        elif isinstance(getattr(breaks, "dtype", None), CategoricalDtype):
+            return {"data": breaks._constructor(tuples)}
+        return {"data": com.asarray_tuplesafe(tuples)}
+
+    def test_constructor_errors(self):
+        # non-tuple
+        tuples = [(0, 1), 2, (3, 4)]
+        msg = "IntervalIndex.from_tuples received an invalid item, 2"
+        with pytest.raises(TypeError, match=msg.format(t=tuples)):
+            IntervalIndex.from_tuples(tuples)
+
+        # too few/many items
+        tuples = [(0, 1), (2,), (3, 4)]
+        msg = "IntervalIndex.from_tuples requires tuples of length 2, got {t}"
+        with pytest.raises(ValueError, match=msg.format(t=tuples)):
+            IntervalIndex.from_tuples(tuples)
+
+        tuples = [(0, 1), (2, 3, 4), (5, 6)]
+        with pytest.raises(ValueError, match=msg.format(t=tuples)):
+            IntervalIndex.from_tuples(tuples)
+
+    def test_na_tuples(self):
+        # tuple (NA, NA) evaluates the same as NA as an element
+        na_tuple = [(0, 1), (np.nan, np.nan), (2, 3)]
+        idx_na_tuple = IntervalIndex.from_tuples(na_tuple)
+        idx_na_element = IntervalIndex.from_tuples([(0, 1), np.nan, (2, 3)])
+        tm.assert_index_equal(idx_na_tuple, idx_na_element)
+
+
+class TestClassConstructors(ConstructorTests):
+    """Tests specific to the IntervalIndex/Index constructors"""
+
+    @pytest.fixture(
+        params=[IntervalIndex, partial(Index, dtype="interval")],
+        ids=["IntervalIndex", "Index"],
+    )
+    def klass(self, request):
+        # We use a separate fixture here to include Index.__new__ with dtype kwarg
+        return request.param
+
+    @pytest.fixture
+    def constructor(self):
+        return IntervalIndex
+
+    def get_kwargs_from_breaks(self, breaks, closed="right"):
+        """
+        converts intervals in breaks format to a dictionary of kwargs to
+        specific to the format expected by the IntervalIndex/Index constructors
+        """
+        if is_unsigned_integer_dtype(breaks):
+            pytest.skip(f"{breaks.dtype} not relevant for class constructor tests")
+
+        if len(breaks) == 0:
+            return {"data": breaks}
+
+        ivs = [
+            Interval(left, right, closed) if notna(left) else left
+            for left, right in zip(breaks[:-1], breaks[1:])
+        ]
+
+        if isinstance(breaks, list):
+            return {"data": ivs}
+        elif isinstance(getattr(breaks, "dtype", None), CategoricalDtype):
+            return {"data": breaks._constructor(ivs)}
+        return {"data": np.array(ivs, dtype=object)}
+
+    def test_generic_errors(self, constructor):
+        """
+        override the base class implementation since errors are handled
+        differently; checks unnecessary since caught at the Interval level
+        """
+
+    def test_constructor_string(self):
+        # GH23013
+        # When forming the interval from breaks,
+        # the interval of strings is already forbidden.
+        pass
+
+    def test_constructor_errors(self, klass):
+        # mismatched closed within intervals with no constructor override
+        ivs = [Interval(0, 1, closed="right"), Interval(2, 3, closed="left")]
+        msg = "intervals must all be closed on the same side"
+        with pytest.raises(ValueError, match=msg):
+            klass(ivs)
+
+        # scalar
+        msg = (
+            r"(IntervalIndex|Index)\(...\) must be called with a collection of "
+            "some kind, 5 was passed"
+        )
+        with pytest.raises(TypeError, match=msg):
+            klass(5)
+
+        # not an interval; dtype depends on 32bit/windows builds
+        msg = "type <class 'numpy.int(32|64)'> with value 0 is not an interval"
+        with pytest.raises(TypeError, match=msg):
+            klass([0, 1])
+
+    @pytest.mark.parametrize(
+        "data, closed",
+        [
+            ([], "both"),
+            ([np.nan, np.nan], "neither"),
+            (
+                [Interval(0, 3, closed="neither"), Interval(2, 5, closed="neither")],
+                "left",
+            ),
+            (
+                [Interval(0, 3, closed="left"), Interval(2, 5, closed="right")],
+                "neither",
+            ),
+            (IntervalIndex.from_breaks(range(5), closed="both"), "right"),
+        ],
+    )
+    def test_override_inferred_closed(self, constructor, data, closed):
+        # GH 19370
+        if isinstance(data, IntervalIndex):
+            tuples = data.to_tuples()
+        else:
+            tuples = [(iv.left, iv.right) if notna(iv) else iv for iv in data]
+        expected = IntervalIndex.from_tuples(tuples, closed=closed)
+        result = constructor(data, closed=closed)
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "values_constructor", [list, np.array, IntervalIndex, IntervalArray]
+    )
+    def test_index_object_dtype(self, values_constructor):
+        # Index(intervals, dtype=object) is an Index (not an IntervalIndex)
+        intervals = [Interval(0, 1), Interval(1, 2), Interval(2, 3)]
+        values = values_constructor(intervals)
+        result = Index(values, dtype=object)
+
+        assert type(result) is Index
+        tm.assert_numpy_array_equal(result.values, np.array(values))
+
+    def test_index_mixed_closed(self):
+        # GH27172
+        intervals = [
+            Interval(0, 1, closed="left"),
+            Interval(1, 2, closed="right"),
+            Interval(2, 3, closed="neither"),
+            Interval(3, 4, closed="both"),
+        ]
+        result = Index(intervals)
+        expected = Index(intervals, dtype=object)
+        tm.assert_index_equal(result, expected)
+
+
+@pytest.mark.parametrize("timezone", ["UTC", "US/Pacific", "GMT"])
+def test_interval_index_subtype(timezone, inclusive_endpoints_fixture):
+    # GH#46999
+    dates = date_range("2022", periods=3, tz=timezone)
+    dtype = f"interval[datetime64[ns, {timezone}], {inclusive_endpoints_fixture}]"
+    result = IntervalIndex.from_arrays(
+        ["2022-01-01", "2022-01-02"],
+        ["2022-01-02", "2022-01-03"],
+        closed=inclusive_endpoints_fixture,
+        dtype=dtype,
+    )
+    expected = IntervalIndex.from_arrays(
+        dates[:-1], dates[1:], closed=inclusive_endpoints_fixture
+    )
+    tm.assert_index_equal(result, expected)
+
+
+def test_dtype_closed_mismatch():
+    # GH#38394 closed specified in both dtype and IntervalIndex constructor
+
+    dtype = IntervalDtype(np.int64, "left")
+
+    msg = "closed keyword does not match dtype.closed"
+    with pytest.raises(ValueError, match=msg):
+        IntervalIndex([], dtype=dtype, closed="neither")
+
+    with pytest.raises(ValueError, match=msg):
+        IntervalArray([], dtype=dtype, closed="neither")
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    ["Float64", pytest.param("float64[pyarrow]", marks=td.skip_if_no("pyarrow"))],
+)
+def test_ea_dtype(dtype):
+    # GH#56765
+    bins = [(0.0, 0.4), (0.4, 0.6)]
+    interval_dtype = IntervalDtype(subtype=dtype, closed="left")
+    result = IntervalIndex.from_tuples(bins, closed="left", dtype=interval_dtype)
+    assert result.dtype == interval_dtype
+    expected = IntervalIndex.from_tuples(bins, closed="left").astype(interval_dtype)
+    tm.assert_index_equal(result, expected)
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_equals.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_equals.py
new file mode 100644
index 0000000000000000000000000000000000000000..87e2348e5fdb331d80061d184f41e1ab11bedcc3
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_equals.py
@@ -0,0 +1,36 @@
+import numpy as np
+
+from pandas import (
+    IntervalIndex,
+    date_range,
+)
+
+
+class TestEquals:
+    def test_equals(self, closed):
+        expected = IntervalIndex.from_breaks(np.arange(5), closed=closed)
+        assert expected.equals(expected)
+        assert expected.equals(expected.copy())
+
+        assert not expected.equals(expected.astype(object))
+        assert not expected.equals(np.array(expected))
+        assert not expected.equals(list(expected))
+
+        assert not expected.equals([1, 2])
+        assert not expected.equals(np.array([1, 2]))
+        assert not expected.equals(date_range("20130101", periods=2))
+
+        expected_name1 = IntervalIndex.from_breaks(
+            np.arange(5), closed=closed, name="foo"
+        )
+        expected_name2 = IntervalIndex.from_breaks(
+            np.arange(5), closed=closed, name="bar"
+        )
+        assert expected.equals(expected_name1)
+        assert expected_name1.equals(expected_name2)
+
+        for other_closed in {"left", "right", "both", "neither"} - {closed}:
+            expected_other_closed = IntervalIndex.from_breaks(
+                np.arange(5), closed=other_closed
+            )
+            assert not expected.equals(expected_other_closed)
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_formats.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_formats.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b8e18463160f0364c289b7edb36023ca7a6428f
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_formats.py
@@ -0,0 +1,119 @@
+import numpy as np
+import pytest
+
+from pandas._config import using_pyarrow_string_dtype
+
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    Interval,
+    IntervalIndex,
+    Series,
+    Timedelta,
+    Timestamp,
+)
+import pandas._testing as tm
+
+
+class TestIntervalIndexRendering:
+    # TODO: this is a test for DataFrame/Series, not IntervalIndex
+    @pytest.mark.parametrize(
+        "constructor,expected",
+        [
+            (
+                Series,
+                (
+                    "(0.0, 1.0]    a\n"
+                    "NaN           b\n"
+                    "(2.0, 3.0]    c\n"
+                    "dtype: object"
+                ),
+            ),
+            (DataFrame, ("            0\n(0.0, 1.0]  a\nNaN         b\n(2.0, 3.0]  c")),
+        ],
+    )
+    def test_repr_missing(self, constructor, expected, using_infer_string, request):
+        # GH 25984
+        if using_infer_string and constructor is Series:
+            request.applymarker(pytest.mark.xfail(reason="repr different"))
+        index = IntervalIndex.from_tuples([(0, 1), np.nan, (2, 3)])
+        obj = constructor(list("abc"), index=index)
+        result = repr(obj)
+        assert result == expected
+
+    @pytest.mark.xfail(using_pyarrow_string_dtype(), reason="repr different")
+    def test_repr_floats(self):
+        # GH 32553
+
+        markers = Series(
+            ["foo", "bar"],
+            index=IntervalIndex(
+                [
+                    Interval(left, right)
+                    for left, right in zip(
+                        Index([329.973, 345.137], dtype="float64"),
+                        Index([345.137, 360.191], dtype="float64"),
+                    )
+                ]
+            ),
+        )
+        result = str(markers)
+        expected = "(329.973, 345.137]    foo\n(345.137, 360.191]    bar\ndtype: object"
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "tuples, closed, expected_data",
+        [
+            ([(0, 1), (1, 2), (2, 3)], "left", ["[0, 1)", "[1, 2)", "[2, 3)"]),
+            (
+                [(0.5, 1.0), np.nan, (2.0, 3.0)],
+                "right",
+                ["(0.5, 1.0]", "NaN", "(2.0, 3.0]"],
+            ),
+            (
+                [
+                    (Timestamp("20180101"), Timestamp("20180102")),
+                    np.nan,
+                    ((Timestamp("20180102"), Timestamp("20180103"))),
+                ],
+                "both",
+                [
+                    "[2018-01-01 00:00:00, 2018-01-02 00:00:00]",
+                    "NaN",
+                    "[2018-01-02 00:00:00, 2018-01-03 00:00:00]",
+                ],
+            ),
+            (
+                [
+                    (Timedelta("0 days"), Timedelta("1 days")),
+                    (Timedelta("1 days"), Timedelta("2 days")),
+                    np.nan,
+                ],
+                "neither",
+                [
+                    "(0 days 00:00:00, 1 days 00:00:00)",
+                    "(1 days 00:00:00, 2 days 00:00:00)",
+                    "NaN",
+                ],
+            ),
+        ],
+    )
+    def test_get_values_for_csv(self, tuples, closed, expected_data):
+        # GH 28210
+        index = IntervalIndex.from_tuples(tuples, closed=closed)
+        result = index._get_values_for_csv(na_rep="NaN")
+        expected = np.array(expected_data)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_timestamp_with_timezone(self, unit):
+        # GH 55035
+        left = DatetimeIndex(["2020-01-01"], dtype=f"M8[{unit}, UTC]")
+        right = DatetimeIndex(["2020-01-02"], dtype=f"M8[{unit}, UTC]")
+        index = IntervalIndex.from_arrays(left, right)
+        result = repr(index)
+        expected = (
+            "IntervalIndex([(2020-01-01 00:00:00+00:00, 2020-01-02 00:00:00+00:00]], "
+            f"dtype='interval[datetime64[{unit}, UTC], right]')"
+        )
+        assert result == expected
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_indexing.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_indexing.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd03047b2c1274294a927c4505b63d04460a5878
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_indexing.py
@@ -0,0 +1,671 @@
+import re
+
+import numpy as np
+import pytest
+
+from pandas.errors import InvalidIndexError
+
+from pandas import (
+    NA,
+    CategoricalIndex,
+    DatetimeIndex,
+    Index,
+    Interval,
+    IntervalIndex,
+    MultiIndex,
+    NaT,
+    Timedelta,
+    Timestamp,
+    array,
+    date_range,
+    interval_range,
+    isna,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+
+
+class TestGetItem:
+    def test_getitem(self, closed):
+        idx = IntervalIndex.from_arrays((0, 1, np.nan), (1, 2, np.nan), closed=closed)
+        assert idx[0] == Interval(0.0, 1.0, closed=closed)
+        assert idx[1] == Interval(1.0, 2.0, closed=closed)
+        assert isna(idx[2])
+
+        result = idx[0:1]
+        expected = IntervalIndex.from_arrays((0.0,), (1.0,), closed=closed)
+        tm.assert_index_equal(result, expected)
+
+        result = idx[0:2]
+        expected = IntervalIndex.from_arrays((0.0, 1), (1.0, 2.0), closed=closed)
+        tm.assert_index_equal(result, expected)
+
+        result = idx[1:3]
+        expected = IntervalIndex.from_arrays(
+            (1.0, np.nan), (2.0, np.nan), closed=closed
+        )
+        tm.assert_index_equal(result, expected)
+
+    def test_getitem_2d_deprecated(self):
+        # GH#30588 multi-dim indexing is deprecated, but raising is also acceptable
+        idx = IntervalIndex.from_breaks(range(11), closed="right")
+        with pytest.raises(ValueError, match="multi-dimensional indexing not allowed"):
+            idx[:, None]
+        with pytest.raises(ValueError, match="multi-dimensional indexing not allowed"):
+            # GH#44051
+            idx[True]
+        with pytest.raises(ValueError, match="multi-dimensional indexing not allowed"):
+            # GH#44051
+            idx[False]
+
+
+class TestWhere:
+    def test_where(self, listlike_box):
+        klass = listlike_box
+
+        idx = IntervalIndex.from_breaks(range(11), closed="right")
+        cond = [True] * len(idx)
+        expected = idx
+        result = expected.where(klass(cond))
+        tm.assert_index_equal(result, expected)
+
+        cond = [False] + [True] * len(idx[1:])
+        expected = IntervalIndex([np.nan] + idx[1:].tolist())
+        result = idx.where(klass(cond))
+        tm.assert_index_equal(result, expected)
+
+
+class TestTake:
+    def test_take(self, closed):
+        index = IntervalIndex.from_breaks(range(11), closed=closed)
+
+        result = index.take(range(10))
+        tm.assert_index_equal(result, index)
+
+        result = index.take([0, 0, 1])
+        expected = IntervalIndex.from_arrays([0, 0, 1], [1, 1, 2], closed=closed)
+        tm.assert_index_equal(result, expected)
+
+
+class TestGetLoc:
+    @pytest.mark.parametrize("side", ["right", "left", "both", "neither"])
+    def test_get_loc_interval(self, closed, side):
+        idx = IntervalIndex.from_tuples([(0, 1), (2, 3)], closed=closed)
+
+        for bound in [[0, 1], [1, 2], [2, 3], [3, 4], [0, 2], [2.5, 3], [-1, 4]]:
+            # if get_loc is supplied an interval, it should only search
+            # for exact matches, not overlaps or covers, else KeyError.
+            msg = re.escape(f"Interval({bound[0]}, {bound[1]}, closed='{side}')")
+            if closed == side:
+                if bound == [0, 1]:
+                    assert idx.get_loc(Interval(0, 1, closed=side)) == 0
+                elif bound == [2, 3]:
+                    assert idx.get_loc(Interval(2, 3, closed=side)) == 1
+                else:
+                    with pytest.raises(KeyError, match=msg):
+                        idx.get_loc(Interval(*bound, closed=side))
+            else:
+                with pytest.raises(KeyError, match=msg):
+                    idx.get_loc(Interval(*bound, closed=side))
+
+    @pytest.mark.parametrize("scalar", [-0.5, 0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5])
+    def test_get_loc_scalar(self, closed, scalar):
+        # correct = {side: {query: answer}}.
+        # If query is not in the dict, that query should raise a KeyError
+        correct = {
+            "right": {0.5: 0, 1: 0, 2.5: 1, 3: 1},
+            "left": {0: 0, 0.5: 0, 2: 1, 2.5: 1},
+            "both": {0: 0, 0.5: 0, 1: 0, 2: 1, 2.5: 1, 3: 1},
+            "neither": {0.5: 0, 2.5: 1},
+        }
+
+        idx = IntervalIndex.from_tuples([(0, 1), (2, 3)], closed=closed)
+
+        # if get_loc is supplied a scalar, it should return the index of
+        # the interval which contains the scalar, or KeyError.
+        if scalar in correct[closed].keys():
+            assert idx.get_loc(scalar) == correct[closed][scalar]
+        else:
+            with pytest.raises(KeyError, match=str(scalar)):
+                idx.get_loc(scalar)
+
+    @pytest.mark.parametrize("scalar", [-1, 0, 0.5, 3, 4.5, 5, 6])
+    def test_get_loc_length_one_scalar(self, scalar, closed):
+        # GH 20921
+        index = IntervalIndex.from_tuples([(0, 5)], closed=closed)
+        if scalar in index[0]:
+            result = index.get_loc(scalar)
+            assert result == 0
+        else:
+            with pytest.raises(KeyError, match=str(scalar)):
+                index.get_loc(scalar)
+
+    @pytest.mark.parametrize("other_closed", ["left", "right", "both", "neither"])
+    @pytest.mark.parametrize("left, right", [(0, 5), (-1, 4), (-1, 6), (6, 7)])
+    def test_get_loc_length_one_interval(self, left, right, closed, other_closed):
+        # GH 20921
+        index = IntervalIndex.from_tuples([(0, 5)], closed=closed)
+        interval = Interval(left, right, closed=other_closed)
+        if interval == index[0]:
+            result = index.get_loc(interval)
+            assert result == 0
+        else:
+            with pytest.raises(
+                KeyError,
+                match=re.escape(f"Interval({left}, {right}, closed='{other_closed}')"),
+            ):
+                index.get_loc(interval)
+
+    # Make consistent with test_interval_new.py (see #16316, #16386)
+    @pytest.mark.parametrize(
+        "breaks",
+        [
+            date_range("20180101", periods=4),
+            date_range("20180101", periods=4, tz="US/Eastern"),
+            timedelta_range("0 days", periods=4),
+        ],
+        ids=lambda x: str(x.dtype),
+    )
+    def test_get_loc_datetimelike_nonoverlapping(self, breaks):
+        # GH 20636
+        # nonoverlapping = IntervalIndex method and no i8 conversion
+        index = IntervalIndex.from_breaks(breaks)
+
+        value = index[0].mid
+        result = index.get_loc(value)
+        expected = 0
+        assert result == expected
+
+        interval = Interval(index[0].left, index[0].right)
+        result = index.get_loc(interval)
+        expected = 0
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "arrays",
+        [
+            (date_range("20180101", periods=4), date_range("20180103", periods=4)),
+            (
+                date_range("20180101", periods=4, tz="US/Eastern"),
+                date_range("20180103", periods=4, tz="US/Eastern"),
+            ),
+            (
+                timedelta_range("0 days", periods=4),
+                timedelta_range("2 days", periods=4),
+            ),
+        ],
+        ids=lambda x: str(x[0].dtype),
+    )
+    def test_get_loc_datetimelike_overlapping(self, arrays):
+        # GH 20636
+        index = IntervalIndex.from_arrays(*arrays)
+
+        value = index[0].mid + Timedelta("12 hours")
+        result = index.get_loc(value)
+        expected = slice(0, 2, None)
+        assert result == expected
+
+        interval = Interval(index[0].left, index[0].right)
+        result = index.get_loc(interval)
+        expected = 0
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "values",
+        [
+            date_range("2018-01-04", periods=4, freq="-1D"),
+            date_range("2018-01-04", periods=4, freq="-1D", tz="US/Eastern"),
+            timedelta_range("3 days", periods=4, freq="-1D"),
+            np.arange(3.0, -1.0, -1.0),
+            np.arange(3, -1, -1),
+        ],
+        ids=lambda x: str(x.dtype),
+    )
+    def test_get_loc_decreasing(self, values):
+        # GH 25860
+        index = IntervalIndex.from_arrays(values[1:], values[:-1])
+        result = index.get_loc(index[0])
+        expected = 0
+        assert result == expected
+
+    @pytest.mark.parametrize("key", [[5], (2, 3)])
+    def test_get_loc_non_scalar_errors(self, key):
+        # GH 31117
+        idx = IntervalIndex.from_tuples([(1, 3), (2, 4), (3, 5), (7, 10), (3, 10)])
+
+        msg = str(key)
+        with pytest.raises(InvalidIndexError, match=msg):
+            idx.get_loc(key)
+
+    def test_get_indexer_with_nans(self):
+        # GH#41831
+        index = IntervalIndex([np.nan, Interval(1, 2), np.nan])
+
+        expected = np.array([True, False, True])
+        for key in [None, np.nan, NA]:
+            assert key in index
+            result = index.get_loc(key)
+            tm.assert_numpy_array_equal(result, expected)
+
+        for key in [NaT, np.timedelta64("NaT", "ns"), np.datetime64("NaT", "ns")]:
+            with pytest.raises(KeyError, match=str(key)):
+                index.get_loc(key)
+
+
+class TestGetIndexer:
+    @pytest.mark.parametrize(
+        "query, expected",
+        [
+            ([Interval(2, 4, closed="right")], [1]),
+            ([Interval(2, 4, closed="left")], [-1]),
+            ([Interval(2, 4, closed="both")], [-1]),
+            ([Interval(2, 4, closed="neither")], [-1]),
+            ([Interval(1, 4, closed="right")], [-1]),
+            ([Interval(0, 4, closed="right")], [-1]),
+            ([Interval(0.5, 1.5, closed="right")], [-1]),
+            ([Interval(2, 4, closed="right"), Interval(0, 1, closed="right")], [1, -1]),
+            ([Interval(2, 4, closed="right"), Interval(2, 4, closed="right")], [1, 1]),
+            ([Interval(5, 7, closed="right"), Interval(2, 4, closed="right")], [2, 1]),
+            ([Interval(2, 4, closed="right"), Interval(2, 4, closed="left")], [1, -1]),
+        ],
+    )
+    def test_get_indexer_with_interval(self, query, expected):
+        tuples = [(0, 2), (2, 4), (5, 7)]
+        index = IntervalIndex.from_tuples(tuples, closed="right")
+
+        result = index.get_indexer(query)
+        expected = np.array(expected, dtype="intp")
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "query, expected",
+        [
+            ([-0.5], [-1]),
+            ([0], [-1]),
+            ([0.5], [0]),
+            ([1], [0]),
+            ([1.5], [1]),
+            ([2], [1]),
+            ([2.5], [-1]),
+            ([3], [-1]),
+            ([3.5], [2]),
+            ([4], [2]),
+            ([4.5], [-1]),
+            ([1, 2], [0, 1]),
+            ([1, 2, 3], [0, 1, -1]),
+            ([1, 2, 3, 4], [0, 1, -1, 2]),
+            ([1, 2, 3, 4, 2], [0, 1, -1, 2, 1]),
+        ],
+    )
+    def test_get_indexer_with_int_and_float(self, query, expected):
+        tuples = [(0, 1), (1, 2), (3, 4)]
+        index = IntervalIndex.from_tuples(tuples, closed="right")
+
+        result = index.get_indexer(query)
+        expected = np.array(expected, dtype="intp")
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("item", [[3], np.arange(0.5, 5, 0.5)])
+    def test_get_indexer_length_one(self, item, closed):
+        # GH 17284
+        index = IntervalIndex.from_tuples([(0, 5)], closed=closed)
+        result = index.get_indexer(item)
+        expected = np.array([0] * len(item), dtype="intp")
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("size", [1, 5])
+    def test_get_indexer_length_one_interval(self, size, closed):
+        # GH 17284
+        index = IntervalIndex.from_tuples([(0, 5)], closed=closed)
+        result = index.get_indexer([Interval(0, 5, closed)] * size)
+        expected = np.array([0] * size, dtype="intp")
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "target",
+        [
+            IntervalIndex.from_tuples([(7, 8), (1, 2), (3, 4), (0, 1)]),
+            IntervalIndex.from_tuples([(0, 1), (1, 2), (3, 4), np.nan]),
+            IntervalIndex.from_tuples([(0, 1), (1, 2), (3, 4)], closed="both"),
+            [-1, 0, 0.5, 1, 2, 2.5, np.nan],
+            ["foo", "foo", "bar", "baz"],
+        ],
+    )
+    def test_get_indexer_categorical(self, target, ordered):
+        # GH 30063: categorical and non-categorical results should be consistent
+        index = IntervalIndex.from_tuples([(0, 1), (1, 2), (3, 4)])
+        categorical_target = CategoricalIndex(target, ordered=ordered)
+
+        result = index.get_indexer(categorical_target)
+        expected = index.get_indexer(target)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_get_indexer_categorical_with_nans(self):
+        # GH#41934 nans in both index and in target
+        ii = IntervalIndex.from_breaks(range(5))
+        ii2 = ii.append(IntervalIndex([np.nan]))
+        ci2 = CategoricalIndex(ii2)
+
+        result = ii2.get_indexer(ci2)
+        expected = np.arange(5, dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # not-all-matches
+        result = ii2[1:].get_indexer(ci2[::-1])
+        expected = np.array([3, 2, 1, 0, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # non-unique target, non-unique nans
+        result = ii2.get_indexer(ci2.append(ci2))
+        expected = np.array([0, 1, 2, 3, 4, 0, 1, 2, 3, 4], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_get_indexer_datetime(self):
+        ii = IntervalIndex.from_breaks(date_range("2018-01-01", periods=4))
+        # TODO: with mismatched resolution get_indexer currently raises;
+        #  this should probably coerce?
+        target = DatetimeIndex(["2018-01-02"], dtype="M8[ns]")
+        result = ii.get_indexer(target)
+        expected = np.array([0], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = ii.get_indexer(target.astype(str))
+        tm.assert_numpy_array_equal(result, expected)
+
+        # https://github.com/pandas-dev/pandas/issues/47772
+        result = ii.get_indexer(target.asi8)
+        expected = np.array([-1], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "tuples, closed",
+        [
+            ([(0, 2), (1, 3), (3, 4)], "neither"),
+            ([(0, 5), (1, 4), (6, 7)], "left"),
+            ([(0, 1), (0, 1), (1, 2)], "right"),
+            ([(0, 1), (2, 3), (3, 4)], "both"),
+        ],
+    )
+    def test_get_indexer_errors(self, tuples, closed):
+        # IntervalIndex needs non-overlapping for uniqueness when querying
+        index = IntervalIndex.from_tuples(tuples, closed=closed)
+
+        msg = (
+            "cannot handle overlapping indices; use "
+            "IntervalIndex.get_indexer_non_unique"
+        )
+        with pytest.raises(InvalidIndexError, match=msg):
+            index.get_indexer([0, 2])
+
+    @pytest.mark.parametrize(
+        "query, expected",
+        [
+            ([-0.5], ([-1], [0])),
+            ([0], ([0], [])),
+            ([0.5], ([0], [])),
+            ([1], ([0, 1], [])),
+            ([1.5], ([0, 1], [])),
+            ([2], ([0, 1, 2], [])),
+            ([2.5], ([1, 2], [])),
+            ([3], ([2], [])),
+            ([3.5], ([2], [])),
+            ([4], ([-1], [0])),
+            ([4.5], ([-1], [0])),
+            ([1, 2], ([0, 1, 0, 1, 2], [])),
+            ([1, 2, 3], ([0, 1, 0, 1, 2, 2], [])),
+            ([1, 2, 3, 4], ([0, 1, 0, 1, 2, 2, -1], [3])),
+            ([1, 2, 3, 4, 2], ([0, 1, 0, 1, 2, 2, -1, 0, 1, 2], [3])),
+        ],
+    )
+    def test_get_indexer_non_unique_with_int_and_float(self, query, expected):
+        tuples = [(0, 2.5), (1, 3), (2, 4)]
+        index = IntervalIndex.from_tuples(tuples, closed="left")
+
+        result_indexer, result_missing = index.get_indexer_non_unique(query)
+        expected_indexer = np.array(expected[0], dtype="intp")
+        expected_missing = np.array(expected[1], dtype="intp")
+
+        tm.assert_numpy_array_equal(result_indexer, expected_indexer)
+        tm.assert_numpy_array_equal(result_missing, expected_missing)
+
+        # TODO we may also want to test get_indexer for the case when
+        # the intervals are duplicated, decreasing, non-monotonic, etc..
+
+    def test_get_indexer_non_monotonic(self):
+        # GH 16410
+        idx1 = IntervalIndex.from_tuples([(2, 3), (4, 5), (0, 1)])
+        idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (6, 7), (8, 9)])
+        result = idx1.get_indexer(idx2)
+        expected = np.array([2, 0, -1, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = idx1.get_indexer(idx1[1:])
+        expected = np.array([1, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_get_indexer_with_nans(self):
+        # GH#41831
+        index = IntervalIndex([np.nan, np.nan])
+        other = IntervalIndex([np.nan])
+
+        assert not index._index_as_unique
+
+        result = index.get_indexer_for(other)
+        expected = np.array([0, 1], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_get_index_non_unique_non_monotonic(self):
+        # GH#44084 (root cause)
+        index = IntervalIndex.from_tuples(
+            [(0.0, 1.0), (1.0, 2.0), (0.0, 1.0), (1.0, 2.0)]
+        )
+
+        result, _ = index.get_indexer_non_unique([Interval(1.0, 2.0)])
+        expected = np.array([1, 3], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_get_indexer_multiindex_with_intervals(self):
+        # GH#44084 (MultiIndex case as reported)
+        interval_index = IntervalIndex.from_tuples(
+            [(2.0, 3.0), (0.0, 1.0), (1.0, 2.0)], name="interval"
+        )
+        foo_index = Index([1, 2, 3], name="foo")
+
+        multi_index = MultiIndex.from_product([foo_index, interval_index])
+
+        result = multi_index.get_level_values("interval").get_indexer_for(
+            [Interval(0.0, 1.0)]
+        )
+        expected = np.array([1, 4, 7], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("box", [IntervalIndex, array, list])
+    def test_get_indexer_interval_index(self, box):
+        # GH#30178
+        rng = period_range("2022-07-01", freq="D", periods=3)
+        idx = box(interval_range(Timestamp("2022-07-01"), freq="3D", periods=3))
+
+        actual = rng.get_indexer(idx)
+        expected = np.array([-1, -1, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(actual, expected)
+
+    def test_get_indexer_read_only(self):
+        idx = interval_range(start=0, end=5)
+        arr = np.array([1, 2])
+        arr.flags.writeable = False
+        result = idx.get_indexer(arr)
+        expected = np.array([0, 1])
+        tm.assert_numpy_array_equal(result, expected, check_dtype=False)
+
+        result = idx.get_indexer_non_unique(arr)[0]
+        tm.assert_numpy_array_equal(result, expected, check_dtype=False)
+
+
+class TestSliceLocs:
+    def test_slice_locs_with_interval(self):
+        # increasing monotonically
+        index = IntervalIndex.from_tuples([(0, 2), (1, 3), (2, 4)])
+
+        assert index.slice_locs(start=Interval(0, 2), end=Interval(2, 4)) == (0, 3)
+        assert index.slice_locs(start=Interval(0, 2)) == (0, 3)
+        assert index.slice_locs(end=Interval(2, 4)) == (0, 3)
+        assert index.slice_locs(end=Interval(0, 2)) == (0, 1)
+        assert index.slice_locs(start=Interval(2, 4), end=Interval(0, 2)) == (2, 1)
+
+        # decreasing monotonically
+        index = IntervalIndex.from_tuples([(2, 4), (1, 3), (0, 2)])
+
+        assert index.slice_locs(start=Interval(0, 2), end=Interval(2, 4)) == (2, 1)
+        assert index.slice_locs(start=Interval(0, 2)) == (2, 3)
+        assert index.slice_locs(end=Interval(2, 4)) == (0, 1)
+        assert index.slice_locs(end=Interval(0, 2)) == (0, 3)
+        assert index.slice_locs(start=Interval(2, 4), end=Interval(0, 2)) == (0, 3)
+
+        # sorted duplicates
+        index = IntervalIndex.from_tuples([(0, 2), (0, 2), (2, 4)])
+
+        assert index.slice_locs(start=Interval(0, 2), end=Interval(2, 4)) == (0, 3)
+        assert index.slice_locs(start=Interval(0, 2)) == (0, 3)
+        assert index.slice_locs(end=Interval(2, 4)) == (0, 3)
+        assert index.slice_locs(end=Interval(0, 2)) == (0, 2)
+        assert index.slice_locs(start=Interval(2, 4), end=Interval(0, 2)) == (2, 2)
+
+        # unsorted duplicates
+        index = IntervalIndex.from_tuples([(0, 2), (2, 4), (0, 2)])
+
+        with pytest.raises(
+            KeyError,
+            match=re.escape(
+                '"Cannot get left slice bound for non-unique label: '
+                "Interval(0, 2, closed='right')\""
+            ),
+        ):
+            index.slice_locs(start=Interval(0, 2), end=Interval(2, 4))
+
+        with pytest.raises(
+            KeyError,
+            match=re.escape(
+                '"Cannot get left slice bound for non-unique label: '
+                "Interval(0, 2, closed='right')\""
+            ),
+        ):
+            index.slice_locs(start=Interval(0, 2))
+
+        assert index.slice_locs(end=Interval(2, 4)) == (0, 2)
+
+        with pytest.raises(
+            KeyError,
+            match=re.escape(
+                '"Cannot get right slice bound for non-unique label: '
+                "Interval(0, 2, closed='right')\""
+            ),
+        ):
+            index.slice_locs(end=Interval(0, 2))
+
+        with pytest.raises(
+            KeyError,
+            match=re.escape(
+                '"Cannot get right slice bound for non-unique label: '
+                "Interval(0, 2, closed='right')\""
+            ),
+        ):
+            index.slice_locs(start=Interval(2, 4), end=Interval(0, 2))
+
+        # another unsorted duplicates
+        index = IntervalIndex.from_tuples([(0, 2), (0, 2), (2, 4), (1, 3)])
+
+        assert index.slice_locs(start=Interval(0, 2), end=Interval(2, 4)) == (0, 3)
+        assert index.slice_locs(start=Interval(0, 2)) == (0, 4)
+        assert index.slice_locs(end=Interval(2, 4)) == (0, 3)
+        assert index.slice_locs(end=Interval(0, 2)) == (0, 2)
+        assert index.slice_locs(start=Interval(2, 4), end=Interval(0, 2)) == (2, 2)
+
+    def test_slice_locs_with_ints_and_floats_succeeds(self):
+        # increasing non-overlapping
+        index = IntervalIndex.from_tuples([(0, 1), (1, 2), (3, 4)])
+
+        assert index.slice_locs(0, 1) == (0, 1)
+        assert index.slice_locs(0, 2) == (0, 2)
+        assert index.slice_locs(0, 3) == (0, 2)
+        assert index.slice_locs(3, 1) == (2, 1)
+        assert index.slice_locs(3, 4) == (2, 3)
+        assert index.slice_locs(0, 4) == (0, 3)
+
+        # decreasing non-overlapping
+        index = IntervalIndex.from_tuples([(3, 4), (1, 2), (0, 1)])
+        assert index.slice_locs(0, 1) == (3, 3)
+        assert index.slice_locs(0, 2) == (3, 2)
+        assert index.slice_locs(0, 3) == (3, 1)
+        assert index.slice_locs(3, 1) == (1, 3)
+        assert index.slice_locs(3, 4) == (1, 1)
+        assert index.slice_locs(0, 4) == (3, 1)
+
+    @pytest.mark.parametrize("query", [[0, 1], [0, 2], [0, 3], [0, 4]])
+    @pytest.mark.parametrize(
+        "tuples",
+        [
+            [(0, 2), (1, 3), (2, 4)],
+            [(2, 4), (1, 3), (0, 2)],
+            [(0, 2), (0, 2), (2, 4)],
+            [(0, 2), (2, 4), (0, 2)],
+            [(0, 2), (0, 2), (2, 4), (1, 3)],
+        ],
+    )
+    def test_slice_locs_with_ints_and_floats_errors(self, tuples, query):
+        start, stop = query
+        index = IntervalIndex.from_tuples(tuples)
+        with pytest.raises(
+            KeyError,
+            match=(
+                "'can only get slices from an IntervalIndex if bounds are "
+                "non-overlapping and all monotonic increasing or decreasing'"
+            ),
+        ):
+            index.slice_locs(start, stop)
+
+
+class TestPutmask:
+    @pytest.mark.parametrize("tz", ["US/Pacific", None])
+    def test_putmask_dt64(self, tz):
+        # GH#37968
+        dti = date_range("2016-01-01", periods=9, tz=tz)
+        idx = IntervalIndex.from_breaks(dti)
+        mask = np.zeros(idx.shape, dtype=bool)
+        mask[0:3] = True
+
+        result = idx.putmask(mask, idx[-1])
+        expected = IntervalIndex([idx[-1]] * 3 + list(idx[3:]))
+        tm.assert_index_equal(result, expected)
+
+    def test_putmask_td64(self):
+        # GH#37968
+        dti = date_range("2016-01-01", periods=9)
+        tdi = dti - dti[0]
+        idx = IntervalIndex.from_breaks(tdi)
+        mask = np.zeros(idx.shape, dtype=bool)
+        mask[0:3] = True
+
+        result = idx.putmask(mask, idx[-1])
+        expected = IntervalIndex([idx[-1]] * 3 + list(idx[3:]))
+        tm.assert_index_equal(result, expected)
+
+
+class TestContains:
+    # .__contains__, not .contains
+
+    def test_contains_dunder(self):
+        index = IntervalIndex.from_arrays([0, 1], [1, 2], closed="right")
+
+        # __contains__ requires perfect matches to intervals.
+        assert 0 not in index
+        assert 1 not in index
+        assert 2 not in index
+
+        assert Interval(0, 1, closed="right") in index
+        assert Interval(0, 2, closed="right") not in index
+        assert Interval(0, 0.5, closed="right") not in index
+        assert Interval(3, 5, closed="right") not in index
+        assert Interval(-1, 0, closed="left") not in index
+        assert Interval(0, 1, closed="left") not in index
+        assert Interval(0, 1, closed="both") not in index
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_interval.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_interval.py
new file mode 100644
index 0000000000000000000000000000000000000000..63f9b2176dddde899a2b199eec53abefd7c9621c
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_interval.py
@@ -0,0 +1,918 @@
+from itertools import permutations
+import re
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Index,
+    Interval,
+    IntervalIndex,
+    Timedelta,
+    Timestamp,
+    date_range,
+    interval_range,
+    isna,
+    notna,
+    timedelta_range,
+)
+import pandas._testing as tm
+import pandas.core.common as com
+
+
+@pytest.fixture(params=[None, "foo"])
+def name(request):
+    return request.param
+
+
+class TestIntervalIndex:
+    index = IntervalIndex.from_arrays([0, 1], [1, 2])
+
+    def create_index(self, closed="right"):
+        return IntervalIndex.from_breaks(range(11), closed=closed)
+
+    def create_index_with_nan(self, closed="right"):
+        mask = [True, False] + [True] * 8
+        return IntervalIndex.from_arrays(
+            np.where(mask, np.arange(10), np.nan),
+            np.where(mask, np.arange(1, 11), np.nan),
+            closed=closed,
+        )
+
+    def test_properties(self, closed):
+        index = self.create_index(closed=closed)
+        assert len(index) == 10
+        assert index.size == 10
+        assert index.shape == (10,)
+
+        tm.assert_index_equal(index.left, Index(np.arange(10, dtype=np.int64)))
+        tm.assert_index_equal(index.right, Index(np.arange(1, 11, dtype=np.int64)))
+        tm.assert_index_equal(index.mid, Index(np.arange(0.5, 10.5, dtype=np.float64)))
+
+        assert index.closed == closed
+
+        ivs = [
+            Interval(left, right, closed)
+            for left, right in zip(range(10), range(1, 11))
+        ]
+        expected = np.array(ivs, dtype=object)
+        tm.assert_numpy_array_equal(np.asarray(index), expected)
+
+        # with nans
+        index = self.create_index_with_nan(closed=closed)
+        assert len(index) == 10
+        assert index.size == 10
+        assert index.shape == (10,)
+
+        expected_left = Index([0, np.nan, 2, 3, 4, 5, 6, 7, 8, 9])
+        expected_right = expected_left + 1
+        expected_mid = expected_left + 0.5
+        tm.assert_index_equal(index.left, expected_left)
+        tm.assert_index_equal(index.right, expected_right)
+        tm.assert_index_equal(index.mid, expected_mid)
+
+        assert index.closed == closed
+
+        ivs = [
+            Interval(left, right, closed) if notna(left) else np.nan
+            for left, right in zip(expected_left, expected_right)
+        ]
+        expected = np.array(ivs, dtype=object)
+        tm.assert_numpy_array_equal(np.asarray(index), expected)
+
+    @pytest.mark.parametrize(
+        "breaks",
+        [
+            [1, 1, 2, 5, 15, 53, 217, 1014, 5335, 31240, 201608],
+            [-np.inf, -100, -10, 0.5, 1, 1.5, 3.8, 101, 202, np.inf],
+            date_range("2017-01-01", "2017-01-04"),
+            pytest.param(
+                date_range("2017-01-01", "2017-01-04", unit="s"),
+                marks=pytest.mark.xfail(reason="mismatched result unit"),
+            ),
+            pd.to_timedelta(["1ns", "2ms", "3s", "4min", "5h", "6D"]),
+        ],
+    )
+    def test_length(self, closed, breaks):
+        # GH 18789
+        index = IntervalIndex.from_breaks(breaks, closed=closed)
+        result = index.length
+        expected = Index(iv.length for iv in index)
+        tm.assert_index_equal(result, expected)
+
+        # with NA
+        index = index.insert(1, np.nan)
+        result = index.length
+        expected = Index(iv.length if notna(iv) else iv for iv in index)
+        tm.assert_index_equal(result, expected)
+
+    def test_with_nans(self, closed):
+        index = self.create_index(closed=closed)
+        assert index.hasnans is False
+
+        result = index.isna()
+        expected = np.zeros(len(index), dtype=bool)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = index.notna()
+        expected = np.ones(len(index), dtype=bool)
+        tm.assert_numpy_array_equal(result, expected)
+
+        index = self.create_index_with_nan(closed=closed)
+        assert index.hasnans is True
+
+        result = index.isna()
+        expected = np.array([False, True] + [False] * (len(index) - 2))
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = index.notna()
+        expected = np.array([True, False] + [True] * (len(index) - 2))
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_copy(self, closed):
+        expected = self.create_index(closed=closed)
+
+        result = expected.copy()
+        assert result.equals(expected)
+
+        result = expected.copy(deep=True)
+        assert result.equals(expected)
+        assert result.left is not expected.left
+
+    def test_ensure_copied_data(self, closed):
+        # exercise the copy flag in the constructor
+
+        # not copying
+        index = self.create_index(closed=closed)
+        result = IntervalIndex(index, copy=False)
+        tm.assert_numpy_array_equal(
+            index.left.values, result.left.values, check_same="same"
+        )
+        tm.assert_numpy_array_equal(
+            index.right.values, result.right.values, check_same="same"
+        )
+
+        # by-definition make a copy
+        result = IntervalIndex(np.array(index), copy=False)
+        tm.assert_numpy_array_equal(
+            index.left.values, result.left.values, check_same="copy"
+        )
+        tm.assert_numpy_array_equal(
+            index.right.values, result.right.values, check_same="copy"
+        )
+
+    def test_delete(self, closed):
+        breaks = np.arange(1, 11, dtype=np.int64)
+        expected = IntervalIndex.from_breaks(breaks, closed=closed)
+        result = self.create_index(closed=closed).delete(0)
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "data",
+        [
+            interval_range(0, periods=10, closed="neither"),
+            interval_range(1.7, periods=8, freq=2.5, closed="both"),
+            interval_range(Timestamp("20170101"), periods=12, closed="left"),
+            interval_range(Timedelta("1 day"), periods=6, closed="right"),
+        ],
+    )
+    def test_insert(self, data):
+        item = data[0]
+        idx_item = IntervalIndex([item])
+
+        # start
+        expected = idx_item.append(data)
+        result = data.insert(0, item)
+        tm.assert_index_equal(result, expected)
+
+        # end
+        expected = data.append(idx_item)
+        result = data.insert(len(data), item)
+        tm.assert_index_equal(result, expected)
+
+        # mid
+        expected = data[:3].append(idx_item).append(data[3:])
+        result = data.insert(3, item)
+        tm.assert_index_equal(result, expected)
+
+        # invalid type
+        res = data.insert(1, "foo")
+        expected = data.astype(object).insert(1, "foo")
+        tm.assert_index_equal(res, expected)
+
+        msg = "can only insert Interval objects and NA into an IntervalArray"
+        with pytest.raises(TypeError, match=msg):
+            data._data.insert(1, "foo")
+
+        # invalid closed
+        msg = "'value.closed' is 'left', expected 'right'."
+        for closed in {"left", "right", "both", "neither"} - {item.closed}:
+            msg = f"'value.closed' is '{closed}', expected '{item.closed}'."
+            bad_item = Interval(item.left, item.right, closed=closed)
+            res = data.insert(1, bad_item)
+            expected = data.astype(object).insert(1, bad_item)
+            tm.assert_index_equal(res, expected)
+            with pytest.raises(ValueError, match=msg):
+                data._data.insert(1, bad_item)
+
+        # GH 18295 (test missing)
+        na_idx = IntervalIndex([np.nan], closed=data.closed)
+        for na in [np.nan, None, pd.NA]:
+            expected = data[:1].append(na_idx).append(data[1:])
+            result = data.insert(1, na)
+            tm.assert_index_equal(result, expected)
+
+        if data.left.dtype.kind not in ["m", "M"]:
+            # trying to insert pd.NaT into a numeric-dtyped Index should cast
+            expected = data.astype(object).insert(1, pd.NaT)
+
+            msg = "can only insert Interval objects and NA into an IntervalArray"
+            with pytest.raises(TypeError, match=msg):
+                data._data.insert(1, pd.NaT)
+
+        result = data.insert(1, pd.NaT)
+        tm.assert_index_equal(result, expected)
+
+    def test_is_unique_interval(self, closed):
+        """
+        Interval specific tests for is_unique in addition to base class tests
+        """
+        # unique overlapping - distinct endpoints
+        idx = IntervalIndex.from_tuples([(0, 1), (0.5, 1.5)], closed=closed)
+        assert idx.is_unique is True
+
+        # unique overlapping - shared endpoints
+        idx = IntervalIndex.from_tuples([(1, 2), (1, 3), (2, 3)], closed=closed)
+        assert idx.is_unique is True
+
+        # unique nested
+        idx = IntervalIndex.from_tuples([(-1, 1), (-2, 2)], closed=closed)
+        assert idx.is_unique is True
+
+        # unique NaN
+        idx = IntervalIndex.from_tuples([(np.nan, np.nan)], closed=closed)
+        assert idx.is_unique is True
+
+        # non-unique NaN
+        idx = IntervalIndex.from_tuples(
+            [(np.nan, np.nan), (np.nan, np.nan)], closed=closed
+        )
+        assert idx.is_unique is False
+
+    def test_monotonic(self, closed):
+        # increasing non-overlapping
+        idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (4, 5)], closed=closed)
+        assert idx.is_monotonic_increasing is True
+        assert idx._is_strictly_monotonic_increasing is True
+        assert idx.is_monotonic_decreasing is False
+        assert idx._is_strictly_monotonic_decreasing is False
+
+        # decreasing non-overlapping
+        idx = IntervalIndex.from_tuples([(4, 5), (2, 3), (1, 2)], closed=closed)
+        assert idx.is_monotonic_increasing is False
+        assert idx._is_strictly_monotonic_increasing is False
+        assert idx.is_monotonic_decreasing is True
+        assert idx._is_strictly_monotonic_decreasing is True
+
+        # unordered non-overlapping
+        idx = IntervalIndex.from_tuples([(0, 1), (4, 5), (2, 3)], closed=closed)
+        assert idx.is_monotonic_increasing is False
+        assert idx._is_strictly_monotonic_increasing is False
+        assert idx.is_monotonic_decreasing is False
+        assert idx._is_strictly_monotonic_decreasing is False
+
+        # increasing overlapping
+        idx = IntervalIndex.from_tuples([(0, 2), (0.5, 2.5), (1, 3)], closed=closed)
+        assert idx.is_monotonic_increasing is True
+        assert idx._is_strictly_monotonic_increasing is True
+        assert idx.is_monotonic_decreasing is False
+        assert idx._is_strictly_monotonic_decreasing is False
+
+        # decreasing overlapping
+        idx = IntervalIndex.from_tuples([(1, 3), (0.5, 2.5), (0, 2)], closed=closed)
+        assert idx.is_monotonic_increasing is False
+        assert idx._is_strictly_monotonic_increasing is False
+        assert idx.is_monotonic_decreasing is True
+        assert idx._is_strictly_monotonic_decreasing is True
+
+        # unordered overlapping
+        idx = IntervalIndex.from_tuples([(0.5, 2.5), (0, 2), (1, 3)], closed=closed)
+        assert idx.is_monotonic_increasing is False
+        assert idx._is_strictly_monotonic_increasing is False
+        assert idx.is_monotonic_decreasing is False
+        assert idx._is_strictly_monotonic_decreasing is False
+
+        # increasing overlapping shared endpoints
+        idx = IntervalIndex.from_tuples([(1, 2), (1, 3), (2, 3)], closed=closed)
+        assert idx.is_monotonic_increasing is True
+        assert idx._is_strictly_monotonic_increasing is True
+        assert idx.is_monotonic_decreasing is False
+        assert idx._is_strictly_monotonic_decreasing is False
+
+        # decreasing overlapping shared endpoints
+        idx = IntervalIndex.from_tuples([(2, 3), (1, 3), (1, 2)], closed=closed)
+        assert idx.is_monotonic_increasing is False
+        assert idx._is_strictly_monotonic_increasing is False
+        assert idx.is_monotonic_decreasing is True
+        assert idx._is_strictly_monotonic_decreasing is True
+
+        # stationary
+        idx = IntervalIndex.from_tuples([(0, 1), (0, 1)], closed=closed)
+        assert idx.is_monotonic_increasing is True
+        assert idx._is_strictly_monotonic_increasing is False
+        assert idx.is_monotonic_decreasing is True
+        assert idx._is_strictly_monotonic_decreasing is False
+
+        # empty
+        idx = IntervalIndex([], closed=closed)
+        assert idx.is_monotonic_increasing is True
+        assert idx._is_strictly_monotonic_increasing is True
+        assert idx.is_monotonic_decreasing is True
+        assert idx._is_strictly_monotonic_decreasing is True
+
+    def test_is_monotonic_with_nans(self):
+        # GH#41831
+        index = IntervalIndex([np.nan, np.nan])
+
+        assert not index.is_monotonic_increasing
+        assert not index._is_strictly_monotonic_increasing
+        assert not index.is_monotonic_increasing
+        assert not index._is_strictly_monotonic_decreasing
+        assert not index.is_monotonic_decreasing
+
+    @pytest.mark.parametrize(
+        "breaks",
+        [
+            date_range("20180101", periods=4),
+            date_range("20180101", periods=4, tz="US/Eastern"),
+            timedelta_range("0 days", periods=4),
+        ],
+        ids=lambda x: str(x.dtype),
+    )
+    def test_maybe_convert_i8(self, breaks):
+        # GH 20636
+        index = IntervalIndex.from_breaks(breaks)
+
+        # intervalindex
+        result = index._maybe_convert_i8(index)
+        expected = IntervalIndex.from_breaks(breaks.asi8)
+        tm.assert_index_equal(result, expected)
+
+        # interval
+        interval = Interval(breaks[0], breaks[1])
+        result = index._maybe_convert_i8(interval)
+        expected = Interval(breaks[0]._value, breaks[1]._value)
+        assert result == expected
+
+        # datetimelike index
+        result = index._maybe_convert_i8(breaks)
+        expected = Index(breaks.asi8)
+        tm.assert_index_equal(result, expected)
+
+        # datetimelike scalar
+        result = index._maybe_convert_i8(breaks[0])
+        expected = breaks[0]._value
+        assert result == expected
+
+        # list-like of datetimelike scalars
+        result = index._maybe_convert_i8(list(breaks))
+        expected = Index(breaks.asi8)
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "breaks",
+        [date_range("2018-01-01", periods=5), timedelta_range("0 days", periods=5)],
+    )
+    def test_maybe_convert_i8_nat(self, breaks):
+        # GH 20636
+        index = IntervalIndex.from_breaks(breaks)
+
+        to_convert = breaks._constructor([pd.NaT] * 3).as_unit("ns")
+        expected = Index([np.nan] * 3, dtype=np.float64)
+        result = index._maybe_convert_i8(to_convert)
+        tm.assert_index_equal(result, expected)
+
+        to_convert = to_convert.insert(0, breaks[0])
+        expected = expected.insert(0, float(breaks[0]._value))
+        result = index._maybe_convert_i8(to_convert)
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "make_key",
+        [lambda breaks: breaks, list],
+        ids=["lambda", "list"],
+    )
+    def test_maybe_convert_i8_numeric(self, make_key, any_real_numpy_dtype):
+        # GH 20636
+        breaks = np.arange(5, dtype=any_real_numpy_dtype)
+        index = IntervalIndex.from_breaks(breaks)
+        key = make_key(breaks)
+
+        result = index._maybe_convert_i8(key)
+        kind = breaks.dtype.kind
+        expected_dtype = {"i": np.int64, "u": np.uint64, "f": np.float64}[kind]
+        expected = Index(key, dtype=expected_dtype)
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "make_key",
+        [
+            IntervalIndex.from_breaks,
+            lambda breaks: Interval(breaks[0], breaks[1]),
+            lambda breaks: breaks[0],
+        ],
+        ids=["IntervalIndex", "Interval", "scalar"],
+    )
+    def test_maybe_convert_i8_numeric_identical(self, make_key, any_real_numpy_dtype):
+        # GH 20636
+        breaks = np.arange(5, dtype=any_real_numpy_dtype)
+        index = IntervalIndex.from_breaks(breaks)
+        key = make_key(breaks)
+
+        # test if _maybe_convert_i8 won't change key if an Interval or IntervalIndex
+        result = index._maybe_convert_i8(key)
+        assert result is key
+
+    @pytest.mark.parametrize(
+        "breaks1, breaks2",
+        permutations(
+            [
+                date_range("20180101", periods=4),
+                date_range("20180101", periods=4, tz="US/Eastern"),
+                timedelta_range("0 days", periods=4),
+            ],
+            2,
+        ),
+        ids=lambda x: str(x.dtype),
+    )
+    @pytest.mark.parametrize(
+        "make_key",
+        [
+            IntervalIndex.from_breaks,
+            lambda breaks: Interval(breaks[0], breaks[1]),
+            lambda breaks: breaks,
+            lambda breaks: breaks[0],
+            list,
+        ],
+        ids=["IntervalIndex", "Interval", "Index", "scalar", "list"],
+    )
+    def test_maybe_convert_i8_errors(self, breaks1, breaks2, make_key):
+        # GH 20636
+        index = IntervalIndex.from_breaks(breaks1)
+        key = make_key(breaks2)
+
+        msg = (
+            f"Cannot index an IntervalIndex of subtype {breaks1.dtype} with "
+            f"values of dtype {breaks2.dtype}"
+        )
+        msg = re.escape(msg)
+        with pytest.raises(ValueError, match=msg):
+            index._maybe_convert_i8(key)
+
+    def test_contains_method(self):
+        # can select values that are IN the range of a value
+        i = IntervalIndex.from_arrays([0, 1], [1, 2])
+
+        expected = np.array([False, False], dtype="bool")
+        actual = i.contains(0)
+        tm.assert_numpy_array_equal(actual, expected)
+        actual = i.contains(3)
+        tm.assert_numpy_array_equal(actual, expected)
+
+        expected = np.array([True, False], dtype="bool")
+        actual = i.contains(0.5)
+        tm.assert_numpy_array_equal(actual, expected)
+        actual = i.contains(1)
+        tm.assert_numpy_array_equal(actual, expected)
+
+        # __contains__ not implemented for "interval in interval", follow
+        # that for the contains method for now
+        with pytest.raises(
+            NotImplementedError, match="contains not implemented for two"
+        ):
+            i.contains(Interval(0, 1))
+
+    def test_dropna(self, closed):
+        expected = IntervalIndex.from_tuples([(0.0, 1.0), (1.0, 2.0)], closed=closed)
+
+        ii = IntervalIndex.from_tuples([(0, 1), (1, 2), np.nan], closed=closed)
+        result = ii.dropna()
+        tm.assert_index_equal(result, expected)
+
+        ii = IntervalIndex.from_arrays([0, 1, np.nan], [1, 2, np.nan], closed=closed)
+        result = ii.dropna()
+        tm.assert_index_equal(result, expected)
+
+    def test_non_contiguous(self, closed):
+        index = IntervalIndex.from_tuples([(0, 1), (2, 3)], closed=closed)
+        target = [0.5, 1.5, 2.5]
+        actual = index.get_indexer(target)
+        expected = np.array([0, -1, 1], dtype="intp")
+        tm.assert_numpy_array_equal(actual, expected)
+
+        assert 1.5 not in index
+
+    def test_isin(self, closed):
+        index = self.create_index(closed=closed)
+
+        expected = np.array([True] + [False] * (len(index) - 1))
+        result = index.isin(index[:1])
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = index.isin([index[0]])
+        tm.assert_numpy_array_equal(result, expected)
+
+        other = IntervalIndex.from_breaks(np.arange(-2, 10), closed=closed)
+        expected = np.array([True] * (len(index) - 1) + [False])
+        result = index.isin(other)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = index.isin(other.tolist())
+        tm.assert_numpy_array_equal(result, expected)
+
+        for other_closed in ["right", "left", "both", "neither"]:
+            other = self.create_index(closed=other_closed)
+            expected = np.repeat(closed == other_closed, len(index))
+            result = index.isin(other)
+            tm.assert_numpy_array_equal(result, expected)
+
+            result = index.isin(other.tolist())
+            tm.assert_numpy_array_equal(result, expected)
+
+    def test_comparison(self):
+        actual = Interval(0, 1) < self.index
+        expected = np.array([False, True])
+        tm.assert_numpy_array_equal(actual, expected)
+
+        actual = Interval(0.5, 1.5) < self.index
+        expected = np.array([False, True])
+        tm.assert_numpy_array_equal(actual, expected)
+        actual = self.index > Interval(0.5, 1.5)
+        tm.assert_numpy_array_equal(actual, expected)
+
+        actual = self.index == self.index
+        expected = np.array([True, True])
+        tm.assert_numpy_array_equal(actual, expected)
+        actual = self.index <= self.index
+        tm.assert_numpy_array_equal(actual, expected)
+        actual = self.index >= self.index
+        tm.assert_numpy_array_equal(actual, expected)
+
+        actual = self.index < self.index
+        expected = np.array([False, False])
+        tm.assert_numpy_array_equal(actual, expected)
+        actual = self.index > self.index
+        tm.assert_numpy_array_equal(actual, expected)
+
+        actual = self.index == IntervalIndex.from_breaks([0, 1, 2], "left")
+        tm.assert_numpy_array_equal(actual, expected)
+
+        actual = self.index == self.index.values
+        tm.assert_numpy_array_equal(actual, np.array([True, True]))
+        actual = self.index.values == self.index
+        tm.assert_numpy_array_equal(actual, np.array([True, True]))
+        actual = self.index <= self.index.values
+        tm.assert_numpy_array_equal(actual, np.array([True, True]))
+        actual = self.index != self.index.values
+        tm.assert_numpy_array_equal(actual, np.array([False, False]))
+        actual = self.index > self.index.values
+        tm.assert_numpy_array_equal(actual, np.array([False, False]))
+        actual = self.index.values > self.index
+        tm.assert_numpy_array_equal(actual, np.array([False, False]))
+
+        # invalid comparisons
+        actual = self.index == 0
+        tm.assert_numpy_array_equal(actual, np.array([False, False]))
+        actual = self.index == self.index.left
+        tm.assert_numpy_array_equal(actual, np.array([False, False]))
+
+        msg = "|".join(
+            [
+                "not supported between instances of 'int' and '.*.Interval'",
+                r"Invalid comparison between dtype=interval\[int64, right\] and ",
+            ]
+        )
+        with pytest.raises(TypeError, match=msg):
+            self.index > 0
+        with pytest.raises(TypeError, match=msg):
+            self.index <= 0
+        with pytest.raises(TypeError, match=msg):
+            self.index > np.arange(2)
+
+        msg = "Lengths must match to compare"
+        with pytest.raises(ValueError, match=msg):
+            self.index > np.arange(3)
+
+    def test_missing_values(self, closed):
+        idx = Index(
+            [np.nan, Interval(0, 1, closed=closed), Interval(1, 2, closed=closed)]
+        )
+        idx2 = IntervalIndex.from_arrays([np.nan, 0, 1], [np.nan, 1, 2], closed=closed)
+        assert idx.equals(idx2)
+
+        msg = (
+            "missing values must be missing in the same location both left "
+            "and right sides"
+        )
+        with pytest.raises(ValueError, match=msg):
+            IntervalIndex.from_arrays(
+                [np.nan, 0, 1], np.array([0, 1, 2]), closed=closed
+            )
+
+        tm.assert_numpy_array_equal(isna(idx), np.array([True, False, False]))
+
+    def test_sort_values(self, closed):
+        index = self.create_index(closed=closed)
+
+        result = index.sort_values()
+        tm.assert_index_equal(result, index)
+
+        result = index.sort_values(ascending=False)
+        tm.assert_index_equal(result, index[::-1])
+
+        # with nan
+        index = IntervalIndex([Interval(1, 2), np.nan, Interval(0, 1)])
+
+        result = index.sort_values()
+        expected = IntervalIndex([Interval(0, 1), Interval(1, 2), np.nan])
+        tm.assert_index_equal(result, expected)
+
+        result = index.sort_values(ascending=False, na_position="first")
+        expected = IntervalIndex([np.nan, Interval(1, 2), Interval(0, 1)])
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", [None, "US/Eastern"])
+    def test_datetime(self, tz):
+        start = Timestamp("2000-01-01", tz=tz)
+        dates = date_range(start=start, periods=10)
+        index = IntervalIndex.from_breaks(dates)
+
+        # test mid
+        start = Timestamp("2000-01-01T12:00", tz=tz)
+        expected = date_range(start=start, periods=9)
+        tm.assert_index_equal(index.mid, expected)
+
+        # __contains__ doesn't check individual points
+        assert Timestamp("2000-01-01", tz=tz) not in index
+        assert Timestamp("2000-01-01T12", tz=tz) not in index
+        assert Timestamp("2000-01-02", tz=tz) not in index
+        iv_true = Interval(
+            Timestamp("2000-01-02", tz=tz), Timestamp("2000-01-03", tz=tz)
+        )
+        iv_false = Interval(
+            Timestamp("1999-12-31", tz=tz), Timestamp("2000-01-01", tz=tz)
+        )
+        assert iv_true in index
+        assert iv_false not in index
+
+        # .contains does check individual points
+        assert not index.contains(Timestamp("2000-01-01", tz=tz)).any()
+        assert index.contains(Timestamp("2000-01-01T12", tz=tz)).any()
+        assert index.contains(Timestamp("2000-01-02", tz=tz)).any()
+
+        # test get_indexer
+        start = Timestamp("1999-12-31T12:00", tz=tz)
+        target = date_range(start=start, periods=7, freq="12h")
+        actual = index.get_indexer(target)
+        expected = np.array([-1, -1, 0, 0, 1, 1, 2], dtype="intp")
+        tm.assert_numpy_array_equal(actual, expected)
+
+        start = Timestamp("2000-01-08T18:00", tz=tz)
+        target = date_range(start=start, periods=7, freq="6h")
+        actual = index.get_indexer(target)
+        expected = np.array([7, 7, 8, 8, 8, 8, -1], dtype="intp")
+        tm.assert_numpy_array_equal(actual, expected)
+
+    def test_append(self, closed):
+        index1 = IntervalIndex.from_arrays([0, 1], [1, 2], closed=closed)
+        index2 = IntervalIndex.from_arrays([1, 2], [2, 3], closed=closed)
+
+        result = index1.append(index2)
+        expected = IntervalIndex.from_arrays([0, 1, 1, 2], [1, 2, 2, 3], closed=closed)
+        tm.assert_index_equal(result, expected)
+
+        result = index1.append([index1, index2])
+        expected = IntervalIndex.from_arrays(
+            [0, 1, 0, 1, 1, 2], [1, 2, 1, 2, 2, 3], closed=closed
+        )
+        tm.assert_index_equal(result, expected)
+
+        for other_closed in {"left", "right", "both", "neither"} - {closed}:
+            index_other_closed = IntervalIndex.from_arrays(
+                [0, 1], [1, 2], closed=other_closed
+            )
+            result = index1.append(index_other_closed)
+            expected = index1.astype(object).append(index_other_closed.astype(object))
+            tm.assert_index_equal(result, expected)
+
+    def test_is_non_overlapping_monotonic(self, closed):
+        # Should be True in all cases
+        tpls = [(0, 1), (2, 3), (4, 5), (6, 7)]
+        idx = IntervalIndex.from_tuples(tpls, closed=closed)
+        assert idx.is_non_overlapping_monotonic is True
+
+        idx = IntervalIndex.from_tuples(tpls[::-1], closed=closed)
+        assert idx.is_non_overlapping_monotonic is True
+
+        # Should be False in all cases (overlapping)
+        tpls = [(0, 2), (1, 3), (4, 5), (6, 7)]
+        idx = IntervalIndex.from_tuples(tpls, closed=closed)
+        assert idx.is_non_overlapping_monotonic is False
+
+        idx = IntervalIndex.from_tuples(tpls[::-1], closed=closed)
+        assert idx.is_non_overlapping_monotonic is False
+
+        # Should be False in all cases (non-monotonic)
+        tpls = [(0, 1), (2, 3), (6, 7), (4, 5)]
+        idx = IntervalIndex.from_tuples(tpls, closed=closed)
+        assert idx.is_non_overlapping_monotonic is False
+
+        idx = IntervalIndex.from_tuples(tpls[::-1], closed=closed)
+        assert idx.is_non_overlapping_monotonic is False
+
+        # Should be False for closed='both', otherwise True (GH16560)
+        if closed == "both":
+            idx = IntervalIndex.from_breaks(range(4), closed=closed)
+            assert idx.is_non_overlapping_monotonic is False
+        else:
+            idx = IntervalIndex.from_breaks(range(4), closed=closed)
+            assert idx.is_non_overlapping_monotonic is True
+
+    @pytest.mark.parametrize(
+        "start, shift, na_value",
+        [
+            (0, 1, np.nan),
+            (Timestamp("2018-01-01"), Timedelta("1 day"), pd.NaT),
+            (Timedelta("0 days"), Timedelta("1 day"), pd.NaT),
+        ],
+    )
+    def test_is_overlapping(self, start, shift, na_value, closed):
+        # GH 23309
+        # see test_interval_tree.py for extensive tests; interface tests here
+
+        # non-overlapping
+        tuples = [(start + n * shift, start + (n + 1) * shift) for n in (0, 2, 4)]
+        index = IntervalIndex.from_tuples(tuples, closed=closed)
+        assert index.is_overlapping is False
+
+        # non-overlapping with NA
+        tuples = [(na_value, na_value)] + tuples + [(na_value, na_value)]
+        index = IntervalIndex.from_tuples(tuples, closed=closed)
+        assert index.is_overlapping is False
+
+        # overlapping
+        tuples = [(start + n * shift, start + (n + 2) * shift) for n in range(3)]
+        index = IntervalIndex.from_tuples(tuples, closed=closed)
+        assert index.is_overlapping is True
+
+        # overlapping with NA
+        tuples = [(na_value, na_value)] + tuples + [(na_value, na_value)]
+        index = IntervalIndex.from_tuples(tuples, closed=closed)
+        assert index.is_overlapping is True
+
+        # common endpoints
+        tuples = [(start + n * shift, start + (n + 1) * shift) for n in range(3)]
+        index = IntervalIndex.from_tuples(tuples, closed=closed)
+        result = index.is_overlapping
+        expected = closed == "both"
+        assert result is expected
+
+        # common endpoints with NA
+        tuples = [(na_value, na_value)] + tuples + [(na_value, na_value)]
+        index = IntervalIndex.from_tuples(tuples, closed=closed)
+        result = index.is_overlapping
+        assert result is expected
+
+        # intervals with duplicate left values
+        a = [10, 15, 20, 25, 30, 35, 40, 45, 45, 50, 55, 60, 65, 70, 75, 80, 85]
+        b = [15, 20, 25, 30, 35, 40, 45, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90]
+        index = IntervalIndex.from_arrays(a, b, closed="right")
+        result = index.is_overlapping
+        assert result is False
+
+    @pytest.mark.parametrize(
+        "tuples",
+        [
+            list(zip(range(10), range(1, 11))),
+            list(
+                zip(
+                    date_range("20170101", periods=10),
+                    date_range("20170101", periods=10),
+                )
+            ),
+            list(
+                zip(
+                    timedelta_range("0 days", periods=10),
+                    timedelta_range("1 day", periods=10),
+                )
+            ),
+        ],
+    )
+    def test_to_tuples(self, tuples):
+        # GH 18756
+        idx = IntervalIndex.from_tuples(tuples)
+        result = idx.to_tuples()
+        expected = Index(com.asarray_tuplesafe(tuples))
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "tuples",
+        [
+            list(zip(range(10), range(1, 11))) + [np.nan],
+            list(
+                zip(
+                    date_range("20170101", periods=10),
+                    date_range("20170101", periods=10),
+                )
+            )
+            + [np.nan],
+            list(
+                zip(
+                    timedelta_range("0 days", periods=10),
+                    timedelta_range("1 day", periods=10),
+                )
+            )
+            + [np.nan],
+        ],
+    )
+    @pytest.mark.parametrize("na_tuple", [True, False])
+    def test_to_tuples_na(self, tuples, na_tuple):
+        # GH 18756
+        idx = IntervalIndex.from_tuples(tuples)
+        result = idx.to_tuples(na_tuple=na_tuple)
+
+        # check the non-NA portion
+        expected_notna = Index(com.asarray_tuplesafe(tuples[:-1]))
+        result_notna = result[:-1]
+        tm.assert_index_equal(result_notna, expected_notna)
+
+        # check the NA portion
+        result_na = result[-1]
+        if na_tuple:
+            assert isinstance(result_na, tuple)
+            assert len(result_na) == 2
+            assert all(isna(x) for x in result_na)
+        else:
+            assert isna(result_na)
+
+    def test_nbytes(self):
+        # GH 19209
+        left = np.arange(0, 4, dtype="i8")
+        right = np.arange(1, 5, dtype="i8")
+
+        result = IntervalIndex.from_arrays(left, right).nbytes
+        expected = 64  # 4 * 8 * 2
+        assert result == expected
+
+    @pytest.mark.parametrize("new_closed", ["left", "right", "both", "neither"])
+    def test_set_closed(self, name, closed, new_closed):
+        # GH 21670
+        index = interval_range(0, 5, closed=closed, name=name)
+        result = index.set_closed(new_closed)
+        expected = interval_range(0, 5, closed=new_closed, name=name)
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize("bad_closed", ["foo", 10, "LEFT", True, False])
+    def test_set_closed_errors(self, bad_closed):
+        # GH 21670
+        index = interval_range(0, 5)
+        msg = f"invalid option for 'closed': {bad_closed}"
+        with pytest.raises(ValueError, match=msg):
+            index.set_closed(bad_closed)
+
+    def test_is_all_dates(self):
+        # GH 23576
+        year_2017 = Interval(
+            Timestamp("2017-01-01 00:00:00"), Timestamp("2018-01-01 00:00:00")
+        )
+        year_2017_index = IntervalIndex([year_2017])
+        assert not year_2017_index._is_all_dates
+
+
+def test_dir():
+    # GH#27571 dir(interval_index) should not raise
+    index = IntervalIndex.from_arrays([0, 1], [1, 2])
+    result = dir(index)
+    assert "str" not in result
+
+
+def test_searchsorted_different_argument_classes(listlike_box):
+    # https://github.com/pandas-dev/pandas/issues/32762
+    values = IntervalIndex([Interval(0, 1), Interval(1, 2)])
+    result = values.searchsorted(listlike_box(values))
+    expected = np.array([0, 1], dtype=result.dtype)
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = values._data.searchsorted(listlike_box(values))
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "arg", [[1, 2], ["a", "b"], [Timestamp("2020-01-01", tz="Europe/London")] * 2]
+)
+def test_searchsorted_invalid_argument(arg):
+    values = IntervalIndex([Interval(0, 1), Interval(1, 2)])
+    msg = "'<' not supported between instances of 'pandas._libs.interval.Interval' and "
+    with pytest.raises(TypeError, match=msg):
+        values.searchsorted(arg)
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_interval_range.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_interval_range.py
new file mode 100644
index 0000000000000000000000000000000000000000..e8de59f84bcc6d6cece2768f942b4599d3ce1a2d
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_interval_range.py
@@ -0,0 +1,369 @@
+from datetime import timedelta
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import is_integer
+
+from pandas import (
+    DateOffset,
+    Interval,
+    IntervalIndex,
+    Timedelta,
+    Timestamp,
+    date_range,
+    interval_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+
+from pandas.tseries.offsets import Day
+
+
+@pytest.fixture(params=[None, "foo"])
+def name(request):
+    return request.param
+
+
+class TestIntervalRange:
+    @pytest.mark.parametrize("freq, periods", [(1, 100), (2.5, 40), (5, 20), (25, 4)])
+    def test_constructor_numeric(self, closed, name, freq, periods):
+        start, end = 0, 100
+        breaks = np.arange(101, step=freq)
+        expected = IntervalIndex.from_breaks(breaks, name=name, closed=closed)
+
+        # defined from start/end/freq
+        result = interval_range(
+            start=start, end=end, freq=freq, name=name, closed=closed
+        )
+        tm.assert_index_equal(result, expected)
+
+        # defined from start/periods/freq
+        result = interval_range(
+            start=start, periods=periods, freq=freq, name=name, closed=closed
+        )
+        tm.assert_index_equal(result, expected)
+
+        # defined from end/periods/freq
+        result = interval_range(
+            end=end, periods=periods, freq=freq, name=name, closed=closed
+        )
+        tm.assert_index_equal(result, expected)
+
+        # GH 20976: linspace behavior defined from start/end/periods
+        result = interval_range(
+            start=start, end=end, periods=periods, name=name, closed=closed
+        )
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", [None, "US/Eastern"])
+    @pytest.mark.parametrize(
+        "freq, periods", [("D", 364), ("2D", 182), ("22D18h", 16), ("ME", 11)]
+    )
+    def test_constructor_timestamp(self, closed, name, freq, periods, tz):
+        start, end = Timestamp("20180101", tz=tz), Timestamp("20181231", tz=tz)
+        breaks = date_range(start=start, end=end, freq=freq)
+        expected = IntervalIndex.from_breaks(breaks, name=name, closed=closed)
+
+        # defined from start/end/freq
+        result = interval_range(
+            start=start, end=end, freq=freq, name=name, closed=closed
+        )
+        tm.assert_index_equal(result, expected)
+
+        # defined from start/periods/freq
+        result = interval_range(
+            start=start, periods=periods, freq=freq, name=name, closed=closed
+        )
+        tm.assert_index_equal(result, expected)
+
+        # defined from end/periods/freq
+        result = interval_range(
+            end=end, periods=periods, freq=freq, name=name, closed=closed
+        )
+        tm.assert_index_equal(result, expected)
+
+        # GH 20976: linspace behavior defined from start/end/periods
+        if not breaks.freq.n == 1 and tz is None:
+            result = interval_range(
+                start=start, end=end, periods=periods, name=name, closed=closed
+            )
+            tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "freq, periods", [("D", 100), ("2D12h", 40), ("5D", 20), ("25D", 4)]
+    )
+    def test_constructor_timedelta(self, closed, name, freq, periods):
+        start, end = Timedelta("0 days"), Timedelta("100 days")
+        breaks = timedelta_range(start=start, end=end, freq=freq)
+        expected = IntervalIndex.from_breaks(breaks, name=name, closed=closed)
+
+        # defined from start/end/freq
+        result = interval_range(
+            start=start, end=end, freq=freq, name=name, closed=closed
+        )
+        tm.assert_index_equal(result, expected)
+
+        # defined from start/periods/freq
+        result = interval_range(
+            start=start, periods=periods, freq=freq, name=name, closed=closed
+        )
+        tm.assert_index_equal(result, expected)
+
+        # defined from end/periods/freq
+        result = interval_range(
+            end=end, periods=periods, freq=freq, name=name, closed=closed
+        )
+        tm.assert_index_equal(result, expected)
+
+        # GH 20976: linspace behavior defined from start/end/periods
+        result = interval_range(
+            start=start, end=end, periods=periods, name=name, closed=closed
+        )
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "start, end, freq, expected_endpoint",
+        [
+            (0, 10, 3, 9),
+            (0, 10, 1.5, 9),
+            (0.5, 10, 3, 9.5),
+            (Timedelta("0D"), Timedelta("10D"), "2D4h", Timedelta("8D16h")),
+            (
+                Timestamp("2018-01-01"),
+                Timestamp("2018-02-09"),
+                "MS",
+                Timestamp("2018-02-01"),
+            ),
+            (
+                Timestamp("2018-01-01", tz="US/Eastern"),
+                Timestamp("2018-01-20", tz="US/Eastern"),
+                "5D12h",
+                Timestamp("2018-01-17 12:00:00", tz="US/Eastern"),
+            ),
+        ],
+    )
+    def test_early_truncation(self, start, end, freq, expected_endpoint):
+        # index truncates early if freq causes end to be skipped
+        result = interval_range(start=start, end=end, freq=freq)
+        result_endpoint = result.right[-1]
+        assert result_endpoint == expected_endpoint
+
+    @pytest.mark.parametrize(
+        "start, end, freq",
+        [(0.5, None, None), (None, 4.5, None), (0.5, None, 1.5), (None, 6.5, 1.5)],
+    )
+    def test_no_invalid_float_truncation(self, start, end, freq):
+        # GH 21161
+        if freq is None:
+            breaks = [0.5, 1.5, 2.5, 3.5, 4.5]
+        else:
+            breaks = [0.5, 2.0, 3.5, 5.0, 6.5]
+        expected = IntervalIndex.from_breaks(breaks)
+
+        result = interval_range(start=start, end=end, periods=4, freq=freq)
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "start, mid, end",
+        [
+            (
+                Timestamp("2018-03-10", tz="US/Eastern"),
+                Timestamp("2018-03-10 23:30:00", tz="US/Eastern"),
+                Timestamp("2018-03-12", tz="US/Eastern"),
+            ),
+            (
+                Timestamp("2018-11-03", tz="US/Eastern"),
+                Timestamp("2018-11-04 00:30:00", tz="US/Eastern"),
+                Timestamp("2018-11-05", tz="US/Eastern"),
+            ),
+        ],
+    )
+    def test_linspace_dst_transition(self, start, mid, end):
+        # GH 20976: linspace behavior defined from start/end/periods
+        # accounts for the hour gained/lost during DST transition
+        start = start.as_unit("ns")
+        mid = mid.as_unit("ns")
+        end = end.as_unit("ns")
+        result = interval_range(start=start, end=end, periods=2)
+        expected = IntervalIndex.from_breaks([start, mid, end])
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize("freq", [2, 2.0])
+    @pytest.mark.parametrize("end", [10, 10.0])
+    @pytest.mark.parametrize("start", [0, 0.0])
+    def test_float_subtype(self, start, end, freq):
+        # Has float subtype if any of start/end/freq are float, even if all
+        # resulting endpoints can safely be upcast to integers
+
+        # defined from start/end/freq
+        index = interval_range(start=start, end=end, freq=freq)
+        result = index.dtype.subtype
+        expected = "int64" if is_integer(start + end + freq) else "float64"
+        assert result == expected
+
+        # defined from start/periods/freq
+        index = interval_range(start=start, periods=5, freq=freq)
+        result = index.dtype.subtype
+        expected = "int64" if is_integer(start + freq) else "float64"
+        assert result == expected
+
+        # defined from end/periods/freq
+        index = interval_range(end=end, periods=5, freq=freq)
+        result = index.dtype.subtype
+        expected = "int64" if is_integer(end + freq) else "float64"
+        assert result == expected
+
+        # GH 20976: linspace behavior defined from start/end/periods
+        index = interval_range(start=start, end=end, periods=5)
+        result = index.dtype.subtype
+        expected = "int64" if is_integer(start + end) else "float64"
+        assert result == expected
+
+    def test_interval_range_fractional_period(self):
+        # float value for periods
+        expected = interval_range(start=0, periods=10)
+        msg = "Non-integer 'periods' in pd.date_range, .* pd.interval_range"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = interval_range(start=0, periods=10.5)
+        tm.assert_index_equal(result, expected)
+
+    def test_constructor_coverage(self):
+        # equivalent timestamp-like start/end
+        start, end = Timestamp("2017-01-01"), Timestamp("2017-01-15")
+        expected = interval_range(start=start, end=end)
+
+        result = interval_range(start=start.to_pydatetime(), end=end.to_pydatetime())
+        tm.assert_index_equal(result, expected)
+
+        result = interval_range(start=start.asm8, end=end.asm8)
+        tm.assert_index_equal(result, expected)
+
+        # equivalent freq with timestamp
+        equiv_freq = [
+            "D",
+            Day(),
+            Timedelta(days=1),
+            timedelta(days=1),
+            DateOffset(days=1),
+        ]
+        for freq in equiv_freq:
+            result = interval_range(start=start, end=end, freq=freq)
+            tm.assert_index_equal(result, expected)
+
+        # equivalent timedelta-like start/end
+        start, end = Timedelta(days=1), Timedelta(days=10)
+        expected = interval_range(start=start, end=end)
+
+        result = interval_range(start=start.to_pytimedelta(), end=end.to_pytimedelta())
+        tm.assert_index_equal(result, expected)
+
+        result = interval_range(start=start.asm8, end=end.asm8)
+        tm.assert_index_equal(result, expected)
+
+        # equivalent freq with timedelta
+        equiv_freq = ["D", Day(), Timedelta(days=1), timedelta(days=1)]
+        for freq in equiv_freq:
+            result = interval_range(start=start, end=end, freq=freq)
+            tm.assert_index_equal(result, expected)
+
+    def test_errors(self):
+        # not enough params
+        msg = (
+            "Of the four parameters: start, end, periods, and freq, "
+            "exactly three must be specified"
+        )
+
+        with pytest.raises(ValueError, match=msg):
+            interval_range(start=0)
+
+        with pytest.raises(ValueError, match=msg):
+            interval_range(end=5)
+
+        with pytest.raises(ValueError, match=msg):
+            interval_range(periods=2)
+
+        with pytest.raises(ValueError, match=msg):
+            interval_range()
+
+        # too many params
+        with pytest.raises(ValueError, match=msg):
+            interval_range(start=0, end=5, periods=6, freq=1.5)
+
+        # mixed units
+        msg = "start, end, freq need to be type compatible"
+        with pytest.raises(TypeError, match=msg):
+            interval_range(start=0, end=Timestamp("20130101"), freq=2)
+
+        with pytest.raises(TypeError, match=msg):
+            interval_range(start=0, end=Timedelta("1 day"), freq=2)
+
+        with pytest.raises(TypeError, match=msg):
+            interval_range(start=0, end=10, freq="D")
+
+        with pytest.raises(TypeError, match=msg):
+            interval_range(start=Timestamp("20130101"), end=10, freq="D")
+
+        with pytest.raises(TypeError, match=msg):
+            interval_range(
+                start=Timestamp("20130101"), end=Timedelta("1 day"), freq="D"
+            )
+
+        with pytest.raises(TypeError, match=msg):
+            interval_range(
+                start=Timestamp("20130101"), end=Timestamp("20130110"), freq=2
+            )
+
+        with pytest.raises(TypeError, match=msg):
+            interval_range(start=Timedelta("1 day"), end=10, freq="D")
+
+        with pytest.raises(TypeError, match=msg):
+            interval_range(
+                start=Timedelta("1 day"), end=Timestamp("20130110"), freq="D"
+            )
+
+        with pytest.raises(TypeError, match=msg):
+            interval_range(start=Timedelta("1 day"), end=Timedelta("10 days"), freq=2)
+
+        # invalid periods
+        msg = "periods must be a number, got foo"
+        with pytest.raises(TypeError, match=msg):
+            interval_range(start=0, periods="foo")
+
+        # invalid start
+        msg = "start must be numeric or datetime-like, got foo"
+        with pytest.raises(ValueError, match=msg):
+            interval_range(start="foo", periods=10)
+
+        # invalid end
+        msg = r"end must be numeric or datetime-like, got \(0, 1\]"
+        with pytest.raises(ValueError, match=msg):
+            interval_range(end=Interval(0, 1), periods=10)
+
+        # invalid freq for datetime-like
+        msg = "freq must be numeric or convertible to DateOffset, got foo"
+        with pytest.raises(ValueError, match=msg):
+            interval_range(start=0, end=10, freq="foo")
+
+        with pytest.raises(ValueError, match=msg):
+            interval_range(start=Timestamp("20130101"), periods=10, freq="foo")
+
+        with pytest.raises(ValueError, match=msg):
+            interval_range(end=Timedelta("1 day"), periods=10, freq="foo")
+
+        # mixed tz
+        start = Timestamp("2017-01-01", tz="US/Eastern")
+        end = Timestamp("2017-01-07", tz="US/Pacific")
+        msg = "Start and end cannot both be tz-aware with different timezones"
+        with pytest.raises(TypeError, match=msg):
+            interval_range(start=start, end=end)
+
+    def test_float_freq(self):
+        # GH 54477
+        result = interval_range(0, 1, freq=0.1)
+        expected = IntervalIndex.from_breaks([0 + 0.1 * n for n in range(11)])
+        tm.assert_index_equal(result, expected)
+
+        result = interval_range(0, 1, freq=0.6)
+        expected = IntervalIndex.from_breaks([0, 0.6])
+        tm.assert_index_equal(result, expected)
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_interval_tree.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_interval_tree.py
new file mode 100644
index 0000000000000000000000000000000000000000..78388e84fc6dc1af7dadd78b88a1155ed8cfd812
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_interval_tree.py
@@ -0,0 +1,208 @@
+from itertools import permutations
+
+import numpy as np
+import pytest
+
+from pandas._libs.interval import IntervalTree
+from pandas.compat import IS64
+
+import pandas._testing as tm
+
+
+def skipif_32bit(param):
+    """
+    Skip parameters in a parametrize on 32bit systems. Specifically used
+    here to skip leaf_size parameters related to GH 23440.
+    """
+    marks = pytest.mark.skipif(not IS64, reason="GH 23440: int type mismatch on 32bit")
+    return pytest.param(param, marks=marks)
+
+
+@pytest.fixture(params=["int64", "float64", "uint64"])
+def dtype(request):
+    return request.param
+
+
+@pytest.fixture(params=[skipif_32bit(1), skipif_32bit(2), 10])
+def leaf_size(request):
+    """
+    Fixture to specify IntervalTree leaf_size parameter; to be used with the
+    tree fixture.
+    """
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        np.arange(5, dtype="int64"),
+        np.arange(5, dtype="uint64"),
+        np.arange(5, dtype="float64"),
+        np.array([0, 1, 2, 3, 4, np.nan], dtype="float64"),
+    ]
+)
+def tree(request, leaf_size):
+    left = request.param
+    return IntervalTree(left, left + 2, leaf_size=leaf_size)
+
+
+class TestIntervalTree:
+    def test_get_indexer(self, tree):
+        result = tree.get_indexer(np.array([1.0, 5.5, 6.5]))
+        expected = np.array([0, 4, -1], dtype="intp")
+        tm.assert_numpy_array_equal(result, expected)
+
+        with pytest.raises(
+            KeyError, match="'indexer does not intersect a unique set of intervals'"
+        ):
+            tree.get_indexer(np.array([3.0]))
+
+    @pytest.mark.parametrize(
+        "dtype, target_value, target_dtype",
+        [("int64", 2**63 + 1, "uint64"), ("uint64", -1, "int64")],
+    )
+    def test_get_indexer_overflow(self, dtype, target_value, target_dtype):
+        left, right = np.array([0, 1], dtype=dtype), np.array([1, 2], dtype=dtype)
+        tree = IntervalTree(left, right)
+
+        result = tree.get_indexer(np.array([target_value], dtype=target_dtype))
+        expected = np.array([-1], dtype="intp")
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_get_indexer_non_unique(self, tree):
+        indexer, missing = tree.get_indexer_non_unique(np.array([1.0, 2.0, 6.5]))
+
+        result = indexer[:1]
+        expected = np.array([0], dtype="intp")
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = np.sort(indexer[1:3])
+        expected = np.array([0, 1], dtype="intp")
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = np.sort(indexer[3:])
+        expected = np.array([-1], dtype="intp")
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = missing
+        expected = np.array([2], dtype="intp")
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype, target_value, target_dtype",
+        [("int64", 2**63 + 1, "uint64"), ("uint64", -1, "int64")],
+    )
+    def test_get_indexer_non_unique_overflow(self, dtype, target_value, target_dtype):
+        left, right = np.array([0, 2], dtype=dtype), np.array([1, 3], dtype=dtype)
+        tree = IntervalTree(left, right)
+        target = np.array([target_value], dtype=target_dtype)
+
+        result_indexer, result_missing = tree.get_indexer_non_unique(target)
+        expected_indexer = np.array([-1], dtype="intp")
+        tm.assert_numpy_array_equal(result_indexer, expected_indexer)
+
+        expected_missing = np.array([0], dtype="intp")
+        tm.assert_numpy_array_equal(result_missing, expected_missing)
+
+    def test_duplicates(self, dtype):
+        left = np.array([0, 0, 0], dtype=dtype)
+        tree = IntervalTree(left, left + 1)
+
+        with pytest.raises(
+            KeyError, match="'indexer does not intersect a unique set of intervals'"
+        ):
+            tree.get_indexer(np.array([0.5]))
+
+        indexer, missing = tree.get_indexer_non_unique(np.array([0.5]))
+        result = np.sort(indexer)
+        expected = np.array([0, 1, 2], dtype="intp")
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = missing
+        expected = np.array([], dtype="intp")
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "leaf_size", [skipif_32bit(1), skipif_32bit(10), skipif_32bit(100), 10000]
+    )
+    def test_get_indexer_closed(self, closed, leaf_size):
+        x = np.arange(1000, dtype="float64")
+        found = x.astype("intp")
+        not_found = (-1 * np.ones(1000)).astype("intp")
+
+        tree = IntervalTree(x, x + 0.5, closed=closed, leaf_size=leaf_size)
+        tm.assert_numpy_array_equal(found, tree.get_indexer(x + 0.25))
+
+        expected = found if tree.closed_left else not_found
+        tm.assert_numpy_array_equal(expected, tree.get_indexer(x + 0.0))
+
+        expected = found if tree.closed_right else not_found
+        tm.assert_numpy_array_equal(expected, tree.get_indexer(x + 0.5))
+
+    @pytest.mark.parametrize(
+        "left, right, expected",
+        [
+            (np.array([0, 1, 4], dtype="int64"), np.array([2, 3, 5]), True),
+            (np.array([0, 1, 2], dtype="int64"), np.array([5, 4, 3]), True),
+            (np.array([0, 1, np.nan]), np.array([5, 4, np.nan]), True),
+            (np.array([0, 2, 4], dtype="int64"), np.array([1, 3, 5]), False),
+            (np.array([0, 2, np.nan]), np.array([1, 3, np.nan]), False),
+        ],
+    )
+    @pytest.mark.parametrize("order", (list(x) for x in permutations(range(3))))
+    def test_is_overlapping(self, closed, order, left, right, expected):
+        # GH 23309
+        tree = IntervalTree(left[order], right[order], closed=closed)
+        result = tree.is_overlapping
+        assert result is expected
+
+    @pytest.mark.parametrize("order", (list(x) for x in permutations(range(3))))
+    def test_is_overlapping_endpoints(self, closed, order):
+        """shared endpoints are marked as overlapping"""
+        # GH 23309
+        left, right = np.arange(3, dtype="int64"), np.arange(1, 4)
+        tree = IntervalTree(left[order], right[order], closed=closed)
+        result = tree.is_overlapping
+        expected = closed == "both"
+        assert result is expected
+
+    @pytest.mark.parametrize(
+        "left, right",
+        [
+            (np.array([], dtype="int64"), np.array([], dtype="int64")),
+            (np.array([0], dtype="int64"), np.array([1], dtype="int64")),
+            (np.array([np.nan]), np.array([np.nan])),
+            (np.array([np.nan] * 3), np.array([np.nan] * 3)),
+        ],
+    )
+    def test_is_overlapping_trivial(self, closed, left, right):
+        # GH 23309
+        tree = IntervalTree(left, right, closed=closed)
+        assert tree.is_overlapping is False
+
+    @pytest.mark.skipif(not IS64, reason="GH 23440")
+    def test_construction_overflow(self):
+        # GH 25485
+        left, right = np.arange(101, dtype="int64"), [np.iinfo(np.int64).max] * 101
+        tree = IntervalTree(left, right)
+
+        # pivot should be average of left/right medians
+        result = tree.root.pivot
+        expected = (50 + np.iinfo(np.int64).max) / 2
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "left, right, expected",
+        [
+            ([-np.inf, 1.0], [1.0, 2.0], 0.0),
+            ([-np.inf, -2.0], [-2.0, -1.0], -2.0),
+            ([-2.0, -1.0], [-1.0, np.inf], 0.0),
+            ([1.0, 2.0], [2.0, np.inf], 2.0),
+        ],
+    )
+    def test_inf_bound_infinite_recursion(self, left, right, expected):
+        # GH 46658
+
+        tree = IntervalTree(left * 101, right * 101)
+
+        result = tree.root.pivot
+        assert result == expected
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_join.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_join.py
new file mode 100644
index 0000000000000000000000000000000000000000..2f42c530a66868fa69b1d449e75f84d42592bb77
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_join.py
@@ -0,0 +1,44 @@
+import pytest
+
+from pandas import (
+    IntervalIndex,
+    MultiIndex,
+    RangeIndex,
+)
+import pandas._testing as tm
+
+
+@pytest.fixture
+def range_index():
+    return RangeIndex(3, name="range_index")
+
+
+@pytest.fixture
+def interval_index():
+    return IntervalIndex.from_tuples(
+        [(0.0, 1.0), (1.0, 2.0), (1.5, 2.5)], name="interval_index"
+    )
+
+
+def test_join_overlapping_in_mi_to_same_intervalindex(range_index, interval_index):
+    #  GH-45661
+    multi_index = MultiIndex.from_product([interval_index, range_index])
+    result = multi_index.join(interval_index)
+
+    tm.assert_index_equal(result, multi_index)
+
+
+def test_join_overlapping_to_multiindex_with_same_interval(range_index, interval_index):
+    #  GH-45661
+    multi_index = MultiIndex.from_product([interval_index, range_index])
+    result = interval_index.join(multi_index)
+
+    tm.assert_index_equal(result, multi_index)
+
+
+def test_join_overlapping_interval_to_another_intervalindex(interval_index):
+    #  GH-45661
+    flipped_interval_index = interval_index[::-1]
+    result = interval_index.join(flipped_interval_index)
+
+    tm.assert_index_equal(result, interval_index)
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_pickle.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_pickle.py
new file mode 100644
index 0000000000000000000000000000000000000000..308a90e72eab5db55f300341212d2c04e82c6900
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_pickle.py
@@ -0,0 +1,13 @@
+import pytest
+
+from pandas import IntervalIndex
+import pandas._testing as tm
+
+
+class TestPickle:
+    @pytest.mark.parametrize("closed", ["left", "right", "both"])
+    def test_pickle_round_trip_closed(self, closed):
+        # https://github.com/pandas-dev/pandas/issues/35658
+        idx = IntervalIndex.from_tuples([(1, 2), (2, 3)], closed=closed)
+        result = tm.round_trip_pickle(idx)
+        tm.assert_index_equal(result, idx)
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_setops.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_setops.py
new file mode 100644
index 0000000000000000000000000000000000000000..1b0816a9405cb9dd6ed81691e72012c948b898a2
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/interval/test_setops.py
@@ -0,0 +1,208 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Index,
+    IntervalIndex,
+    Timestamp,
+    interval_range,
+)
+import pandas._testing as tm
+
+
+def monotonic_index(start, end, dtype="int64", closed="right"):
+    return IntervalIndex.from_breaks(np.arange(start, end, dtype=dtype), closed=closed)
+
+
+def empty_index(dtype="int64", closed="right"):
+    return IntervalIndex(np.array([], dtype=dtype), closed=closed)
+
+
+class TestIntervalIndex:
+    def test_union(self, closed, sort):
+        index = monotonic_index(0, 11, closed=closed)
+        other = monotonic_index(5, 13, closed=closed)
+
+        expected = monotonic_index(0, 13, closed=closed)
+        result = index[::-1].union(other, sort=sort)
+        if sort in (None, True):
+            tm.assert_index_equal(result, expected)
+        else:
+            tm.assert_index_equal(result.sort_values(), expected)
+
+        result = other[::-1].union(index, sort=sort)
+        if sort in (None, True):
+            tm.assert_index_equal(result, expected)
+        else:
+            tm.assert_index_equal(result.sort_values(), expected)
+
+        tm.assert_index_equal(index.union(index, sort=sort), index)
+        tm.assert_index_equal(index.union(index[:1], sort=sort), index)
+
+    def test_union_empty_result(self, closed, sort):
+        # GH 19101: empty result, same dtype
+        index = empty_index(dtype="int64", closed=closed)
+        result = index.union(index, sort=sort)
+        tm.assert_index_equal(result, index)
+
+        # GH 19101: empty result, different numeric dtypes -> common dtype is f8
+        other = empty_index(dtype="float64", closed=closed)
+        result = index.union(other, sort=sort)
+        expected = other
+        tm.assert_index_equal(result, expected)
+
+        other = index.union(index, sort=sort)
+        tm.assert_index_equal(result, expected)
+
+        other = empty_index(dtype="uint64", closed=closed)
+        result = index.union(other, sort=sort)
+        tm.assert_index_equal(result, expected)
+
+        result = other.union(index, sort=sort)
+        tm.assert_index_equal(result, expected)
+
+    def test_intersection(self, closed, sort):
+        index = monotonic_index(0, 11, closed=closed)
+        other = monotonic_index(5, 13, closed=closed)
+
+        expected = monotonic_index(5, 11, closed=closed)
+        result = index[::-1].intersection(other, sort=sort)
+        if sort in (None, True):
+            tm.assert_index_equal(result, expected)
+        else:
+            tm.assert_index_equal(result.sort_values(), expected)
+
+        result = other[::-1].intersection(index, sort=sort)
+        if sort in (None, True):
+            tm.assert_index_equal(result, expected)
+        else:
+            tm.assert_index_equal(result.sort_values(), expected)
+
+        tm.assert_index_equal(index.intersection(index, sort=sort), index)
+
+        # GH 26225: nested intervals
+        index = IntervalIndex.from_tuples([(1, 2), (1, 3), (1, 4), (0, 2)])
+        other = IntervalIndex.from_tuples([(1, 2), (1, 3)])
+        expected = IntervalIndex.from_tuples([(1, 2), (1, 3)])
+        result = index.intersection(other)
+        tm.assert_index_equal(result, expected)
+
+        # GH 26225
+        index = IntervalIndex.from_tuples([(0, 3), (0, 2)])
+        other = IntervalIndex.from_tuples([(0, 2), (1, 3)])
+        expected = IntervalIndex.from_tuples([(0, 2)])
+        result = index.intersection(other)
+        tm.assert_index_equal(result, expected)
+
+        # GH 26225: duplicate nan element
+        index = IntervalIndex([np.nan, np.nan])
+        other = IntervalIndex([np.nan])
+        expected = IntervalIndex([np.nan])
+        result = index.intersection(other)
+        tm.assert_index_equal(result, expected)
+
+    def test_intersection_empty_result(self, closed, sort):
+        index = monotonic_index(0, 11, closed=closed)
+
+        # GH 19101: empty result, same dtype
+        other = monotonic_index(300, 314, closed=closed)
+        expected = empty_index(dtype="int64", closed=closed)
+        result = index.intersection(other, sort=sort)
+        tm.assert_index_equal(result, expected)
+
+        # GH 19101: empty result, different numeric dtypes -> common dtype is float64
+        other = monotonic_index(300, 314, dtype="float64", closed=closed)
+        result = index.intersection(other, sort=sort)
+        expected = other[:0]
+        tm.assert_index_equal(result, expected)
+
+        other = monotonic_index(300, 314, dtype="uint64", closed=closed)
+        result = index.intersection(other, sort=sort)
+        tm.assert_index_equal(result, expected)
+
+    def test_intersection_duplicates(self):
+        # GH#38743
+        index = IntervalIndex.from_tuples([(1, 2), (1, 2), (2, 3), (3, 4)])
+        other = IntervalIndex.from_tuples([(1, 2), (2, 3)])
+        expected = IntervalIndex.from_tuples([(1, 2), (2, 3)])
+        result = index.intersection(other)
+        tm.assert_index_equal(result, expected)
+
+    def test_difference(self, closed, sort):
+        index = IntervalIndex.from_arrays([1, 0, 3, 2], [1, 2, 3, 4], closed=closed)
+        result = index.difference(index[:1], sort=sort)
+        expected = index[1:]
+        if sort is None:
+            expected = expected.sort_values()
+        tm.assert_index_equal(result, expected)
+
+        # GH 19101: empty result, same dtype
+        result = index.difference(index, sort=sort)
+        expected = empty_index(dtype="int64", closed=closed)
+        tm.assert_index_equal(result, expected)
+
+        # GH 19101: empty result, different dtypes
+        other = IntervalIndex.from_arrays(
+            index.left.astype("float64"), index.right, closed=closed
+        )
+        result = index.difference(other, sort=sort)
+        tm.assert_index_equal(result, expected)
+
+    def test_symmetric_difference(self, closed, sort):
+        index = monotonic_index(0, 11, closed=closed)
+        result = index[1:].symmetric_difference(index[:-1], sort=sort)
+        expected = IntervalIndex([index[0], index[-1]])
+        if sort in (None, True):
+            tm.assert_index_equal(result, expected)
+        else:
+            tm.assert_index_equal(result.sort_values(), expected)
+
+        # GH 19101: empty result, same dtype
+        result = index.symmetric_difference(index, sort=sort)
+        expected = empty_index(dtype="int64", closed=closed)
+        if sort in (None, True):
+            tm.assert_index_equal(result, expected)
+        else:
+            tm.assert_index_equal(result.sort_values(), expected)
+
+        # GH 19101: empty result, different dtypes
+        other = IntervalIndex.from_arrays(
+            index.left.astype("float64"), index.right, closed=closed
+        )
+        result = index.symmetric_difference(other, sort=sort)
+        expected = empty_index(dtype="float64", closed=closed)
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.filterwarnings("ignore:'<' not supported between:RuntimeWarning")
+    @pytest.mark.parametrize(
+        "op_name", ["union", "intersection", "difference", "symmetric_difference"]
+    )
+    def test_set_incompatible_types(self, closed, op_name, sort):
+        index = monotonic_index(0, 11, closed=closed)
+        set_op = getattr(index, op_name)
+
+        # TODO: standardize return type of non-union setops type(self vs other)
+        # non-IntervalIndex
+        if op_name == "difference":
+            expected = index
+        else:
+            expected = getattr(index.astype("O"), op_name)(Index([1, 2, 3]))
+        result = set_op(Index([1, 2, 3]), sort=sort)
+        tm.assert_index_equal(result, expected)
+
+        # mixed closed -> cast to object
+        for other_closed in {"right", "left", "both", "neither"} - {closed}:
+            other = monotonic_index(0, 11, closed=other_closed)
+            expected = getattr(index.astype(object), op_name)(other, sort=sort)
+            if op_name == "difference":
+                expected = index
+            result = set_op(other, sort=sort)
+            tm.assert_index_equal(result, expected)
+
+        # GH 19016: incompatible dtypes -> cast to object
+        other = interval_range(Timestamp("20180101"), periods=9, closed=closed)
+        expected = getattr(index.astype(object), op_name)(other, sort=sort)
+        if op_name == "difference":
+            expected = index
+        result = set_op(other, sort=sort)
+        tm.assert_index_equal(result, expected)
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/multi/test_compat.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/multi/test_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..27a8c6e9b715880a57e711e8eab457ae553a4867
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/multi/test_compat.py
@@ -0,0 +1,122 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import MultiIndex
+import pandas._testing as tm
+
+
+def test_numeric_compat(idx):
+    with pytest.raises(TypeError, match="cannot perform __mul__"):
+        idx * 1
+
+    with pytest.raises(TypeError, match="cannot perform __rmul__"):
+        1 * idx
+
+    div_err = "cannot perform __truediv__"
+    with pytest.raises(TypeError, match=div_err):
+        idx / 1
+
+    div_err = div_err.replace(" __", " __r")
+    with pytest.raises(TypeError, match=div_err):
+        1 / idx
+
+    with pytest.raises(TypeError, match="cannot perform __floordiv__"):
+        idx // 1
+
+    with pytest.raises(TypeError, match="cannot perform __rfloordiv__"):
+        1 // idx
+
+
+@pytest.mark.parametrize("method", ["all", "any", "__invert__"])
+def test_logical_compat(idx, method):
+    msg = f"cannot perform {method}"
+
+    with pytest.raises(TypeError, match=msg):
+        getattr(idx, method)()
+
+
+def test_inplace_mutation_resets_values():
+    levels = [["a", "b", "c"], [4]]
+    levels2 = [[1, 2, 3], ["a"]]
+    codes = [[0, 1, 0, 2, 2, 0], [0, 0, 0, 0, 0, 0]]
+
+    mi1 = MultiIndex(levels=levels, codes=codes)
+    mi2 = MultiIndex(levels=levels2, codes=codes)
+
+    # instantiating MultiIndex should not access/cache _.values
+    assert "_values" not in mi1._cache
+    assert "_values" not in mi2._cache
+
+    vals = mi1.values.copy()
+    vals2 = mi2.values.copy()
+
+    # accessing .values should cache ._values
+    assert mi1._values is mi1._cache["_values"]
+    assert mi1.values is mi1._cache["_values"]
+    assert isinstance(mi1._cache["_values"], np.ndarray)
+
+    # Make sure level setting works
+    new_vals = mi1.set_levels(levels2).values
+    tm.assert_almost_equal(vals2, new_vals)
+
+    #  Doesn't drop _values from _cache [implementation detail]
+    tm.assert_almost_equal(mi1._cache["_values"], vals)
+
+    # ...and values is still same too
+    tm.assert_almost_equal(mi1.values, vals)
+
+    # Make sure label setting works too
+    codes2 = [[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]
+    exp_values = np.empty((6,), dtype=object)
+    exp_values[:] = [(1, "a")] * 6
+
+    # Must be 1d array of tuples
+    assert exp_values.shape == (6,)
+
+    new_mi = mi2.set_codes(codes2)
+    assert "_values" not in new_mi._cache
+    new_values = new_mi.values
+    assert "_values" in new_mi._cache
+
+    # Shouldn't change cache
+    tm.assert_almost_equal(mi2._cache["_values"], vals2)
+
+    # Should have correct values
+    tm.assert_almost_equal(exp_values, new_values)
+
+
+def test_boxable_categorical_values():
+    cat = pd.Categorical(pd.date_range("2012-01-01", periods=3, freq="h"))
+    result = MultiIndex.from_product([["a", "b", "c"], cat]).values
+    expected = pd.Series(
+        [
+            ("a", pd.Timestamp("2012-01-01 00:00:00")),
+            ("a", pd.Timestamp("2012-01-01 01:00:00")),
+            ("a", pd.Timestamp("2012-01-01 02:00:00")),
+            ("b", pd.Timestamp("2012-01-01 00:00:00")),
+            ("b", pd.Timestamp("2012-01-01 01:00:00")),
+            ("b", pd.Timestamp("2012-01-01 02:00:00")),
+            ("c", pd.Timestamp("2012-01-01 00:00:00")),
+            ("c", pd.Timestamp("2012-01-01 01:00:00")),
+            ("c", pd.Timestamp("2012-01-01 02:00:00")),
+        ]
+    ).values
+    tm.assert_numpy_array_equal(result, expected)
+    result = pd.DataFrame({"a": ["a", "b", "c"], "b": cat, "c": np.array(cat)}).values
+    expected = pd.DataFrame(
+        {
+            "a": ["a", "b", "c"],
+            "b": [
+                pd.Timestamp("2012-01-01 00:00:00"),
+                pd.Timestamp("2012-01-01 01:00:00"),
+                pd.Timestamp("2012-01-01 02:00:00"),
+            ],
+            "c": [
+                pd.Timestamp("2012-01-01 00:00:00"),
+                pd.Timestamp("2012-01-01 01:00:00"),
+                pd.Timestamp("2012-01-01 02:00:00"),
+            ],
+        }
+    ).values
+    tm.assert_numpy_array_equal(result, expected)
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/multi/test_copy.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/multi/test_copy.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e09a580f9528bc8197d55c6a7533098e0129fa2
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/multi/test_copy.py
@@ -0,0 +1,96 @@
+from copy import (
+    copy,
+    deepcopy,
+)
+
+import pytest
+
+from pandas import MultiIndex
+import pandas._testing as tm
+
+
+def assert_multiindex_copied(copy, original):
+    # Levels should be (at least, shallow copied)
+    tm.assert_copy(copy.levels, original.levels)
+    tm.assert_almost_equal(copy.codes, original.codes)
+
+    # Labels doesn't matter which way copied
+    tm.assert_almost_equal(copy.codes, original.codes)
+    assert copy.codes is not original.codes
+
+    # Names doesn't matter which way copied
+    assert copy.names == original.names
+    assert copy.names is not original.names
+
+    # Sort order should be copied
+    assert copy.sortorder == original.sortorder
+
+
+def test_copy(idx):
+    i_copy = idx.copy()
+
+    assert_multiindex_copied(i_copy, idx)
+
+
+def test_shallow_copy(idx):
+    i_copy = idx._view()
+
+    assert_multiindex_copied(i_copy, idx)
+
+
+def test_view(idx):
+    i_view = idx.view()
+    assert_multiindex_copied(i_view, idx)
+
+
+@pytest.mark.parametrize("func", [copy, deepcopy])
+def test_copy_and_deepcopy(func):
+    idx = MultiIndex(
+        levels=[["foo", "bar"], ["fizz", "buzz"]],
+        codes=[[0, 0, 0, 1], [0, 0, 1, 1]],
+        names=["first", "second"],
+    )
+    idx_copy = func(idx)
+    assert idx_copy is not idx
+    assert idx_copy.equals(idx)
+
+
+@pytest.mark.parametrize("deep", [True, False])
+def test_copy_method(deep):
+    idx = MultiIndex(
+        levels=[["foo", "bar"], ["fizz", "buzz"]],
+        codes=[[0, 0, 0, 1], [0, 0, 1, 1]],
+        names=["first", "second"],
+    )
+    idx_copy = idx.copy(deep=deep)
+    assert idx_copy.equals(idx)
+
+
+@pytest.mark.parametrize("deep", [True, False])
+@pytest.mark.parametrize(
+    "kwarg, value",
+    [
+        ("names", ["third", "fourth"]),
+    ],
+)
+def test_copy_method_kwargs(deep, kwarg, value):
+    # gh-12309: Check that the "name" argument as well other kwargs are honored
+    idx = MultiIndex(
+        levels=[["foo", "bar"], ["fizz", "buzz"]],
+        codes=[[0, 0, 0, 1], [0, 0, 1, 1]],
+        names=["first", "second"],
+    )
+    idx_copy = idx.copy(**{kwarg: value, "deep": deep})
+    assert getattr(idx_copy, kwarg) == value
+
+
+def test_copy_deep_false_retains_id():
+    # GH#47878
+    idx = MultiIndex(
+        levels=[["foo", "bar"], ["fizz", "buzz"]],
+        codes=[[0, 0, 0, 1], [0, 0, 1, 1]],
+        names=["first", "second"],
+    )
+
+    res = idx.copy(deep=False)
+    assert res._id is idx._id
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/object/__init__.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/object/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/object/__pycache__/__init__.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/object/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f5280c5aeeae5207a382a3c520d40fe828f40f4d
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/object/__pycache__/__init__.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/object/test_astype.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/object/test_astype.py
new file mode 100644
index 0000000000000000000000000000000000000000..9c1ef302c5b51cad92e2c0b1996d4d58d90e5ec6
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/object/test_astype.py
@@ -0,0 +1,33 @@
+import pytest
+
+from pandas import (
+    Index,
+    NaT,
+    Series,
+)
+import pandas._testing as tm
+
+
+def test_astype_str_from_bytes():
+    # https://github.com/pandas-dev/pandas/issues/38607
+    # GH#49658 pre-2.0 Index called .values.astype(str) here, which effectively
+    #  did a .decode() on the bytes object.  In 2.0 we go through
+    #  ensure_string_array which does f"{val}"
+    idx = Index(["あ", b"a"], dtype="object")
+    result = idx.astype(str)
+    expected = Index(["あ", "a"], dtype="object")
+    tm.assert_index_equal(result, expected)
+
+    # while we're here, check that Series.astype behaves the same
+    result = Series(idx).astype(str)
+    expected = Series(expected, dtype=object)
+    tm.assert_series_equal(result, expected)
+
+
+def test_astype_invalid_nas_to_tdt64_raises():
+    # GH#45722 don't cast np.datetime64 NaTs to timedelta64 NaT
+    idx = Index([NaT.asm8] * 2, dtype=object)
+
+    msg = r"Invalid type for timedelta scalar: <class 'numpy.datetime64'>"
+    with pytest.raises(TypeError, match=msg):
+        idx.astype("m8[ns]")
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/__pycache__/test_astype.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/__pycache__/test_astype.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d15fb47659874574c315d35e42cd3ecff7fcca42
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/__pycache__/test_astype.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/__pycache__/test_factorize.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/__pycache__/test_factorize.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..06fb923b342967f6ed6d2907a9f4565bdf1f54eb
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/__pycache__/test_factorize.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/__pycache__/test_fillna.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/__pycache__/test_fillna.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..39586e61451357659f72c03f6266a6cbbbce3356
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/__pycache__/test_fillna.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/__pycache__/test_repeat.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/__pycache__/test_repeat.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a6792915fead801036d3f771170b04610e879abc
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/__pycache__/test_repeat.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/__pycache__/test_shift.cpython-310.pyc b/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/__pycache__/test_shift.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d26c93ae48c9c2c255346014a19e1ee705727a66
Binary files /dev/null and b/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/__pycache__/test_shift.cpython-310.pyc differ
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/test_astype.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/test_astype.py
new file mode 100644
index 0000000000000000000000000000000000000000..311f2b5c9aa598de68543825d1bde9dc814b469e
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/test_astype.py
@@ -0,0 +1,176 @@
+from datetime import timedelta
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Index,
+    NaT,
+    Timedelta,
+    TimedeltaIndex,
+    timedelta_range,
+)
+import pandas._testing as tm
+from pandas.core.arrays import TimedeltaArray
+
+
+class TestTimedeltaIndex:
+    def test_astype_object(self):
+        idx = timedelta_range(start="1 days", periods=4, freq="D", name="idx")
+        expected_list = [
+            Timedelta("1 days"),
+            Timedelta("2 days"),
+            Timedelta("3 days"),
+            Timedelta("4 days"),
+        ]
+        result = idx.astype(object)
+        expected = Index(expected_list, dtype=object, name="idx")
+        tm.assert_index_equal(result, expected)
+        assert idx.tolist() == expected_list
+
+    def test_astype_object_with_nat(self):
+        idx = TimedeltaIndex(
+            [timedelta(days=1), timedelta(days=2), NaT, timedelta(days=4)], name="idx"
+        )
+        expected_list = [
+            Timedelta("1 days"),
+            Timedelta("2 days"),
+            NaT,
+            Timedelta("4 days"),
+        ]
+        result = idx.astype(object)
+        expected = Index(expected_list, dtype=object, name="idx")
+        tm.assert_index_equal(result, expected)
+        assert idx.tolist() == expected_list
+
+    def test_astype(self):
+        # GH 13149, GH 13209
+        idx = TimedeltaIndex([1e14, "NaT", NaT, np.nan], name="idx")
+
+        result = idx.astype(object)
+        expected = Index(
+            [Timedelta("1 days 03:46:40")] + [NaT] * 3, dtype=object, name="idx"
+        )
+        tm.assert_index_equal(result, expected)
+
+        result = idx.astype(np.int64)
+        expected = Index(
+            [100000000000000] + [-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)
+
+        rng = timedelta_range("1 days", periods=10)
+        result = rng.astype("i8")
+        tm.assert_index_equal(result, Index(rng.asi8))
+        tm.assert_numpy_array_equal(rng.asi8, result.values)
+
+    def test_astype_uint(self):
+        arr = timedelta_range("1h", periods=2)
+
+        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_timedelta64(self):
+        # GH 13149, GH 13209
+        idx = TimedeltaIndex([1e14, "NaT", NaT, np.nan])
+
+        msg = (
+            r"Cannot convert from timedelta64\[ns\] to timedelta64. "
+            "Supported resolutions are 's', 'ms', 'us', 'ns'"
+        )
+        with pytest.raises(ValueError, match=msg):
+            idx.astype("timedelta64")
+
+        result = idx.astype("timedelta64[ns]")
+        tm.assert_index_equal(result, idx)
+        assert result is not idx
+
+        result = idx.astype("timedelta64[ns]", copy=False)
+        tm.assert_index_equal(result, idx)
+        assert result is idx
+
+    def test_astype_to_td64d_raises(self, index_or_series):
+        # We don't support "D" reso
+        scalar = Timedelta(days=31)
+        td = index_or_series(
+            [scalar, scalar, scalar + timedelta(minutes=5, seconds=3), NaT],
+            dtype="m8[ns]",
+        )
+        msg = (
+            r"Cannot convert from timedelta64\[ns\] to timedelta64\[D\]. "
+            "Supported resolutions are 's', 'ms', 'us', 'ns'"
+        )
+        with pytest.raises(ValueError, match=msg):
+            td.astype("timedelta64[D]")
+
+    def test_astype_ms_to_s(self, index_or_series):
+        scalar = Timedelta(days=31)
+        td = index_or_series(
+            [scalar, scalar, scalar + timedelta(minutes=5, seconds=3), NaT],
+            dtype="m8[ns]",
+        )
+
+        exp_values = np.asarray(td).astype("m8[s]")
+        exp_tda = TimedeltaArray._simple_new(exp_values, dtype=exp_values.dtype)
+        expected = index_or_series(exp_tda)
+        assert expected.dtype == "m8[s]"
+        result = td.astype("timedelta64[s]")
+        tm.assert_equal(result, expected)
+
+    def test_astype_freq_conversion(self):
+        # pre-2.0 td64 astype converted to float64. now for supported units
+        #  (s, ms, us, ns) this converts to the requested dtype.
+        # This matches TDA and Series
+        tdi = timedelta_range("1 Day", periods=30)
+
+        res = tdi.astype("m8[s]")
+        exp_values = np.asarray(tdi).astype("m8[s]")
+        exp_tda = TimedeltaArray._simple_new(
+            exp_values, dtype=exp_values.dtype, freq=tdi.freq
+        )
+        expected = Index(exp_tda)
+        assert expected.dtype == "m8[s]"
+        tm.assert_index_equal(res, expected)
+
+        # check this matches Series and TimedeltaArray
+        res = tdi._data.astype("m8[s]")
+        tm.assert_equal(res, expected._values)
+
+        res = tdi.to_series().astype("m8[s]")
+        tm.assert_equal(res._values, expected._values._with_freq(None))
+
+    @pytest.mark.parametrize("dtype", [float, "datetime64", "datetime64[ns]"])
+    def test_astype_raises(self, dtype):
+        # GH 13149, GH 13209
+        idx = TimedeltaIndex([1e14, "NaT", NaT, np.nan])
+        msg = "Cannot cast TimedeltaIndex to dtype"
+        with pytest.raises(TypeError, match=msg):
+            idx.astype(dtype)
+
+    def test_astype_category(self):
+        obj = timedelta_range("1h", periods=2, freq="h")
+
+        result = obj.astype("category")
+        expected = pd.CategoricalIndex([Timedelta("1h"), Timedelta("2h")])
+        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 = timedelta_range("1h", periods=2)
+        result = obj.astype(bool)
+        expected = Index(np.array([True, True]))
+        tm.assert_index_equal(result, expected)
+
+        result = obj._data.astype(bool)
+        expected = np.array([True, True])
+        tm.assert_numpy_array_equal(result, expected)
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/test_fillna.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/test_fillna.py
new file mode 100644
index 0000000000000000000000000000000000000000..40aa95d0a46058d2dc3fc5208ca39328d96b23fb
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/test_fillna.py
@@ -0,0 +1,22 @@
+from pandas import (
+    Index,
+    NaT,
+    Timedelta,
+    TimedeltaIndex,
+)
+import pandas._testing as tm
+
+
+class TestFillNA:
+    def test_fillna_timedelta(self):
+        # GH#11343
+        idx = TimedeltaIndex(["1 day", NaT, "3 day"])
+
+        exp = TimedeltaIndex(["1 day", "2 day", "3 day"])
+        tm.assert_index_equal(idx.fillna(Timedelta("2 day")), exp)
+
+        exp = TimedeltaIndex(["1 day", "3 hour", "3 day"])
+        idx.fillna(Timedelta("3 hour"))
+
+        exp = Index([Timedelta("1 day"), "x", Timedelta("3 day")], dtype=object)
+        tm.assert_index_equal(idx.fillna("x"), exp)
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/test_insert.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/test_insert.py
new file mode 100644
index 0000000000000000000000000000000000000000..f8164102815f61ec61962524db2a2b3dd0ff6d55
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/methods/test_insert.py
@@ -0,0 +1,145 @@
+from datetime import timedelta
+
+import numpy as np
+import pytest
+
+from pandas._libs import lib
+
+import pandas as pd
+from pandas import (
+    Index,
+    Timedelta,
+    TimedeltaIndex,
+    timedelta_range,
+)
+import pandas._testing as tm
+
+
+class TestTimedeltaIndexInsert:
+    def test_insert(self):
+        idx = TimedeltaIndex(["4day", "1day", "2day"], name="idx")
+
+        result = idx.insert(2, timedelta(days=5))
+        exp = TimedeltaIndex(["4day", "1day", "5day", "2day"], name="idx")
+        tm.assert_index_equal(result, exp)
+
+        # insertion of non-datetime should coerce to object index
+        result = idx.insert(1, "inserted")
+        expected = Index(
+            [Timedelta("4day"), "inserted", Timedelta("1day"), Timedelta("2day")],
+            name="idx",
+        )
+        assert not isinstance(result, TimedeltaIndex)
+        tm.assert_index_equal(result, expected)
+        assert result.name == expected.name
+
+        idx = timedelta_range("1day 00:00:01", periods=3, freq="s", name="idx")
+
+        # preserve freq
+        expected_0 = TimedeltaIndex(
+            ["1day", "1day 00:00:01", "1day 00:00:02", "1day 00:00:03"],
+            name="idx",
+            freq="s",
+        )
+        expected_3 = TimedeltaIndex(
+            ["1day 00:00:01", "1day 00:00:02", "1day 00:00:03", "1day 00:00:04"],
+            name="idx",
+            freq="s",
+        )
+
+        # reset freq to None
+        expected_1_nofreq = TimedeltaIndex(
+            ["1day 00:00:01", "1day 00:00:01", "1day 00:00:02", "1day 00:00:03"],
+            name="idx",
+            freq=None,
+        )
+        expected_3_nofreq = TimedeltaIndex(
+            ["1day 00:00:01", "1day 00:00:02", "1day 00:00:03", "1day 00:00:05"],
+            name="idx",
+            freq=None,
+        )
+
+        cases = [
+            (0, Timedelta("1day"), expected_0),
+            (-3, Timedelta("1day"), expected_0),
+            (3, Timedelta("1day 00:00:04"), expected_3),
+            (1, Timedelta("1day 00:00:01"), expected_1_nofreq),
+            (3, Timedelta("1day 00:00:05"), expected_3_nofreq),
+        ]
+
+        for n, d, expected in cases:
+            result = idx.insert(n, d)
+            tm.assert_index_equal(result, expected)
+            assert result.name == expected.name
+            assert result.freq == expected.freq
+
+    @pytest.mark.parametrize(
+        "null", [None, np.nan, np.timedelta64("NaT"), pd.NaT, pd.NA]
+    )
+    def test_insert_nat(self, null):
+        # GH 18295 (test missing)
+        idx = timedelta_range("1day", "3day")
+        result = idx.insert(1, null)
+        expected = TimedeltaIndex(["1day", pd.NaT, "2day", "3day"])
+        tm.assert_index_equal(result, expected)
+
+    def test_insert_invalid_na(self):
+        idx = TimedeltaIndex(["4day", "1day", "2day"], name="idx")
+
+        item = np.datetime64("NaT")
+        result = idx.insert(0, item)
+
+        expected = Index([item] + list(idx), dtype=object, name="idx")
+        tm.assert_index_equal(result, expected)
+
+        # Also works if we pass a different dt64nat object
+        item2 = np.datetime64("NaT")
+        result = idx.insert(0, item2)
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "item", [0, np.int64(0), np.float64(0), np.array(0), np.datetime64(456, "us")]
+    )
+    def test_insert_mismatched_types_raises(self, item):
+        # GH#33703 dont cast these to td64
+        tdi = TimedeltaIndex(["4day", "1day", "2day"], name="idx")
+
+        result = tdi.insert(1, item)
+
+        expected = Index(
+            [tdi[0], lib.item_from_zerodim(item)] + list(tdi[1:]),
+            dtype=object,
+            name="idx",
+        )
+        tm.assert_index_equal(result, expected)
+
+    def test_insert_castable_str(self):
+        idx = timedelta_range("1day", "3day")
+
+        result = idx.insert(0, "1 Day")
+
+        expected = TimedeltaIndex([idx[0]] + list(idx))
+        tm.assert_index_equal(result, expected)
+
+    def test_insert_non_castable_str(self):
+        idx = timedelta_range("1day", "3day")
+
+        result = idx.insert(0, "foo")
+
+        expected = Index(["foo"] + list(idx), dtype=object)
+        tm.assert_index_equal(result, expected)
+
+    def test_insert_empty(self):
+        # Corner case inserting with length zero doesn't raise IndexError
+        # GH#33573 for freq preservation
+        idx = timedelta_range("1 Day", periods=3)
+        td = idx[0]
+
+        result = idx[:0].insert(0, td)
+        assert result.freq == "D"
+
+        with pytest.raises(IndexError, match="loc must be an integer between"):
+            result = idx[:0].insert(1, td)
+
+        with pytest.raises(IndexError, match="loc must be an integer between"):
+            result = idx[:0].insert(-1, td)
diff --git a/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/test_constructors.py b/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/test_constructors.py
new file mode 100644
index 0000000000000000000000000000000000000000..0510700bb64d7a626761a67d72ecfa6ecfba9ac4
--- /dev/null
+++ b/valley/lib/python3.10/site-packages/pandas/tests/indexes/timedeltas/test_constructors.py
@@ -0,0 +1,291 @@
+from datetime import timedelta
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Timedelta,
+    TimedeltaIndex,
+    timedelta_range,
+    to_timedelta,
+)
+import pandas._testing as tm
+from pandas.core.arrays.timedeltas import TimedeltaArray
+
+
+class TestTimedeltaIndex:
+    def test_closed_deprecated(self):
+        # GH#52628
+        msg = "The 'closed' keyword"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            TimedeltaIndex([], closed=True)
+
+    def test_array_of_dt64_nat_raises(self):
+        # GH#39462
+        nat = np.datetime64("NaT", "ns")
+        arr = np.array([nat], dtype=object)
+
+        msg = "Invalid type for timedelta scalar"
+        with pytest.raises(TypeError, match=msg):
+            TimedeltaIndex(arr)
+
+        with pytest.raises(TypeError, match=msg):
+            TimedeltaArray._from_sequence(arr, dtype="m8[ns]")
+
+        with pytest.raises(TypeError, match=msg):
+            to_timedelta(arr)
+
+    @pytest.mark.parametrize("unit", ["Y", "y", "M"])
+    def test_unit_m_y_raises(self, unit):
+        msg = "Units 'M', 'Y', and 'y' are no longer supported"
+        depr_msg = "The 'unit' keyword in TimedeltaIndex construction is deprecated"
+        with pytest.raises(ValueError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+                TimedeltaIndex([1, 3, 7], unit)
+
+    def test_int64_nocopy(self):
+        # GH#23539 check that a copy isn't made when we pass int64 data
+        #  and copy=False
+        arr = np.arange(10, dtype=np.int64)
+        tdi = TimedeltaIndex(arr, copy=False)
+        assert tdi._data._ndarray.base is arr
+
+    def test_infer_from_tdi(self):
+        # GH#23539
+        # fast-path for inferring a frequency if the passed data already
+        #  has one
+        tdi = timedelta_range("1 second", periods=10**7, freq="1s")
+
+        result = TimedeltaIndex(tdi, freq="infer")
+        assert result.freq == tdi.freq
+
+        # check that inferred_freq was not called by checking that the
+        #  value has not been cached
+        assert "inferred_freq" not in getattr(result, "_cache", {})
+
+    def test_infer_from_tdi_mismatch(self):
+        # GH#23539
+        # fast-path for invalidating a frequency if the passed data already
+        #  has one and it does not match the `freq` input
+        tdi = timedelta_range("1 second", periods=100, freq="1s")
+
+        depr_msg = "TimedeltaArray.__init__ is deprecated"
+        msg = (
+            "Inferred frequency .* from passed values does "
+            "not conform to passed frequency"
+        )
+        with pytest.raises(ValueError, match=msg):
+            TimedeltaIndex(tdi, freq="D")
+
+        with pytest.raises(ValueError, match=msg):
+            # GH#23789
+            with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+                TimedeltaArray(tdi, freq="D")
+
+        with pytest.raises(ValueError, match=msg):
+            TimedeltaIndex(tdi._data, freq="D")
+
+        with pytest.raises(ValueError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+                TimedeltaArray(tdi._data, freq="D")
+
+    def test_dt64_data_invalid(self):
+        # GH#23539
+        # passing tz-aware DatetimeIndex raises, naive or ndarray[datetime64]
+        #  raise as of GH#29794
+        dti = pd.date_range("2016-01-01", periods=3)
+
+        msg = "cannot be converted to timedelta64"
+        with pytest.raises(TypeError, match=msg):
+            TimedeltaIndex(dti.tz_localize("Europe/Brussels"))
+
+        with pytest.raises(TypeError, match=msg):
+            TimedeltaIndex(dti)
+
+        with pytest.raises(TypeError, match=msg):
+            TimedeltaIndex(np.asarray(dti))
+
+    def test_float64_ns_rounded(self):
+        # GH#23539 without specifying a unit, floats are regarded as nanos,
+        #  and fractional portions are truncated
+        tdi = TimedeltaIndex([2.3, 9.7])
+        expected = TimedeltaIndex([2, 9])
+        tm.assert_index_equal(tdi, expected)
+
+        # integral floats are non-lossy
+        tdi = TimedeltaIndex([2.0, 9.0])
+        expected = TimedeltaIndex([2, 9])
+        tm.assert_index_equal(tdi, expected)
+
+        # NaNs get converted to NaT
+        tdi = TimedeltaIndex([2.0, np.nan])
+        expected = TimedeltaIndex([Timedelta(nanoseconds=2), pd.NaT])
+        tm.assert_index_equal(tdi, expected)
+
+    def test_float64_unit_conversion(self):
+        # GH#23539
+        tdi = to_timedelta([1.5, 2.25], unit="D")
+        expected = TimedeltaIndex([Timedelta(days=1.5), Timedelta(days=2.25)])
+        tm.assert_index_equal(tdi, expected)
+
+    def test_construction_base_constructor(self):
+        arr = [Timedelta("1 days"), pd.NaT, Timedelta("3 days")]
+        tm.assert_index_equal(pd.Index(arr), TimedeltaIndex(arr))
+        tm.assert_index_equal(pd.Index(np.array(arr)), TimedeltaIndex(np.array(arr)))
+
+        arr = [np.nan, pd.NaT, Timedelta("1 days")]
+        tm.assert_index_equal(pd.Index(arr), TimedeltaIndex(arr))
+        tm.assert_index_equal(pd.Index(np.array(arr)), TimedeltaIndex(np.array(arr)))
+
+    @pytest.mark.filterwarnings(
+        "ignore:The 'unit' keyword in TimedeltaIndex construction:FutureWarning"
+    )
+    def test_constructor(self):
+        expected = TimedeltaIndex(
+            [
+                "1 days",
+                "1 days 00:00:05",
+                "2 days",
+                "2 days 00:00:02",
+                "0 days 00:00:03",
+            ]
+        )
+        result = TimedeltaIndex(
+            [
+                "1 days",
+                "1 days, 00:00:05",
+                np.timedelta64(2, "D"),
+                timedelta(days=2, seconds=2),
+                pd.offsets.Second(3),
+            ]
+        )
+        tm.assert_index_equal(result, expected)
+
+        expected = TimedeltaIndex(
+            ["0 days 00:00:00", "0 days 00:00:01", "0 days 00:00:02"]
+        )
+        result = TimedeltaIndex(range(3), unit="s")
+        tm.assert_index_equal(result, expected)
+        expected = TimedeltaIndex(
+            ["0 days 00:00:00", "0 days 00:00:05", "0 days 00:00:09"]
+        )
+        result = TimedeltaIndex([0, 5, 9], unit="s")
+        tm.assert_index_equal(result, expected)
+        expected = TimedeltaIndex(
+            ["0 days 00:00:00.400", "0 days 00:00:00.450", "0 days 00:00:01.200"]
+        )
+        result = TimedeltaIndex([400, 450, 1200], unit="ms")
+        tm.assert_index_equal(result, expected)
+
+    def test_constructor_iso(self):
+        # GH #21877
+        expected = timedelta_range("1s", periods=9, freq="s")
+        durations = [f"P0DT0H0M{i}S" for i in range(1, 10)]
+        result = to_timedelta(durations)
+        tm.assert_index_equal(result, expected)
+
+    def test_timedelta_range_fractional_period(self):
+        msg = "Non-integer 'periods' in pd.date_range, pd.timedelta_range"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rng = timedelta_range("1 days", periods=10.5)
+        exp = timedelta_range("1 days", periods=10)
+        tm.assert_index_equal(rng, exp)
+
+    def test_constructor_coverage(self):
+        msg = "periods must be a number, got foo"
+        with pytest.raises(TypeError, match=msg):
+            timedelta_range(start="1 days", periods="foo", freq="D")
+
+        msg = (
+            r"TimedeltaIndex\(\.\.\.\) must be called with a collection of some kind, "
+            "'1 days' was passed"
+        )
+        with pytest.raises(TypeError, match=msg):
+            TimedeltaIndex("1 days")
+
+        # generator expression
+        gen = (timedelta(i) for i in range(10))
+        result = TimedeltaIndex(gen)
+        expected = TimedeltaIndex([timedelta(i) for i in range(10)])
+        tm.assert_index_equal(result, expected)
+
+        # NumPy string array
+        strings = np.array(["1 days", "2 days", "3 days"])
+        result = TimedeltaIndex(strings)
+        expected = to_timedelta([1, 2, 3], unit="d")
+        tm.assert_index_equal(result, expected)
+
+        from_ints = TimedeltaIndex(expected.asi8)
+        tm.assert_index_equal(from_ints, expected)
+
+        # non-conforming freq
+        msg = (
+            "Inferred frequency None from passed values does not conform to "
+            "passed frequency D"
+        )
+        with pytest.raises(ValueError, match=msg):
+            TimedeltaIndex(["1 days", "2 days", "4 days"], freq="D")
+
+        msg = (
+            "Of the four parameters: start, end, periods, and freq, exactly "
+            "three must be specified"
+        )
+        with pytest.raises(ValueError, match=msg):
+            timedelta_range(periods=10, freq="D")
+
+    def test_constructor_name(self):
+        idx = timedelta_range(start="1 days", periods=1, freq="D", name="TEST")
+        assert idx.name == "TEST"
+
+        # GH10025
+        idx2 = TimedeltaIndex(idx, name="something else")
+        assert idx2.name == "something else"
+
+    def test_constructor_no_precision_raises(self):
+        # GH-24753, GH-24739
+
+        msg = "with no precision is not allowed"
+        with pytest.raises(ValueError, match=msg):
+            TimedeltaIndex(["2000"], dtype="timedelta64")
+
+        msg = "The 'timedelta64' dtype has no unit. Please pass in"
+        with pytest.raises(ValueError, match=msg):
+            pd.Index(["2000"], dtype="timedelta64")
+
+    def test_constructor_wrong_precision_raises(self):
+        msg = "Supported timedelta64 resolutions are 's', 'ms', 'us', 'ns'"
+        with pytest.raises(ValueError, match=msg):
+            TimedeltaIndex(["2000"], dtype="timedelta64[D]")
+
+        # "timedelta64[us]" was unsupported pre-2.0, but now this works.
+        tdi = TimedeltaIndex(["2000"], dtype="timedelta64[us]")
+        assert tdi.dtype == "m8[us]"
+
+    def test_explicit_none_freq(self):
+        # Explicitly passing freq=None is respected
+        tdi = timedelta_range(1, periods=5)
+        assert tdi.freq is not None
+
+        result = TimedeltaIndex(tdi, freq=None)
+        assert result.freq is None
+
+        result = TimedeltaIndex(tdi._data, freq=None)
+        assert result.freq is None
+
+        msg = "TimedeltaArray.__init__ is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            tda = TimedeltaArray(tdi, freq=None)
+        assert tda.freq is None
+
+    def test_from_categorical(self):
+        tdi = timedelta_range(1, periods=5)
+
+        cat = pd.Categorical(tdi)
+
+        result = TimedeltaIndex(cat)
+        tm.assert_index_equal(result, tdi)
+
+        ci = pd.CategoricalIndex(tdi)
+        result = TimedeltaIndex(ci)
+        tm.assert_index_equal(result, tdi)