Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/pandas/tests/indexing/interval/test_interval.py

@@ -0,0 +1,227 @@
+import numpy as np
+import pytest
+
+from pandas._libs import index as libindex
+from pandas.compat import IS64
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    IntervalIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestIntervalIndex:
+    @pytest.fixture
+    def series_with_interval_index(self):
+        return Series(np.arange(5), IntervalIndex.from_breaks(np.arange(6)))
+
+    def test_getitem_with_scalar(self, series_with_interval_index, indexer_sl):
+        ser = series_with_interval_index.copy()
+
+        expected = ser.iloc[:3]
+        tm.assert_series_equal(expected, indexer_sl(ser)[:3])
+        tm.assert_series_equal(expected, indexer_sl(ser)[:2.5])
+        tm.assert_series_equal(expected, indexer_sl(ser)[0.1:2.5])
+        if indexer_sl is tm.loc:
+            tm.assert_series_equal(expected, ser.loc[-1:3])
+
+        expected = ser.iloc[1:4]
+        tm.assert_series_equal(expected, indexer_sl(ser)[[1.5, 2.5, 3.5]])
+        tm.assert_series_equal(expected, indexer_sl(ser)[[2, 3, 4]])
+        tm.assert_series_equal(expected, indexer_sl(ser)[[1.5, 3, 4]])
+
+        expected = ser.iloc[2:5]
+        tm.assert_series_equal(expected, indexer_sl(ser)[ser >= 2])
+
+    @pytest.mark.parametrize("direction", ["increasing", "decreasing"])
+    def test_getitem_nonoverlapping_monotonic(self, direction, closed, indexer_sl):
+        tpls = [(0, 1), (2, 3), (4, 5)]
+        if direction == "decreasing":
+            tpls = tpls[::-1]
+
+        idx = IntervalIndex.from_tuples(tpls, closed=closed)
+        ser = Series(list("abc"), idx)
+
+        for key, expected in zip(idx.left, ser):
+            if idx.closed_left:
+                assert indexer_sl(ser)[key] == expected
+            else:
+                with pytest.raises(KeyError, match=str(key)):
+                    indexer_sl(ser)[key]
+
+        for key, expected in zip(idx.right, ser):
+            if idx.closed_right:
+                assert indexer_sl(ser)[key] == expected
+            else:
+                with pytest.raises(KeyError, match=str(key)):
+                    indexer_sl(ser)[key]
+
+        for key, expected in zip(idx.mid, ser):
+            assert indexer_sl(ser)[key] == expected
+
+    def test_getitem_non_matching(self, series_with_interval_index, indexer_sl):
+        ser = series_with_interval_index.copy()
+
+        # this is a departure from our current
+        # indexing scheme, but simpler
+        with pytest.raises(KeyError, match=r"\[-1\] not in index"):
+            indexer_sl(ser)[[-1, 3, 4, 5]]
+
+        with pytest.raises(KeyError, match=r"\[-1\] not in index"):
+            indexer_sl(ser)[[-1, 3]]
+
+    def test_loc_getitem_large_series(self, monkeypatch):
+        size_cutoff = 20
+        with monkeypatch.context():
+            monkeypatch.setattr(libindex, "_SIZE_CUTOFF", size_cutoff)
+            ser = Series(
+                np.arange(size_cutoff),
+                index=IntervalIndex.from_breaks(np.arange(size_cutoff + 1)),
+            )
+
+            result1 = ser.loc[:8]
+            result2 = ser.loc[0:8]
+            result3 = ser.loc[0:8:1]
+        tm.assert_series_equal(result1, result2)
+        tm.assert_series_equal(result1, result3)
+
+    def test_loc_getitem_frame(self):
+        # CategoricalIndex with IntervalIndex categories
+        df = DataFrame({"A": range(10)})
+        ser = pd.cut(df.A, 5)
+        df["B"] = ser
+        df = df.set_index("B")
+
+        result = df.loc[4]
+        expected = df.iloc[4:6]
+        tm.assert_frame_equal(result, expected)
+
+        with pytest.raises(KeyError, match="10"):
+            df.loc[10]
+
+        # single list-like
+        result = df.loc[[4]]
+        expected = df.iloc[4:6]
+        tm.assert_frame_equal(result, expected)
+
+        # non-unique
+        result = df.loc[[4, 5]]
+        expected = df.take([4, 5, 4, 5])
+        tm.assert_frame_equal(result, expected)
+
+        msg = (
+            r"None of \[Index\(\[10\], dtype='object', name='B'\)\] "
+            r"are in the \[index\]"
+        )
+        with pytest.raises(KeyError, match=msg):
+            df.loc[[10]]
+
+        # partial missing
+        with pytest.raises(KeyError, match=r"\[10\] not in index"):
+            df.loc[[10, 4]]
+
+    def test_getitem_interval_with_nans(self, frame_or_series, indexer_sl):
+        # GH#41831
+
+        index = IntervalIndex([np.nan, np.nan])
+        key = index[:-1]
+
+        obj = frame_or_series(range(2), index=index)
+        if frame_or_series is DataFrame and indexer_sl is tm.setitem:
+            obj = obj.T
+
+        result = indexer_sl(obj)[key]
+        expected = obj
+
+        tm.assert_equal(result, expected)
+
+    def test_setitem_interval_with_slice(self):
+        # GH#54722
+        ii = IntervalIndex.from_breaks(range(4, 15))
+        ser = Series(range(10), index=ii)
+
+        orig = ser.copy()
+
+        # This should be a no-op (used to raise)
+        ser.loc[1:3] = 20
+        tm.assert_series_equal(ser, orig)
+
+        ser.loc[6:8] = 19
+        orig.iloc[1:4] = 19
+        tm.assert_series_equal(ser, orig)
+
+        ser2 = Series(range(5), index=ii[::2])
+        orig2 = ser2.copy()
+
+        # this used to raise
+        ser2.loc[6:8] = 22  # <- raises on main, sets on branch
+        orig2.iloc[1] = 22
+        tm.assert_series_equal(ser2, orig2)
+
+        ser2.loc[5:7] = 21
+        orig2.iloc[:2] = 21
+        tm.assert_series_equal(ser2, orig2)
+
+
+class TestIntervalIndexInsideMultiIndex:
+    def test_mi_intervalindex_slicing_with_scalar(self):
+        # GH#27456
+        ii = IntervalIndex.from_arrays(
+            [0, 1, 10, 11, 0, 1, 10, 11], [1, 2, 11, 12, 1, 2, 11, 12], name="MP"
+        )
+        idx = pd.MultiIndex.from_arrays(
+            [
+                pd.Index(["FC", "FC", "FC", "FC", "OWNER", "OWNER", "OWNER", "OWNER"]),
+                pd.Index(
+                    ["RID1", "RID1", "RID2", "RID2", "RID1", "RID1", "RID2", "RID2"]
+                ),
+                ii,
+            ]
+        )
+
+        idx.names = ["Item", "RID", "MP"]
+        df = DataFrame({"value": [1, 2, 3, 4, 5, 6, 7, 8]})
+        df.index = idx
+
+        query_df = DataFrame(
+            {
+                "Item": ["FC", "OWNER", "FC", "OWNER", "OWNER"],
+                "RID": ["RID1", "RID1", "RID1", "RID2", "RID2"],
+                "MP": [0.2, 1.5, 1.6, 11.1, 10.9],
+            }
+        )
+
+        query_df = query_df.sort_index()
+
+        idx = pd.MultiIndex.from_arrays([query_df.Item, query_df.RID, query_df.MP])
+        query_df.index = idx
+        result = df.value.loc[query_df.index]
+
+        # the IntervalIndex level is indexed with floats, which map to
+        #  the intervals containing them.  Matching the behavior we would get
+        #  with _only_ an IntervalIndex, we get an IntervalIndex level back.
+        sliced_level = ii.take([0, 1, 1, 3, 2])
+        expected_index = pd.MultiIndex.from_arrays(
+            [idx.get_level_values(0), idx.get_level_values(1), sliced_level]
+        )
+        expected = Series([1, 6, 2, 8, 7], index=expected_index, name="value")
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.xfail(not IS64, reason="GH 23440")
+    @pytest.mark.parametrize(
+        "base",
+        [101, 1010],
+    )
+    def test_reindex_behavior_with_interval_index(self, base):
+        # GH 51826
+
+        ser = Series(
+            range(base),
+            index=IntervalIndex.from_arrays(range(base), range(1, base + 1)),
+        )
+        expected_result = Series([np.nan, 0], index=[np.nan, 1.0], dtype=float)
+        result = ser.reindex(index=[np.nan, 1.0])
+        tm.assert_series_equal(result, expected_result)

env-llmeval/lib/python3.10/site-packages/pandas/tests/indexing/interval/test_interval_new.py

@@ -0,0 +1,232 @@
+import re
+
+import numpy as np
+import pytest
+
+from pandas.compat import IS64
+
+from pandas import (
+    Index,
+    Interval,
+    IntervalIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestIntervalIndex:
+    @pytest.fixture
+    def series_with_interval_index(self):
+        return Series(np.arange(5), IntervalIndex.from_breaks(np.arange(6)))
+
+    def test_loc_with_interval(self, series_with_interval_index, indexer_sl):
+        # loc with single label / list of labels:
+        #   - Intervals: only exact matches
+        #   - scalars: those that contain it
+
+        ser = series_with_interval_index.copy()
+
+        expected = 0
+        result = indexer_sl(ser)[Interval(0, 1)]
+        assert result == expected
+
+        expected = ser.iloc[3:5]
+        result = indexer_sl(ser)[[Interval(3, 4), Interval(4, 5)]]
+        tm.assert_series_equal(expected, result)
+
+        # missing or not exact
+        with pytest.raises(KeyError, match=re.escape("Interval(3, 5, closed='left')")):
+            indexer_sl(ser)[Interval(3, 5, closed="left")]
+
+        with pytest.raises(KeyError, match=re.escape("Interval(3, 5, closed='right')")):
+            indexer_sl(ser)[Interval(3, 5)]
+
+        with pytest.raises(
+            KeyError, match=re.escape("Interval(-2, 0, closed='right')")
+        ):
+            indexer_sl(ser)[Interval(-2, 0)]
+
+        with pytest.raises(KeyError, match=re.escape("Interval(5, 6, closed='right')")):
+            indexer_sl(ser)[Interval(5, 6)]
+
+    def test_loc_with_scalar(self, series_with_interval_index, indexer_sl):
+        # loc with single label / list of labels:
+        #   - Intervals: only exact matches
+        #   - scalars: those that contain it
+
+        ser = series_with_interval_index.copy()
+
+        assert indexer_sl(ser)[1] == 0
+        assert indexer_sl(ser)[1.5] == 1
+        assert indexer_sl(ser)[2] == 1
+
+        expected = ser.iloc[1:4]
+        tm.assert_series_equal(expected, indexer_sl(ser)[[1.5, 2.5, 3.5]])
+        tm.assert_series_equal(expected, indexer_sl(ser)[[2, 3, 4]])
+        tm.assert_series_equal(expected, indexer_sl(ser)[[1.5, 3, 4]])
+
+        expected = ser.iloc[[1, 1, 2, 1]]
+        tm.assert_series_equal(expected, indexer_sl(ser)[[1.5, 2, 2.5, 1.5]])
+
+        expected = ser.iloc[2:5]
+        tm.assert_series_equal(expected, indexer_sl(ser)[ser >= 2])
+
+    def test_loc_with_slices(self, series_with_interval_index, indexer_sl):
+        # loc with slices:
+        #   - Interval objects: only works with exact matches
+        #   - scalars: only works for non-overlapping, monotonic intervals,
+        #     and start/stop select location based on the interval that
+        #     contains them:
+        #    (slice_loc(start, stop) == (idx.get_loc(start), idx.get_loc(stop))
+
+        ser = series_with_interval_index.copy()
+
+        # slice of interval
+
+        expected = ser.iloc[:3]
+        result = indexer_sl(ser)[Interval(0, 1) : Interval(2, 3)]
+        tm.assert_series_equal(expected, result)
+
+        expected = ser.iloc[3:]
+        result = indexer_sl(ser)[Interval(3, 4) :]
+        tm.assert_series_equal(expected, result)
+
+        msg = "Interval objects are not currently supported"
+        with pytest.raises(NotImplementedError, match=msg):
+            indexer_sl(ser)[Interval(3, 6) :]
+
+        with pytest.raises(NotImplementedError, match=msg):
+            indexer_sl(ser)[Interval(3, 4, closed="left") :]
+
+    def test_slice_step_ne1(self, series_with_interval_index):
+        # GH#31658 slice of scalar with step != 1
+        ser = series_with_interval_index.copy()
+        expected = ser.iloc[0:4:2]
+
+        result = ser[0:4:2]
+        tm.assert_series_equal(result, expected)
+
+        result2 = ser[0:4][::2]
+        tm.assert_series_equal(result2, expected)
+
+    def test_slice_float_start_stop(self, series_with_interval_index):
+        # GH#31658 slicing with integers is positional, with floats is not
+        #  supported
+        ser = series_with_interval_index.copy()
+
+        msg = "label-based slicing with step!=1 is not supported for IntervalIndex"
+        with pytest.raises(ValueError, match=msg):
+            ser[1.5:9.5:2]
+
+    def test_slice_interval_step(self, series_with_interval_index):
+        # GH#31658 allows for integer step!=1, not Interval step
+        ser = series_with_interval_index.copy()
+        msg = "label-based slicing with step!=1 is not supported for IntervalIndex"
+        with pytest.raises(ValueError, match=msg):
+            ser[0 : 4 : Interval(0, 1)]
+
+    def test_loc_with_overlap(self, indexer_sl):
+        idx = IntervalIndex.from_tuples([(1, 5), (3, 7)])
+        ser = Series(range(len(idx)), index=idx)
+
+        # scalar
+        expected = ser
+        result = indexer_sl(ser)[4]
+        tm.assert_series_equal(expected, result)
+
+        result = indexer_sl(ser)[[4]]
+        tm.assert_series_equal(expected, result)
+
+        # interval
+        expected = 0
+        result = indexer_sl(ser)[Interval(1, 5)]
+        assert expected == result
+
+        expected = ser
+        result = indexer_sl(ser)[[Interval(1, 5), Interval(3, 7)]]
+        tm.assert_series_equal(expected, result)
+
+        with pytest.raises(KeyError, match=re.escape("Interval(3, 5, closed='right')")):
+            indexer_sl(ser)[Interval(3, 5)]
+
+        msg = (
+            r"None of \[IntervalIndex\(\[\(3, 5\]\], "
+            r"dtype='interval\[int64, right\]'\)\] are in the \[index\]"
+        )
+        with pytest.raises(KeyError, match=msg):
+            indexer_sl(ser)[[Interval(3, 5)]]
+
+        # slices with interval (only exact matches)
+        expected = ser
+        result = indexer_sl(ser)[Interval(1, 5) : Interval(3, 7)]
+        tm.assert_series_equal(expected, result)
+
+        msg = (
+            "'can only get slices from an IntervalIndex if bounds are "
+            "non-overlapping and all monotonic increasing or decreasing'"
+        )
+        with pytest.raises(KeyError, match=msg):
+            indexer_sl(ser)[Interval(1, 6) : Interval(3, 8)]
+
+        if indexer_sl is tm.loc:
+            # slices with scalar raise for overlapping intervals
+            # TODO KeyError is the appropriate error?
+            with pytest.raises(KeyError, match=msg):
+                ser.loc[1:4]
+
+    def test_non_unique(self, indexer_sl):
+        idx = IntervalIndex.from_tuples([(1, 3), (3, 7)])
+        ser = Series(range(len(idx)), index=idx)
+
+        result = indexer_sl(ser)[Interval(1, 3)]
+        assert result == 0
+
+        result = indexer_sl(ser)[[Interval(1, 3)]]
+        expected = ser.iloc[0:1]
+        tm.assert_series_equal(expected, result)
+
+    def test_non_unique_moar(self, indexer_sl):
+        idx = IntervalIndex.from_tuples([(1, 3), (1, 3), (3, 7)])
+        ser = Series(range(len(idx)), index=idx)
+
+        expected = ser.iloc[[0, 1]]
+        result = indexer_sl(ser)[Interval(1, 3)]
+        tm.assert_series_equal(expected, result)
+
+        expected = ser
+        result = indexer_sl(ser)[Interval(1, 3) :]
+        tm.assert_series_equal(expected, result)
+
+        expected = ser.iloc[[0, 1]]
+        result = indexer_sl(ser)[[Interval(1, 3)]]
+        tm.assert_series_equal(expected, result)
+
+    def test_loc_getitem_missing_key_error_message(
+        self, frame_or_series, series_with_interval_index
+    ):
+        # GH#27365
+        ser = series_with_interval_index.copy()
+        obj = frame_or_series(ser)
+        with pytest.raises(KeyError, match=r"\[6\]"):
+            obj.loc[[4, 5, 6]]
+
+
+@pytest.mark.xfail(not IS64, reason="GH 23440")
+@pytest.mark.parametrize(
+    "intervals",
+    [
+        ([Interval(-np.inf, 0.0), Interval(0.0, 1.0)]),
+        ([Interval(-np.inf, -2.0), Interval(-2.0, -1.0)]),
+        ([Interval(-1.0, 0.0), Interval(0.0, np.inf)]),
+        ([Interval(1.0, 2.0), Interval(2.0, np.inf)]),
+    ],
+)
+def test_repeating_interval_index_with_infs(intervals):
+    # GH 46658
+
+    interval_index = Index(intervals * 51)
+
+    expected = np.arange(1, 102, 2, dtype=np.intp)
+    result = interval_index.get_indexer_for([intervals[1]])
+
+    tm.assert_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/indexing/multiindex/test_chaining_and_caching.py

@@ -0,0 +1,87 @@
+import numpy as np
+import pytest
+
+from pandas._libs import index as libindex
+from pandas.errors import SettingWithCopyError
+import pandas.util._test_decorators as td
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+def test_detect_chained_assignment(using_copy_on_write, warn_copy_on_write):
+    # Inplace ops, originally from:
+    # https://stackoverflow.com/questions/20508968/series-fillna-in-a-multiindex-dataframe-does-not-fill-is-this-a-bug
+    a = [12, 23]
+    b = [123, None]
+    c = [1234, 2345]
+    d = [12345, 23456]
+    tuples = [("eyes", "left"), ("eyes", "right"), ("ears", "left"), ("ears", "right")]
+    events = {
+        ("eyes", "left"): a,
+        ("eyes", "right"): b,
+        ("ears", "left"): c,
+        ("ears", "right"): d,
+    }
+    multiind = MultiIndex.from_tuples(tuples, names=["part", "side"])
+    zed = DataFrame(events, index=["a", "b"], columns=multiind)
+
+    if using_copy_on_write:
+        with tm.raises_chained_assignment_error():
+            zed["eyes"]["right"].fillna(value=555, inplace=True)
+    elif warn_copy_on_write:
+        with tm.assert_produces_warning(None):
+            zed["eyes"]["right"].fillna(value=555, inplace=True)
+    else:
+        msg = "A value is trying to be set on a copy of a slice from a DataFrame"
+        with pytest.raises(SettingWithCopyError, match=msg):
+            with tm.assert_produces_warning(None):
+                zed["eyes"]["right"].fillna(value=555, inplace=True)
+
+
+@td.skip_array_manager_invalid_test  # with ArrayManager df.loc[0] is not a view
+def test_cache_updating(using_copy_on_write, warn_copy_on_write):
+    # 5216
+    # make sure that we don't try to set a dead cache
+    a = np.random.default_rng(2).random((10, 3))
+    df = DataFrame(a, columns=["x", "y", "z"])
+    df_original = df.copy()
+    tuples = [(i, j) for i in range(5) for j in range(2)]
+    index = MultiIndex.from_tuples(tuples)
+    df.index = index
+
+    # setting via chained assignment
+    # but actually works, since everything is a view
+
+    with tm.raises_chained_assignment_error():
+        df.loc[0]["z"].iloc[0] = 1.0
+
+    if using_copy_on_write:
+        assert df.loc[(0, 0), "z"] == df_original.loc[0, "z"]
+    else:
+        result = df.loc[(0, 0), "z"]
+        assert result == 1
+
+    # correct setting
+    df.loc[(0, 0), "z"] = 2
+    result = df.loc[(0, 0), "z"]
+    assert result == 2
+
+
+def test_indexer_caching(monkeypatch):
+    # GH5727
+    # make sure that indexers are in the _internal_names_set
+    size_cutoff = 20
+    with monkeypatch.context():
+        monkeypatch.setattr(libindex, "_SIZE_CUTOFF", size_cutoff)
+        index = MultiIndex.from_arrays([np.arange(size_cutoff), np.arange(size_cutoff)])
+        s = Series(np.zeros(size_cutoff), index=index)
+
+        # setitem
+        s[s == 0] = 1
+    expected = Series(np.ones(size_cutoff), index=index)
+    tm.assert_series_equal(s, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/indexing/multiindex/test_datetime.py

@@ -0,0 +1,50 @@
+from datetime import datetime
+
+import numpy as np
+
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    Period,
+    Series,
+    period_range,
+    to_datetime,
+)
+import pandas._testing as tm
+
+
+def test_multiindex_period_datetime():
+    # GH4861, using datetime in period of multiindex raises exception
+
+    idx1 = Index(["a", "a", "a", "b", "b"])
+    idx2 = period_range("2012-01", periods=len(idx1), freq="M")
+    s = Series(np.random.default_rng(2).standard_normal(len(idx1)), [idx1, idx2])
+
+    # try Period as index
+    expected = s.iloc[0]
+    result = s.loc["a", Period("2012-01")]
+    assert result == expected
+
+    # try datetime as index
+    result = s.loc["a", datetime(2012, 1, 1)]
+    assert result == expected
+
+
+def test_multiindex_datetime_columns():
+    # GH35015, using datetime as column indices raises exception
+
+    mi = MultiIndex.from_tuples(
+        [(to_datetime("02/29/2020"), to_datetime("03/01/2020"))], names=["a", "b"]
+    )
+
+    df = DataFrame([], columns=mi)
+
+    expected_df = DataFrame(
+        [],
+        columns=MultiIndex.from_arrays(
+            [[to_datetime("02/29/2020")], [to_datetime("03/01/2020")]], names=["a", "b"]
+        ),
+    )
+
+    tm.assert_frame_equal(df, expected_df)

env-llmeval/lib/python3.10/site-packages/pandas/tests/indexing/multiindex/test_getitem.py

@@ -0,0 +1,410 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+from pandas.core.indexing import IndexingError
+
+# ----------------------------------------------------------------------------
+# test indexing of Series with multi-level Index
+# ----------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "access_method",
+    [lambda s, x: s[:, x], lambda s, x: s.loc[:, x], lambda s, x: s.xs(x, level=1)],
+)
+@pytest.mark.parametrize(
+    "level1_value, expected",
+    [(0, Series([1], index=[0])), (1, Series([2, 3], index=[1, 2]))],
+)
+def test_series_getitem_multiindex(access_method, level1_value, expected):
+    # GH 6018
+    # series regression getitem with a multi-index
+
+    mi = MultiIndex.from_tuples([(0, 0), (1, 1), (2, 1)], names=["A", "B"])
+    ser = Series([1, 2, 3], index=mi)
+    expected.index.name = "A"
+
+    result = access_method(ser, level1_value)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("level0_value", ["D", "A"])
+def test_series_getitem_duplicates_multiindex(level0_value):
+    # GH 5725 the 'A' happens to be a valid Timestamp so the doesn't raise
+    # the appropriate error, only in PY3 of course!
+
+    index = MultiIndex(
+        levels=[[level0_value, "B", "C"], [0, 26, 27, 37, 57, 67, 75, 82]],
+        codes=[[0, 0, 0, 1, 2, 2, 2, 2, 2, 2], [1, 3, 4, 6, 0, 2, 2, 3, 5, 7]],
+        names=["tag", "day"],
+    )
+    arr = np.random.default_rng(2).standard_normal((len(index), 1))
+    df = DataFrame(arr, index=index, columns=["val"])
+
+    # confirm indexing on missing value raises KeyError
+    if level0_value != "A":
+        with pytest.raises(KeyError, match=r"^'A'$"):
+            df.val["A"]
+
+    with pytest.raises(KeyError, match=r"^'X'$"):
+        df.val["X"]
+
+    result = df.val[level0_value]
+    expected = Series(
+        arr.ravel()[0:3], name="val", index=Index([26, 37, 57], name="day")
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_series_getitem(multiindex_year_month_day_dataframe_random_data, indexer_sl):
+    s = multiindex_year_month_day_dataframe_random_data["A"]
+    expected = s.reindex(s.index[42:65])
+    expected.index = expected.index.droplevel(0).droplevel(0)
+
+    result = indexer_sl(s)[2000, 3]
+    tm.assert_series_equal(result, expected)
+
+
+def test_series_getitem_returns_scalar(
+    multiindex_year_month_day_dataframe_random_data, indexer_sl
+):
+    s = multiindex_year_month_day_dataframe_random_data["A"]
+    expected = s.iloc[49]
+
+    result = indexer_sl(s)[2000, 3, 10]
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "indexer,expected_error,expected_error_msg",
+    [
+        (lambda s: s.__getitem__((2000, 3, 4)), KeyError, r"^\(2000, 3, 4\)$"),
+        (lambda s: s[(2000, 3, 4)], KeyError, r"^\(2000, 3, 4\)$"),
+        (lambda s: s.loc[(2000, 3, 4)], KeyError, r"^\(2000, 3, 4\)$"),
+        (lambda s: s.loc[(2000, 3, 4, 5)], IndexingError, "Too many indexers"),
+        (lambda s: s.__getitem__(len(s)), KeyError, ""),  # match should include len(s)
+        (lambda s: s[len(s)], KeyError, ""),  # match should include len(s)
+        (
+            lambda s: s.iloc[len(s)],
+            IndexError,
+            "single positional indexer is out-of-bounds",
+        ),
+    ],
+)
+def test_series_getitem_indexing_errors(
+    multiindex_year_month_day_dataframe_random_data,
+    indexer,
+    expected_error,
+    expected_error_msg,
+):
+    s = multiindex_year_month_day_dataframe_random_data["A"]
+    with pytest.raises(expected_error, match=expected_error_msg):
+        indexer(s)
+
+
+def test_series_getitem_corner_generator(
+    multiindex_year_month_day_dataframe_random_data,
+):
+    s = multiindex_year_month_day_dataframe_random_data["A"]
+    result = s[(x > 0 for x in s)]
+    expected = s[s > 0]
+    tm.assert_series_equal(result, expected)
+
+
+# ----------------------------------------------------------------------------
+# test indexing of DataFrame with multi-level Index
+# ----------------------------------------------------------------------------
+
+
+def test_getitem_simple(multiindex_dataframe_random_data):
+    df = multiindex_dataframe_random_data.T
+    expected = df.values[:, 0]
+    result = df["foo", "one"].values
+    tm.assert_almost_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "indexer,expected_error_msg",
+    [
+        (lambda df: df[("foo", "four")], r"^\('foo', 'four'\)$"),
+        (lambda df: df["foobar"], r"^'foobar'$"),
+    ],
+)
+def test_frame_getitem_simple_key_error(
+    multiindex_dataframe_random_data, indexer, expected_error_msg
+):
+    df = multiindex_dataframe_random_data.T
+    with pytest.raises(KeyError, match=expected_error_msg):
+        indexer(df)
+
+
+def test_tuple_string_column_names():
+    # GH#50372
+    mi = MultiIndex.from_tuples([("a", "aa"), ("a", "ab"), ("b", "ba"), ("b", "bb")])
+    df = DataFrame([range(4), range(1, 5), range(2, 6)], columns=mi)
+    df["single_index"] = 0
+
+    df_flat = df.copy()
+    df_flat.columns = df_flat.columns.to_flat_index()
+    df_flat["new_single_index"] = 0
+
+    result = df_flat[[("a", "aa"), "new_single_index"]]
+    expected = DataFrame(
+        [[0, 0], [1, 0], [2, 0]], columns=Index([("a", "aa"), "new_single_index"])
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_frame_getitem_multicolumn_empty_level():
+    df = DataFrame({"a": ["1", "2", "3"], "b": ["2", "3", "4"]})
+    df.columns = [
+        ["level1 item1", "level1 item2"],
+        ["", "level2 item2"],
+        ["level3 item1", "level3 item2"],
+    ]
+
+    result = df["level1 item1"]
+    expected = DataFrame(
+        [["1"], ["2"], ["3"]], index=df.index, columns=["level3 item1"]
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "indexer,expected_slice",
+    [
+        (lambda df: df["foo"], slice(3)),
+        (lambda df: df["bar"], slice(3, 5)),
+        (lambda df: df.loc[:, "bar"], slice(3, 5)),
+    ],
+)
+def test_frame_getitem_toplevel(
+    multiindex_dataframe_random_data, indexer, expected_slice
+):
+    df = multiindex_dataframe_random_data.T
+    expected = df.reindex(columns=df.columns[expected_slice])
+    expected.columns = expected.columns.droplevel(0)
+    result = indexer(df)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_frame_mixed_depth_get():
+    arrays = [
+        ["a", "top", "top", "routine1", "routine1", "routine2"],
+        ["", "OD", "OD", "result1", "result2", "result1"],
+        ["", "wx", "wy", "", "", ""],
+    ]
+
+    tuples = sorted(zip(*arrays))
+    index = MultiIndex.from_tuples(tuples)
+    df = DataFrame(np.random.default_rng(2).standard_normal((4, 6)), columns=index)
+
+    result = df["a"]
+    expected = df["a", "", ""].rename("a")
+    tm.assert_series_equal(result, expected)
+
+    result = df["routine1", "result1"]
+    expected = df["routine1", "result1", ""]
+    expected = expected.rename(("routine1", "result1"))
+    tm.assert_series_equal(result, expected)
+
+
+def test_frame_getitem_nan_multiindex(nulls_fixture):
+    # GH#29751
+    # loc on a multiindex containing nan values
+    n = nulls_fixture  # for code readability
+    cols = ["a", "b", "c"]
+    df = DataFrame(
+        [[11, n, 13], [21, n, 23], [31, n, 33], [41, n, 43]],
+        columns=cols,
+    ).set_index(["a", "b"])
+    df["c"] = df["c"].astype("int64")
+
+    idx = (21, n)
+    result = df.loc[:idx]
+    expected = DataFrame([[11, n, 13], [21, n, 23]], columns=cols).set_index(["a", "b"])
+    expected["c"] = expected["c"].astype("int64")
+    tm.assert_frame_equal(result, expected)
+
+    result = df.loc[idx:]
+    expected = DataFrame(
+        [[21, n, 23], [31, n, 33], [41, n, 43]], columns=cols
+    ).set_index(["a", "b"])
+    expected["c"] = expected["c"].astype("int64")
+    tm.assert_frame_equal(result, expected)
+
+    idx1, idx2 = (21, n), (31, n)
+    result = df.loc[idx1:idx2]
+    expected = DataFrame([[21, n, 23], [31, n, 33]], columns=cols).set_index(["a", "b"])
+    expected["c"] = expected["c"].astype("int64")
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "indexer,expected",
+    [
+        (
+            (["b"], ["bar", np.nan]),
+            (
+                DataFrame(
+                    [[2, 3], [5, 6]],
+                    columns=MultiIndex.from_tuples([("b", "bar"), ("b", np.nan)]),
+                    dtype="int64",
+                )
+            ),
+        ),
+        (
+            (["a", "b"]),
+            (
+                DataFrame(
+                    [[1, 2, 3], [4, 5, 6]],
+                    columns=MultiIndex.from_tuples(
+                        [("a", "foo"), ("b", "bar"), ("b", np.nan)]
+                    ),
+                    dtype="int64",
+                )
+            ),
+        ),
+        (
+            (["b"]),
+            (
+                DataFrame(
+                    [[2, 3], [5, 6]],
+                    columns=MultiIndex.from_tuples([("b", "bar"), ("b", np.nan)]),
+                    dtype="int64",
+                )
+            ),
+        ),
+        (
+            (["b"], ["bar"]),
+            (
+                DataFrame(
+                    [[2], [5]],
+                    columns=MultiIndex.from_tuples([("b", "bar")]),
+                    dtype="int64",
+                )
+            ),
+        ),
+        (
+            (["b"], [np.nan]),
+            (
+                DataFrame(
+                    [[3], [6]],
+                    columns=MultiIndex(
+                        codes=[[1], [-1]], levels=[["a", "b"], ["bar", "foo"]]
+                    ),
+                    dtype="int64",
+                )
+            ),
+        ),
+        (("b", np.nan), Series([3, 6], dtype="int64", name=("b", np.nan))),
+    ],
+)
+def test_frame_getitem_nan_cols_multiindex(
+    indexer,
+    expected,
+    nulls_fixture,
+):
+    # Slicing MultiIndex including levels with nan values, for more information
+    # see GH#25154
+    df = DataFrame(
+        [[1, 2, 3], [4, 5, 6]],
+        columns=MultiIndex.from_tuples(
+            [("a", "foo"), ("b", "bar"), ("b", nulls_fixture)]
+        ),
+        dtype="int64",
+    )
+
+    result = df.loc[:, indexer]
+    tm.assert_equal(result, expected)
+
+
+# ----------------------------------------------------------------------------
+# test indexing of DataFrame with multi-level Index with duplicates
+# ----------------------------------------------------------------------------
+
+
+@pytest.fixture
+def dataframe_with_duplicate_index():
+    """Fixture for DataFrame used in tests for gh-4145 and gh-4146"""
+    data = [["a", "d", "e", "c", "f", "b"], [1, 4, 5, 3, 6, 2], [1, 4, 5, 3, 6, 2]]
+    index = ["h1", "h3", "h5"]
+    columns = MultiIndex(
+        levels=[["A", "B"], ["A1", "A2", "B1", "B2"]],
+        codes=[[0, 0, 0, 1, 1, 1], [0, 3, 3, 0, 1, 2]],
+        names=["main", "sub"],
+    )
+    return DataFrame(data, index=index, columns=columns)
+
+
+@pytest.mark.parametrize(
+    "indexer", [lambda df: df[("A", "A1")], lambda df: df.loc[:, ("A", "A1")]]
+)
+def test_frame_mi_access(dataframe_with_duplicate_index, indexer):
+    # GH 4145
+    df = dataframe_with_duplicate_index
+    index = Index(["h1", "h3", "h5"])
+    columns = MultiIndex.from_tuples([("A", "A1")], names=["main", "sub"])
+    expected = DataFrame([["a", 1, 1]], index=columns, columns=index).T
+
+    result = indexer(df)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_frame_mi_access_returns_series(dataframe_with_duplicate_index):
+    # GH 4146, not returning a block manager when selecting a unique index
+    # from a duplicate index
+    # as of 4879, this returns a Series (which is similar to what happens
+    # with a non-unique)
+    df = dataframe_with_duplicate_index
+    expected = Series(["a", 1, 1], index=["h1", "h3", "h5"], name="A1")
+    result = df["A"]["A1"]
+    tm.assert_series_equal(result, expected)
+
+
+def test_frame_mi_access_returns_frame(dataframe_with_duplicate_index):
+    # selecting a non_unique from the 2nd level
+    df = dataframe_with_duplicate_index
+    expected = DataFrame(
+        [["d", 4, 4], ["e", 5, 5]],
+        index=Index(["B2", "B2"], name="sub"),
+        columns=["h1", "h3", "h5"],
+    ).T
+    result = df["A"]["B2"]
+    tm.assert_frame_equal(result, expected)
+
+
+def test_frame_mi_empty_slice():
+    # GH 15454
+    df = DataFrame(0, index=range(2), columns=MultiIndex.from_product([[1], [2]]))
+    result = df[[]]
+    expected = DataFrame(
+        index=[0, 1], columns=MultiIndex(levels=[[1], [2]], codes=[[], []])
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_loc_empty_multiindex():
+    # GH#36936
+    arrays = [["a", "a", "b", "a"], ["a", "a", "b", "b"]]
+    index = MultiIndex.from_arrays(arrays, names=("idx1", "idx2"))
+    df = DataFrame([1, 2, 3, 4], index=index, columns=["value"])
+
+    # loc on empty multiindex == loc with False mask
+    empty_multiindex = df.loc[df.loc[:, "value"] == 0, :].index
+    result = df.loc[empty_multiindex, :]
+    expected = df.loc[[False] * len(df.index), :]
+    tm.assert_frame_equal(result, expected)
+
+    # replacing value with loc on empty multiindex
+    df.loc[df.loc[df.loc[:, "value"] == 0].index, "value"] = 5
+    result = df
+    expected = DataFrame([1, 2, 3, 4], index=index, columns=["value"])
+    tm.assert_frame_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/indexing/multiindex/test_iloc.py

@@ -0,0 +1,171 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+@pytest.fixture
+def simple_multiindex_dataframe():
+    """
+    Factory function to create simple 3 x 3 dataframe with
+    both columns and row MultiIndex using supplied data or
+    random data by default.
+    """
+
+    data = np.random.default_rng(2).standard_normal((3, 3))
+    return DataFrame(
+        data, columns=[[2, 2, 4], [6, 8, 10]], index=[[4, 4, 8], [8, 10, 12]]
+    )
+
+
+@pytest.mark.parametrize(
+    "indexer, expected",
+    [
+        (
+            lambda df: df.iloc[0],
+            lambda arr: Series(arr[0], index=[[2, 2, 4], [6, 8, 10]], name=(4, 8)),
+        ),
+        (
+            lambda df: df.iloc[2],
+            lambda arr: Series(arr[2], index=[[2, 2, 4], [6, 8, 10]], name=(8, 12)),
+        ),
+        (
+            lambda df: df.iloc[:, 2],
+            lambda arr: Series(arr[:, 2], index=[[4, 4, 8], [8, 10, 12]], name=(4, 10)),
+        ),
+    ],
+)
+def test_iloc_returns_series(indexer, expected, simple_multiindex_dataframe):
+    df = simple_multiindex_dataframe
+    arr = df.values
+    result = indexer(df)
+    expected = expected(arr)
+    tm.assert_series_equal(result, expected)
+
+
+def test_iloc_returns_dataframe(simple_multiindex_dataframe):
+    df = simple_multiindex_dataframe
+    result = df.iloc[[0, 1]]
+    expected = df.xs(4, drop_level=False)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_iloc_returns_scalar(simple_multiindex_dataframe):
+    df = simple_multiindex_dataframe
+    arr = df.values
+    result = df.iloc[2, 2]
+    expected = arr[2, 2]
+    assert result == expected
+
+
+def test_iloc_getitem_multiple_items():
+    # GH 5528
+    tup = zip(*[["a", "a", "b", "b"], ["x", "y", "x", "y"]])
+    index = MultiIndex.from_tuples(tup)
+    df = DataFrame(np.random.default_rng(2).standard_normal((4, 4)), index=index)
+    result = df.iloc[[2, 3]]
+    expected = df.xs("b", drop_level=False)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_iloc_getitem_labels():
+    # this is basically regular indexing
+    arr = np.random.default_rng(2).standard_normal((4, 3))
+    df = DataFrame(
+        arr,
+        columns=[["i", "i", "j"], ["A", "A", "B"]],
+        index=[["i", "i", "j", "k"], ["X", "X", "Y", "Y"]],
+    )
+    result = df.iloc[2, 2]
+    expected = arr[2, 2]
+    assert result == expected
+
+
+def test_frame_getitem_slice(multiindex_dataframe_random_data):
+    df = multiindex_dataframe_random_data
+    result = df.iloc[:4]
+    expected = df[:4]
+    tm.assert_frame_equal(result, expected)
+
+
+def test_frame_setitem_slice(multiindex_dataframe_random_data):
+    df = multiindex_dataframe_random_data
+    df.iloc[:4] = 0
+
+    assert (df.values[:4] == 0).all()
+    assert (df.values[4:] != 0).all()
+
+
+def test_indexing_ambiguity_bug_1678():
+    # GH 1678
+    columns = MultiIndex.from_tuples(
+        [("Ohio", "Green"), ("Ohio", "Red"), ("Colorado", "Green")]
+    )
+    index = MultiIndex.from_tuples([("a", 1), ("a", 2), ("b", 1), ("b", 2)])
+
+    df = DataFrame(np.arange(12).reshape((4, 3)), index=index, columns=columns)
+
+    result = df.iloc[:, 1]
+    expected = df.loc[:, ("Ohio", "Red")]
+    tm.assert_series_equal(result, expected)
+
+
+def test_iloc_integer_locations():
+    # GH 13797
+    data = [
+        ["str00", "str01"],
+        ["str10", "str11"],
+        ["str20", "srt21"],
+        ["str30", "str31"],
+        ["str40", "str41"],
+    ]
+
+    index = MultiIndex.from_tuples(
+        [("CC", "A"), ("CC", "B"), ("CC", "B"), ("BB", "a"), ("BB", "b")]
+    )
+
+    expected = DataFrame(data)
+    df = DataFrame(data, index=index)
+
+    result = DataFrame([[df.iloc[r, c] for c in range(2)] for r in range(5)])
+
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "data, indexes, values, expected_k",
+    [
+        # test without indexer value in first level of MultiIndex
+        ([[2, 22, 5], [2, 33, 6]], [0, -1, 1], [2, 3, 1], [7, 10]),
+        # test like code sample 1 in the issue
+        ([[1, 22, 555], [1, 33, 666]], [0, -1, 1], [200, 300, 100], [755, 1066]),
+        # test like code sample 2 in the issue
+        ([[1, 3, 7], [2, 4, 8]], [0, -1, 1], [10, 10, 1000], [17, 1018]),
+        # test like code sample 3 in the issue
+        ([[1, 11, 4], [2, 22, 5], [3, 33, 6]], [0, -1, 1], [4, 7, 10], [8, 15, 13]),
+    ],
+)
+def test_iloc_setitem_int_multiindex_series(data, indexes, values, expected_k):
+    # GH17148
+    df = DataFrame(data=data, columns=["i", "j", "k"])
+    df = df.set_index(["i", "j"])
+
+    series = df.k.copy()
+    for i, v in zip(indexes, values):
+        series.iloc[i] += v
+
+    df["k"] = expected_k
+    expected = df.k
+    tm.assert_series_equal(series, expected)
+
+
+def test_getitem_iloc(multiindex_dataframe_random_data):
+    df = multiindex_dataframe_random_data
+    result = df.iloc[2]
+    expected = df.xs(df.index[2])
+    tm.assert_series_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/indexing/multiindex/test_indexing_slow.py

@@ -0,0 +1,118 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+
+@pytest.fixture
+def m():
+    return 5
+
+
+@pytest.fixture
+def n():
+    return 100
+
+
+@pytest.fixture
+def cols():
+    return ["jim", "joe", "jolie", "joline", "jolia"]
+
+
+@pytest.fixture
+def vals(n):
+    vals = [
+        np.random.default_rng(2).integers(0, 10, n),
+        np.random.default_rng(2).choice(list("abcdefghij"), n),
+        np.random.default_rng(2).choice(
+            pd.date_range("20141009", periods=10).tolist(), n
+        ),
+        np.random.default_rng(2).choice(list("ZYXWVUTSRQ"), n),
+        np.random.default_rng(2).standard_normal(n),
+    ]
+    vals = list(map(tuple, zip(*vals)))
+    return vals
+
+
+@pytest.fixture
+def keys(n, m, vals):
+    # bunch of keys for testing
+    keys = [
+        np.random.default_rng(2).integers(0, 11, m),
+        np.random.default_rng(2).choice(list("abcdefghijk"), m),
+        np.random.default_rng(2).choice(
+            pd.date_range("20141009", periods=11).tolist(), m
+        ),
+        np.random.default_rng(2).choice(list("ZYXWVUTSRQP"), m),
+    ]
+    keys = list(map(tuple, zip(*keys)))
+    keys += [t[:-1] for t in vals[:: n // m]]
+    return keys
+
+
+# covers both unique index and non-unique index
+@pytest.fixture
+def df(vals, cols):
+    return DataFrame(vals, columns=cols)
+
+
+@pytest.fixture
+def a(df):
+    return pd.concat([df, df])
+
+
+@pytest.fixture
+def b(df, cols):
+    return df.drop_duplicates(subset=cols[:-1])
+
+
+@pytest.mark.filterwarnings("ignore::pandas.errors.PerformanceWarning")
+@pytest.mark.parametrize("lexsort_depth", list(range(5)))
+@pytest.mark.parametrize("frame_fixture", ["a", "b"])
+def test_multiindex_get_loc(request, lexsort_depth, keys, frame_fixture, cols):
+    # GH7724, GH2646
+
+    frame = request.getfixturevalue(frame_fixture)
+    if lexsort_depth == 0:
+        df = frame.copy(deep=False)
+    else:
+        df = frame.sort_values(by=cols[:lexsort_depth])
+
+    mi = df.set_index(cols[:-1])
+    assert not mi.index._lexsort_depth < lexsort_depth
+    for key in keys:
+        mask = np.ones(len(df), dtype=bool)
+
+        # test for all partials of this key
+        for i, k in enumerate(key):
+            mask &= df.iloc[:, i] == k
+
+            if not mask.any():
+                assert key[: i + 1] not in mi.index
+                continue
+
+            assert key[: i + 1] in mi.index
+            right = df[mask].copy(deep=False)
+
+            if i + 1 != len(key):  # partial key
+                return_value = right.drop(cols[: i + 1], axis=1, inplace=True)
+                assert return_value is None
+                return_value = right.set_index(cols[i + 1 : -1], inplace=True)
+                assert return_value is None
+                tm.assert_frame_equal(mi.loc[key[: i + 1]], right)
+
+            else:  # full key
+                return_value = right.set_index(cols[:-1], inplace=True)
+                assert return_value is None
+                if len(right) == 1:  # single hit
+                    right = Series(
+                        right["jolia"].values, name=right.index[0], index=["jolia"]
+                    )
+                    tm.assert_series_equal(mi.loc[key[: i + 1]], right)
+                else:  # multi hit
+                    tm.assert_frame_equal(mi.loc[key[: i + 1]], right)

env-llmeval/lib/python3.10/site-packages/pandas/tests/indexing/multiindex/test_loc.py

@@ -0,0 +1,992 @@
+import numpy as np
+import pytest
+
+from pandas.errors import (
+    IndexingError,
+    PerformanceWarning,
+)
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+@pytest.fixture
+def single_level_multiindex():
+    """single level MultiIndex"""
+    return MultiIndex(
+        levels=[["foo", "bar", "baz", "qux"]], codes=[[0, 1, 2, 3]], names=["first"]
+    )
+
+
+@pytest.fixture
+def frame_random_data_integer_multi_index():
+    levels = [[0, 1], [0, 1, 2]]
+    codes = [[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]]
+    index = MultiIndex(levels=levels, codes=codes)
+    return DataFrame(np.random.default_rng(2).standard_normal((6, 2)), index=index)
+
+
+class TestMultiIndexLoc:
+    def test_loc_setitem_frame_with_multiindex(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+        frame.loc[("bar", "two"), "B"] = 5
+        assert frame.loc[("bar", "two"), "B"] == 5
+
+        # with integer labels
+        df = frame.copy()
+        df.columns = list(range(3))
+        df.loc[("bar", "two"), 1] = 7
+        assert df.loc[("bar", "two"), 1] == 7
+
+    def test_loc_getitem_general(self, any_real_numpy_dtype):
+        # GH#2817
+        dtype = any_real_numpy_dtype
+        data = {
+            "amount": {0: 700, 1: 600, 2: 222, 3: 333, 4: 444},
+            "col": {0: 3.5, 1: 3.5, 2: 4.0, 3: 4.0, 4: 4.0},
+            "num": {0: 12, 1: 11, 2: 12, 3: 12, 4: 12},
+        }
+        df = DataFrame(data)
+        df = df.astype({"col": dtype, "num": dtype})
+        df = df.set_index(keys=["col", "num"])
+        key = 4.0, 12
+
+        # emits a PerformanceWarning, ok
+        with tm.assert_produces_warning(PerformanceWarning):
+            tm.assert_frame_equal(df.loc[key], df.iloc[2:])
+
+        # this is ok
+        return_value = df.sort_index(inplace=True)
+        assert return_value is None
+        res = df.loc[key]
+
+        # col has float dtype, result should be float64 Index
+        col_arr = np.array([4.0] * 3, dtype=dtype)
+        year_arr = np.array([12] * 3, dtype=dtype)
+        index = MultiIndex.from_arrays([col_arr, year_arr], names=["col", "num"])
+        expected = DataFrame({"amount": [222, 333, 444]}, index=index)
+        tm.assert_frame_equal(res, expected)
+
+    def test_loc_getitem_multiindex_missing_label_raises(self):
+        # GH#21593
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 3)),
+            columns=[[2, 2, 4], [6, 8, 10]],
+            index=[[4, 4, 8], [8, 10, 12]],
+        )
+
+        with pytest.raises(KeyError, match=r"^2$"):
+            df.loc[2]
+
+    def test_loc_getitem_list_of_tuples_with_multiindex(
+        self, multiindex_year_month_day_dataframe_random_data
+    ):
+        ser = multiindex_year_month_day_dataframe_random_data["A"]
+        expected = ser.reindex(ser.index[49:51])
+        result = ser.loc[[(2000, 3, 10), (2000, 3, 13)]]
+        tm.assert_series_equal(result, expected)
+
+    def test_loc_getitem_series(self):
+        # GH14730
+        # passing a series as a key with a MultiIndex
+        index = MultiIndex.from_product([[1, 2, 3], ["A", "B", "C"]])
+        x = Series(index=index, data=range(9), dtype=np.float64)
+        y = Series([1, 3])
+        expected = Series(
+            data=[0, 1, 2, 6, 7, 8],
+            index=MultiIndex.from_product([[1, 3], ["A", "B", "C"]]),
+            dtype=np.float64,
+        )
+        result = x.loc[y]
+        tm.assert_series_equal(result, expected)
+
+        result = x.loc[[1, 3]]
+        tm.assert_series_equal(result, expected)
+
+        # GH15424
+        y1 = Series([1, 3], index=[1, 2])
+        result = x.loc[y1]
+        tm.assert_series_equal(result, expected)
+
+        empty = Series(data=[], dtype=np.float64)
+        expected = Series(
+            [],
+            index=MultiIndex(levels=index.levels, codes=[[], []], dtype=np.float64),
+            dtype=np.float64,
+        )
+        result = x.loc[empty]
+        tm.assert_series_equal(result, expected)
+
+    def test_loc_getitem_array(self):
+        # GH15434
+        # passing an array as a key with a MultiIndex
+        index = MultiIndex.from_product([[1, 2, 3], ["A", "B", "C"]])
+        x = Series(index=index, data=range(9), dtype=np.float64)
+        y = np.array([1, 3])
+        expected = Series(
+            data=[0, 1, 2, 6, 7, 8],
+            index=MultiIndex.from_product([[1, 3], ["A", "B", "C"]]),
+            dtype=np.float64,
+        )
+        result = x.loc[y]
+        tm.assert_series_equal(result, expected)
+
+        # empty array:
+        empty = np.array([])
+        expected = Series(
+            [],
+            index=MultiIndex(levels=index.levels, codes=[[], []], dtype=np.float64),
+            dtype="float64",
+        )
+        result = x.loc[empty]
+        tm.assert_series_equal(result, expected)
+
+        # 0-dim array (scalar):
+        scalar = np.int64(1)
+        expected = Series(data=[0, 1, 2], index=["A", "B", "C"], dtype=np.float64)
+        result = x.loc[scalar]
+        tm.assert_series_equal(result, expected)
+
+    def test_loc_multiindex_labels(self):
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 3)),
+            columns=[["i", "i", "j"], ["A", "A", "B"]],
+            index=[["i", "i", "j"], ["X", "X", "Y"]],
+        )
+
+        # the first 2 rows
+        expected = df.iloc[[0, 1]].droplevel(0)
+        result = df.loc["i"]
+        tm.assert_frame_equal(result, expected)
+
+        # 2nd (last) column
+        expected = df.iloc[:, [2]].droplevel(0, axis=1)
+        result = df.loc[:, "j"]
+        tm.assert_frame_equal(result, expected)
+
+        # bottom right corner
+        expected = df.iloc[[2], [2]].droplevel(0).droplevel(0, axis=1)
+        result = df.loc["j"].loc[:, "j"]
+        tm.assert_frame_equal(result, expected)
+
+        # with a tuple
+        expected = df.iloc[[0, 1]]
+        result = df.loc[("i", "X")]
+        tm.assert_frame_equal(result, expected)
+
+    def test_loc_multiindex_ints(self):
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 3)),
+            columns=[[2, 2, 4], [6, 8, 10]],
+            index=[[4, 4, 8], [8, 10, 12]],
+        )
+        expected = df.iloc[[0, 1]].droplevel(0)
+        result = df.loc[4]
+        tm.assert_frame_equal(result, expected)
+
+    def test_loc_multiindex_missing_label_raises(self):
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 3)),
+            columns=[[2, 2, 4], [6, 8, 10]],
+            index=[[4, 4, 8], [8, 10, 12]],
+        )
+
+        with pytest.raises(KeyError, match=r"^2$"):
+            df.loc[2]
+
+    @pytest.mark.parametrize("key, pos", [([2, 4], [0, 1]), ([2], []), ([2, 3], [])])
+    def test_loc_multiindex_list_missing_label(self, key, pos):
+        # GH 27148 - lists with missing labels _do_ raise
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 3)),
+            columns=[[2, 2, 4], [6, 8, 10]],
+            index=[[4, 4, 8], [8, 10, 12]],
+        )
+
+        with pytest.raises(KeyError, match="not in index"):
+            df.loc[key]
+
+    def test_loc_multiindex_too_many_dims_raises(self):
+        # GH 14885
+        s = Series(
+            range(8),
+            index=MultiIndex.from_product([["a", "b"], ["c", "d"], ["e", "f"]]),
+        )
+
+        with pytest.raises(KeyError, match=r"^\('a', 'b'\)$"):
+            s.loc["a", "b"]
+        with pytest.raises(KeyError, match=r"^\('a', 'd', 'g'\)$"):
+            s.loc["a", "d", "g"]
+        with pytest.raises(IndexingError, match="Too many indexers"):
+            s.loc["a", "d", "g", "j"]
+
+    def test_loc_multiindex_indexer_none(self):
+        # GH6788
+        # multi-index indexer is None (meaning take all)
+        attributes = ["Attribute" + str(i) for i in range(1)]
+        attribute_values = ["Value" + str(i) for i in range(5)]
+
+        index = MultiIndex.from_product([attributes, attribute_values])
+        df = 0.1 * np.random.default_rng(2).standard_normal((10, 1 * 5)) + 0.5
+        df = DataFrame(df, columns=index)
+        result = df[attributes]
+        tm.assert_frame_equal(result, df)
+
+        # GH 7349
+        # loc with a multi-index seems to be doing fallback
+        df = DataFrame(
+            np.arange(12).reshape(-1, 1),
+            index=MultiIndex.from_product([[1, 2, 3, 4], [1, 2, 3]]),
+        )
+
+        expected = df.loc[([1, 2],), :]
+        result = df.loc[[1, 2]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_loc_multiindex_incomplete(self):
+        # GH 7399
+        # incomplete indexers
+        s = Series(
+            np.arange(15, dtype="int64"),
+            MultiIndex.from_product([range(5), ["a", "b", "c"]]),
+        )
+        expected = s.loc[:, "a":"c"]
+
+        result = s.loc[0:4, "a":"c"]
+        tm.assert_series_equal(result, expected)
+
+        result = s.loc[:4, "a":"c"]
+        tm.assert_series_equal(result, expected)
+
+        result = s.loc[0:, "a":"c"]
+        tm.assert_series_equal(result, expected)
+
+        # GH 7400
+        # multiindexer getitem with list of indexers skips wrong element
+        s = Series(
+            np.arange(15, dtype="int64"),
+            MultiIndex.from_product([range(5), ["a", "b", "c"]]),
+        )
+        expected = s.iloc[[6, 7, 8, 12, 13, 14]]
+        result = s.loc[2:4:2, "a":"c"]
+        tm.assert_series_equal(result, expected)
+
+    def test_get_loc_single_level(self, single_level_multiindex):
+        single_level = single_level_multiindex
+        s = Series(
+            np.random.default_rng(2).standard_normal(len(single_level)),
+            index=single_level,
+        )
+        for k in single_level.values:
+            s[k]
+
+    def test_loc_getitem_int_slice(self):
+        # GH 3053
+        # loc should treat integer slices like label slices
+
+        index = MultiIndex.from_product([[6, 7, 8], ["a", "b"]])
+        df = DataFrame(np.random.default_rng(2).standard_normal((6, 6)), index, index)
+        result = df.loc[6:8, :]
+        expected = df
+        tm.assert_frame_equal(result, expected)
+
+        index = MultiIndex.from_product([[10, 20, 30], ["a", "b"]])
+        df = DataFrame(np.random.default_rng(2).standard_normal((6, 6)), index, index)
+        result = df.loc[20:30, :]
+        expected = df.iloc[2:]
+        tm.assert_frame_equal(result, expected)
+
+        # doc examples
+        result = df.loc[10, :]
+        expected = df.iloc[0:2]
+        expected.index = ["a", "b"]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.loc[:, 10]
+        expected = df[10]
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "indexer_type_1", (list, tuple, set, slice, np.ndarray, Series, Index)
+    )
+    @pytest.mark.parametrize(
+        "indexer_type_2", (list, tuple, set, slice, np.ndarray, Series, Index)
+    )
+    def test_loc_getitem_nested_indexer(self, indexer_type_1, indexer_type_2):
+        # GH #19686
+        # .loc should work with nested indexers which can be
+        # any list-like objects (see `is_list_like` (`pandas.api.types`)) or slices
+
+        def convert_nested_indexer(indexer_type, keys):
+            if indexer_type == np.ndarray:
+                return np.array(keys)
+            if indexer_type == slice:
+                return slice(*keys)
+            return indexer_type(keys)
+
+        a = [10, 20, 30]
+        b = [1, 2, 3]
+        index = MultiIndex.from_product([a, b])
+        df = DataFrame(
+            np.arange(len(index), dtype="int64"), index=index, columns=["Data"]
+        )
+
+        keys = ([10, 20], [2, 3])
+        types = (indexer_type_1, indexer_type_2)
+
+        # check indexers with all the combinations of nested objects
+        # of all the valid types
+        indexer = tuple(
+            convert_nested_indexer(indexer_type, k)
+            for indexer_type, k in zip(types, keys)
+        )
+        if indexer_type_1 is set or indexer_type_2 is set:
+            with pytest.raises(TypeError, match="as an indexer is not supported"):
+                df.loc[indexer, "Data"]
+
+            return
+        else:
+            result = df.loc[indexer, "Data"]
+        expected = Series(
+            [1, 2, 4, 5], name="Data", index=MultiIndex.from_product(keys)
+        )
+
+        tm.assert_series_equal(result, expected)
+
+    def test_multiindex_loc_one_dimensional_tuple(self, frame_or_series):
+        # GH#37711
+        mi = MultiIndex.from_tuples([("a", "A"), ("b", "A")])
+        obj = frame_or_series([1, 2], index=mi)
+        obj.loc[("a",)] = 0
+        expected = frame_or_series([0, 2], index=mi)
+        tm.assert_equal(obj, expected)
+
+    @pytest.mark.parametrize("indexer", [("a",), ("a")])
+    def test_multiindex_one_dimensional_tuple_columns(self, indexer):
+        # GH#37711
+        mi = MultiIndex.from_tuples([("a", "A"), ("b", "A")])
+        obj = DataFrame([1, 2], index=mi)
+        obj.loc[indexer, :] = 0
+        expected = DataFrame([0, 2], index=mi)
+        tm.assert_frame_equal(obj, expected)
+
+    @pytest.mark.parametrize(
+        "indexer, exp_value", [(slice(None), 1.0), ((1, 2), np.nan)]
+    )
+    def test_multiindex_setitem_columns_enlarging(self, indexer, exp_value):
+        # GH#39147
+        mi = MultiIndex.from_tuples([(1, 2), (3, 4)])
+        df = DataFrame([[1, 2], [3, 4]], index=mi, columns=["a", "b"])
+        df.loc[indexer, ["c", "d"]] = 1.0
+        expected = DataFrame(
+            [[1, 2, 1.0, 1.0], [3, 4, exp_value, exp_value]],
+            index=mi,
+            columns=["a", "b", "c", "d"],
+        )
+        tm.assert_frame_equal(df, expected)
+
+    def test_sorted_multiindex_after_union(self):
+        # GH#44752
+        midx = MultiIndex.from_product(
+            [pd.date_range("20110101", periods=2), Index(["a", "b"])]
+        )
+        ser1 = Series(1, index=midx)
+        ser2 = Series(1, index=midx[:2])
+        df = pd.concat([ser1, ser2], axis=1)
+        expected = df.copy()
+        result = df.loc["2011-01-01":"2011-01-02"]
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame({0: ser1, 1: ser2})
+        result = df.loc["2011-01-01":"2011-01-02"]
+        tm.assert_frame_equal(result, expected)
+
+        df = pd.concat([ser1, ser2.reindex(ser1.index)], axis=1)
+        result = df.loc["2011-01-01":"2011-01-02"]
+        tm.assert_frame_equal(result, expected)
+
+    def test_loc_no_second_level_index(self):
+        # GH#43599
+        df = DataFrame(
+            index=MultiIndex.from_product([list("ab"), list("cd"), list("e")]),
+            columns=["Val"],
+        )
+        res = df.loc[np.s_[:, "c", :]]
+        expected = DataFrame(
+            index=MultiIndex.from_product([list("ab"), list("e")]), columns=["Val"]
+        )
+        tm.assert_frame_equal(res, expected)
+
+    def test_loc_multi_index_key_error(self):
+        # GH 51892
+        df = DataFrame(
+            {
+                (1, 2): ["a", "b", "c"],
+                (1, 3): ["d", "e", "f"],
+                (2, 2): ["g", "h", "i"],
+                (2, 4): ["j", "k", "l"],
+            }
+        )
+        with pytest.raises(KeyError, match=r"(1, 4)"):
+            df.loc[0, (1, 4)]
+
+
+@pytest.mark.parametrize(
+    "indexer, pos",
+    [
+        ([], []),  # empty ok
+        (["A"], slice(3)),
+        (["A", "D"], []),  # "D" isn't present -> raise
+        (["D", "E"], []),  # no values found -> raise
+        (["D"], []),  # same, with single item list: GH 27148
+        (pd.IndexSlice[:, ["foo"]], slice(2, None, 3)),
+        (pd.IndexSlice[:, ["foo", "bah"]], slice(2, None, 3)),
+    ],
+)
+def test_loc_getitem_duplicates_multiindex_missing_indexers(indexer, pos):
+    # GH 7866
+    # multi-index slicing with missing indexers
+    idx = MultiIndex.from_product(
+        [["A", "B", "C"], ["foo", "bar", "baz"]], names=["one", "two"]
+    )
+    ser = Series(np.arange(9, dtype="int64"), index=idx).sort_index()
+    expected = ser.iloc[pos]
+
+    if expected.size == 0 and indexer != []:
+        with pytest.raises(KeyError, match=str(indexer)):
+            ser.loc[indexer]
+    elif indexer == (slice(None), ["foo", "bah"]):
+        # "bah" is not in idx.levels[1], raising KeyError enforced in 2.0
+        with pytest.raises(KeyError, match="'bah'"):
+            ser.loc[indexer]
+    else:
+        result = ser.loc[indexer]
+        tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("columns_indexer", [([], slice(None)), (["foo"], [])])
+def test_loc_getitem_duplicates_multiindex_empty_indexer(columns_indexer):
+    # GH 8737
+    # empty indexer
+    multi_index = MultiIndex.from_product((["foo", "bar", "baz"], ["alpha", "beta"]))
+    df = DataFrame(
+        np.random.default_rng(2).standard_normal((5, 6)),
+        index=range(5),
+        columns=multi_index,
+    )
+    df = df.sort_index(level=0, axis=1)
+
+    expected = DataFrame(index=range(5), columns=multi_index.reindex([])[0])
+    result = df.loc[:, columns_indexer]
+    tm.assert_frame_equal(result, expected)
+
+
+def test_loc_getitem_duplicates_multiindex_non_scalar_type_object():
+    # regression from < 0.14.0
+    # GH 7914
+    df = DataFrame(
+        [[np.mean, np.median], ["mean", "median"]],
+        columns=MultiIndex.from_tuples([("functs", "mean"), ("functs", "median")]),
+        index=["function", "name"],
+    )
+    result = df.loc["function", ("functs", "mean")]
+    expected = np.mean
+    assert result == expected
+
+
+def test_loc_getitem_tuple_plus_slice():
+    # GH 671
+    df = DataFrame(
+        {
+            "a": np.arange(10),
+            "b": np.arange(10),
+            "c": np.random.default_rng(2).standard_normal(10),
+            "d": np.random.default_rng(2).standard_normal(10),
+        }
+    ).set_index(["a", "b"])
+    expected = df.loc[0, 0]
+    result = df.loc[(0, 0), :]
+    tm.assert_series_equal(result, expected)
+
+
+def test_loc_getitem_int(frame_random_data_integer_multi_index):
+    df = frame_random_data_integer_multi_index
+    result = df.loc[1]
+    expected = df[-3:]
+    expected.index = expected.index.droplevel(0)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_loc_getitem_int_raises_exception(frame_random_data_integer_multi_index):
+    df = frame_random_data_integer_multi_index
+    with pytest.raises(KeyError, match=r"^3$"):
+        df.loc[3]
+
+
+def test_loc_getitem_lowerdim_corner(multiindex_dataframe_random_data):
+    df = multiindex_dataframe_random_data
+
+    # test setup - check key not in dataframe
+    with pytest.raises(KeyError, match=r"^\('bar', 'three'\)$"):
+        df.loc[("bar", "three"), "B"]
+
+    # in theory should be inserting in a sorted space????
+    df.loc[("bar", "three"), "B"] = 0
+    expected = 0
+    result = df.sort_index().loc[("bar", "three"), "B"]
+    assert result == expected
+
+
+def test_loc_setitem_single_column_slice():
+    # case from https://github.com/pandas-dev/pandas/issues/27841
+    df = DataFrame(
+        "string",
+        index=list("abcd"),
+        columns=MultiIndex.from_product([["Main"], ("another", "one")]),
+    )
+    df["labels"] = "a"
+    df.loc[:, "labels"] = df.index
+    tm.assert_numpy_array_equal(np.asarray(df["labels"]), np.asarray(df.index))
+
+    # test with non-object block
+    df = DataFrame(
+        np.nan,
+        index=range(4),
+        columns=MultiIndex.from_tuples([("A", "1"), ("A", "2"), ("B", "1")]),
+    )
+    expected = df.copy()
+    df.loc[:, "B"] = np.arange(4)
+    expected.iloc[:, 2] = np.arange(4)
+    tm.assert_frame_equal(df, expected)
+
+
+def test_loc_nan_multiindex(using_infer_string):
+    # GH 5286
+    tups = [
+        ("Good Things", "C", np.nan),
+        ("Good Things", "R", np.nan),
+        ("Bad Things", "C", np.nan),
+        ("Bad Things", "T", np.nan),
+        ("Okay Things", "N", "B"),
+        ("Okay Things", "N", "D"),
+        ("Okay Things", "B", np.nan),
+        ("Okay Things", "D", np.nan),
+    ]
+    df = DataFrame(
+        np.ones((8, 4)),
+        columns=Index(["d1", "d2", "d3", "d4"]),
+        index=MultiIndex.from_tuples(tups, names=["u1", "u2", "u3"]),
+    )
+    result = df.loc["Good Things"].loc["C"]
+    expected = DataFrame(
+        np.ones((1, 4)),
+        index=Index(
+            [np.nan],
+            dtype="object" if not using_infer_string else "string[pyarrow_numpy]",
+            name="u3",
+        ),
+        columns=Index(["d1", "d2", "d3", "d4"]),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_loc_period_string_indexing():
+    # GH 9892
+    a = pd.period_range("2013Q1", "2013Q4", freq="Q")
+    i = (1111, 2222, 3333)
+    idx = MultiIndex.from_product((a, i), names=("Period", "CVR"))
+    df = DataFrame(
+        index=idx,
+        columns=(
+            "OMS",
+            "OMK",
+            "RES",
+            "DRIFT_IND",
+            "OEVRIG_IND",
+            "FIN_IND",
+            "VARE_UD",
+            "LOEN_UD",
+            "FIN_UD",
+        ),
+    )
+    result = df.loc[("2013Q1", 1111), "OMS"]
+
+    alt = df.loc[(a[0], 1111), "OMS"]
+    assert np.isnan(alt)
+
+    # Because the resolution of the string matches, it is an exact lookup,
+    #  not a slice
+    assert np.isnan(result)
+
+    alt = df.loc[("2013Q1", 1111), "OMS"]
+    assert np.isnan(alt)
+
+
+def test_loc_datetime_mask_slicing():
+    # GH 16699
+    dt_idx = pd.to_datetime(["2017-05-04", "2017-05-05"])
+    m_idx = MultiIndex.from_product([dt_idx, dt_idx], names=["Idx1", "Idx2"])
+    df = DataFrame(
+        data=[[1, 2], [3, 4], [5, 6], [7, 6]], index=m_idx, columns=["C1", "C2"]
+    )
+    result = df.loc[(dt_idx[0], (df.index.get_level_values(1) > "2017-05-04")), "C1"]
+    expected = Series(
+        [3],
+        name="C1",
+        index=MultiIndex.from_tuples(
+            [(pd.Timestamp("2017-05-04"), pd.Timestamp("2017-05-05"))],
+            names=["Idx1", "Idx2"],
+        ),
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_loc_datetime_series_tuple_slicing():
+    # https://github.com/pandas-dev/pandas/issues/35858
+    date = pd.Timestamp("2000")
+    ser = Series(
+        1,
+        index=MultiIndex.from_tuples([("a", date)], names=["a", "b"]),
+        name="c",
+    )
+    result = ser.loc[:, [date]]
+    tm.assert_series_equal(result, ser)
+
+
+def test_loc_with_mi_indexer():
+    # https://github.com/pandas-dev/pandas/issues/35351
+    df = DataFrame(
+        data=[["a", 1], ["a", 0], ["b", 1], ["c", 2]],
+        index=MultiIndex.from_tuples(
+            [(0, 1), (1, 0), (1, 1), (1, 1)], names=["index", "date"]
+        ),
+        columns=["author", "price"],
+    )
+    idx = MultiIndex.from_tuples([(0, 1), (1, 1)], names=["index", "date"])
+    result = df.loc[idx, :]
+    expected = DataFrame(
+        [["a", 1], ["b", 1], ["c", 2]],
+        index=MultiIndex.from_tuples([(0, 1), (1, 1), (1, 1)], names=["index", "date"]),
+        columns=["author", "price"],
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_loc_mi_with_level1_named_0():
+    # GH#37194
+    dti = pd.date_range("2016-01-01", periods=3, tz="US/Pacific")
+
+    ser = Series(range(3), index=dti)
+    df = ser.to_frame()
+    df[1] = dti
+
+    df2 = df.set_index(0, append=True)
+    assert df2.index.names == (None, 0)
+    df2.index.get_loc(dti[0])  # smoke test
+
+    result = df2.loc[dti[0]]
+    expected = df2.iloc[[0]].droplevel(None)
+    tm.assert_frame_equal(result, expected)
+
+    ser2 = df2[1]
+    assert ser2.index.names == (None, 0)
+
+    result = ser2.loc[dti[0]]
+    expected = ser2.iloc[[0]].droplevel(None)
+    tm.assert_series_equal(result, expected)
+
+
+def test_getitem_str_slice():
+    # GH#15928
+    df = DataFrame(
+        [
+            ["20160525 13:30:00.023", "MSFT", "51.95", "51.95"],
+            ["20160525 13:30:00.048", "GOOG", "720.50", "720.93"],
+            ["20160525 13:30:00.076", "AAPL", "98.55", "98.56"],
+            ["20160525 13:30:00.131", "AAPL", "98.61", "98.62"],
+            ["20160525 13:30:00.135", "MSFT", "51.92", "51.95"],
+            ["20160525 13:30:00.135", "AAPL", "98.61", "98.62"],
+        ],
+        columns="time,ticker,bid,ask".split(","),
+    )
+    df2 = df.set_index(["ticker", "time"]).sort_index()
+
+    res = df2.loc[("AAPL", slice("2016-05-25 13:30:00")), :].droplevel(0)
+    expected = df2.loc["AAPL"].loc[slice("2016-05-25 13:30:00"), :]
+    tm.assert_frame_equal(res, expected)
+
+
+def test_3levels_leading_period_index():
+    # GH#24091
+    pi = pd.PeriodIndex(
+        ["20181101 1100", "20181101 1200", "20181102 1300", "20181102 1400"],
+        name="datetime",
+        freq="D",
+    )
+    lev2 = ["A", "A", "Z", "W"]
+    lev3 = ["B", "C", "Q", "F"]
+    mi = MultiIndex.from_arrays([pi, lev2, lev3])
+
+    ser = Series(range(4), index=mi, dtype=np.float64)
+    result = ser.loc[(pi[0], "A", "B")]
+    assert result == 0.0
+
+
+class TestKeyErrorsWithMultiIndex:
+    def test_missing_keys_raises_keyerror(self):
+        # GH#27420 KeyError, not TypeError
+        df = DataFrame(np.arange(12).reshape(4, 3), columns=["A", "B", "C"])
+        df2 = df.set_index(["A", "B"])
+
+        with pytest.raises(KeyError, match="1"):
+            df2.loc[(1, 6)]
+
+    def test_missing_key_raises_keyerror2(self):
+        # GH#21168 KeyError, not "IndexingError: Too many indexers"
+        ser = Series(-1, index=MultiIndex.from_product([[0, 1]] * 2))
+
+        with pytest.raises(KeyError, match=r"\(0, 3\)"):
+            ser.loc[0, 3]
+
+    def test_missing_key_combination(self):
+        # GH: 19556
+        mi = MultiIndex.from_arrays(
+            [
+                np.array(["a", "a", "b", "b"]),
+                np.array(["1", "2", "2", "3"]),
+                np.array(["c", "d", "c", "d"]),
+            ],
+            names=["one", "two", "three"],
+        )
+        df = DataFrame(np.random.default_rng(2).random((4, 3)), index=mi)
+        msg = r"\('b', '1', slice\(None, None, None\)\)"
+        with pytest.raises(KeyError, match=msg):
+            df.loc[("b", "1", slice(None)), :]
+        with pytest.raises(KeyError, match=msg):
+            df.index.get_locs(("b", "1", slice(None)))
+        with pytest.raises(KeyError, match=r"\('b', '1'\)"):
+            df.loc[("b", "1"), :]
+
+
+def test_getitem_loc_commutability(multiindex_year_month_day_dataframe_random_data):
+    df = multiindex_year_month_day_dataframe_random_data
+    ser = df["A"]
+    result = ser[2000, 5]
+    expected = df.loc[2000, 5]["A"]
+    tm.assert_series_equal(result, expected)
+
+
+def test_loc_with_nan():
+    # GH: 27104
+    df = DataFrame(
+        {"col": [1, 2, 5], "ind1": ["a", "d", np.nan], "ind2": [1, 4, 5]}
+    ).set_index(["ind1", "ind2"])
+    result = df.loc[["a"]]
+    expected = DataFrame(
+        {"col": [1]}, index=MultiIndex.from_tuples([("a", 1)], names=["ind1", "ind2"])
+    )
+    tm.assert_frame_equal(result, expected)
+
+    result = df.loc["a"]
+    expected = DataFrame({"col": [1]}, index=Index([1], name="ind2"))
+    tm.assert_frame_equal(result, expected)
+
+
+def test_getitem_non_found_tuple():
+    # GH: 25236
+    df = DataFrame([[1, 2, 3, 4]], columns=["a", "b", "c", "d"]).set_index(
+        ["a", "b", "c"]
+    )
+    with pytest.raises(KeyError, match=r"\(2\.0, 2\.0, 3\.0\)"):
+        df.loc[(2.0, 2.0, 3.0)]
+
+
+def test_get_loc_datetime_index():
+    # GH#24263
+    index = pd.date_range("2001-01-01", periods=100)
+    mi = MultiIndex.from_arrays([index])
+    # Check if get_loc matches for Index and MultiIndex
+    assert mi.get_loc("2001-01") == slice(0, 31, None)
+    assert index.get_loc("2001-01") == slice(0, 31, None)
+
+    loc = mi[::2].get_loc("2001-01")
+    expected = index[::2].get_loc("2001-01")
+    assert loc == expected
+
+    loc = mi.repeat(2).get_loc("2001-01")
+    expected = index.repeat(2).get_loc("2001-01")
+    assert loc == expected
+
+    loc = mi.append(mi).get_loc("2001-01")
+    expected = index.append(index).get_loc("2001-01")
+    # TODO: standardize return type for MultiIndex.get_loc
+    tm.assert_numpy_array_equal(loc.nonzero()[0], expected)
+
+
+def test_loc_setitem_indexer_differently_ordered():
+    # GH#34603
+    mi = MultiIndex.from_product([["a", "b"], [0, 1]])
+    df = DataFrame([[1, 2], [3, 4], [5, 6], [7, 8]], index=mi)
+
+    indexer = ("a", [1, 0])
+    df.loc[indexer, :] = np.array([[9, 10], [11, 12]])
+    expected = DataFrame([[11, 12], [9, 10], [5, 6], [7, 8]], index=mi)
+    tm.assert_frame_equal(df, expected)
+
+
+def test_loc_getitem_index_differently_ordered_slice_none():
+    # GH#31330
+    df = DataFrame(
+        [[1, 2], [3, 4], [5, 6], [7, 8]],
+        index=[["a", "a", "b", "b"], [1, 2, 1, 2]],
+        columns=["a", "b"],
+    )
+    result = df.loc[(slice(None), [2, 1]), :]
+    expected = DataFrame(
+        [[3, 4], [7, 8], [1, 2], [5, 6]],
+        index=[["a", "b", "a", "b"], [2, 2, 1, 1]],
+        columns=["a", "b"],
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("indexer", [[1, 2, 7, 6, 2, 3, 8, 7], [1, 2, 7, 6, 3, 8]])
+def test_loc_getitem_index_differently_ordered_slice_none_duplicates(indexer):
+    # GH#40978
+    df = DataFrame(
+        [1] * 8,
+        index=MultiIndex.from_tuples(
+            [(1, 1), (1, 2), (1, 7), (1, 6), (2, 2), (2, 3), (2, 8), (2, 7)]
+        ),
+        columns=["a"],
+    )
+    result = df.loc[(slice(None), indexer), :]
+    expected = DataFrame(
+        [1] * 8,
+        index=[[1, 1, 2, 1, 2, 1, 2, 2], [1, 2, 2, 7, 7, 6, 3, 8]],
+        columns=["a"],
+    )
+    tm.assert_frame_equal(result, expected)
+
+    result = df.loc[df.index.isin(indexer, level=1), :]
+    tm.assert_frame_equal(result, df)
+
+
+def test_loc_getitem_drops_levels_for_one_row_dataframe():
+    # GH#10521 "x" and "z" are both scalar indexing, so those levels are dropped
+    mi = MultiIndex.from_arrays([["x"], ["y"], ["z"]], names=["a", "b", "c"])
+    df = DataFrame({"d": [0]}, index=mi)
+    expected = df.droplevel([0, 2])
+    result = df.loc["x", :, "z"]
+    tm.assert_frame_equal(result, expected)
+
+    ser = Series([0], index=mi)
+    result = ser.loc["x", :, "z"]
+    expected = Series([0], index=Index(["y"], name="b"))
+    tm.assert_series_equal(result, expected)
+
+
+def test_mi_columns_loc_list_label_order():
+    # GH 10710
+    cols = MultiIndex.from_product([["A", "B", "C"], [1, 2]])
+    df = DataFrame(np.zeros((5, 6)), columns=cols)
+    result = df.loc[:, ["B", "A"]]
+    expected = DataFrame(
+        np.zeros((5, 4)),
+        columns=MultiIndex.from_tuples([("B", 1), ("B", 2), ("A", 1), ("A", 2)]),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_mi_partial_indexing_list_raises():
+    # GH 13501
+    frame = DataFrame(
+        np.arange(12).reshape((4, 3)),
+        index=[["a", "a", "b", "b"], [1, 2, 1, 2]],
+        columns=[["Ohio", "Ohio", "Colorado"], ["Green", "Red", "Green"]],
+    )
+    frame.index.names = ["key1", "key2"]
+    frame.columns.names = ["state", "color"]
+    with pytest.raises(KeyError, match="\\[2\\] not in index"):
+        frame.loc[["b", 2], "Colorado"]
+
+
+def test_mi_indexing_list_nonexistent_raises():
+    # GH 15452
+    s = Series(range(4), index=MultiIndex.from_product([[1, 2], ["a", "b"]]))
+    with pytest.raises(KeyError, match="\\['not' 'found'\\] not in index"):
+        s.loc[["not", "found"]]
+
+
+def test_mi_add_cell_missing_row_non_unique():
+    # GH 16018
+    result = DataFrame(
+        [[1, 2, 5, 6], [3, 4, 7, 8]],
+        index=["a", "a"],
+        columns=MultiIndex.from_product([[1, 2], ["A", "B"]]),
+    )
+    result.loc["c"] = -1
+    result.loc["c", (1, "A")] = 3
+    result.loc["d", (1, "A")] = 3
+    expected = DataFrame(
+        [
+            [1.0, 2.0, 5.0, 6.0],
+            [3.0, 4.0, 7.0, 8.0],
+            [3.0, -1.0, -1, -1],
+            [3.0, np.nan, np.nan, np.nan],
+        ],
+        index=["a", "a", "c", "d"],
+        columns=MultiIndex.from_product([[1, 2], ["A", "B"]]),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_loc_get_scalar_casting_to_float():
+    # GH#41369
+    df = DataFrame(
+        {"a": 1.0, "b": 2}, index=MultiIndex.from_arrays([[3], [4]], names=["c", "d"])
+    )
+    result = df.loc[(3, 4), "b"]
+    assert result == 2
+    assert isinstance(result, np.int64)
+    result = df.loc[[(3, 4)], "b"].iloc[0]
+    assert result == 2
+    assert isinstance(result, np.int64)
+
+
+def test_loc_empty_single_selector_with_names():
+    # GH 19517
+    idx = MultiIndex.from_product([["a", "b"], ["A", "B"]], names=[1, 0])
+    s2 = Series(index=idx, dtype=np.float64)
+    result = s2.loc["a"]
+    expected = Series([np.nan, np.nan], index=Index(["A", "B"], name=0))
+    tm.assert_series_equal(result, expected)
+
+
+def test_loc_keyerror_rightmost_key_missing():
+    # GH 20951
+
+    df = DataFrame(
+        {
+            "A": [100, 100, 200, 200, 300, 300],
+            "B": [10, 10, 20, 21, 31, 33],
+            "C": range(6),
+        }
+    )
+    df = df.set_index(["A", "B"])
+    with pytest.raises(KeyError, match="^1$"):
+        df.loc[(100, 1)]
+
+
+def test_multindex_series_loc_with_tuple_label():
+    # GH#43908
+    mi = MultiIndex.from_tuples([(1, 2), (3, (4, 5))])
+    ser = Series([1, 2], index=mi)
+    result = ser.loc[(3, (4, 5))]
+    assert result == 2

env-llmeval/lib/python3.10/site-packages/pandas/tests/indexing/multiindex/test_multiindex.py

@@ -0,0 +1,235 @@
+import numpy as np
+import pytest
+
+import pandas._libs.index as libindex
+from pandas.errors import PerformanceWarning
+
+import pandas as pd
+from pandas import (
+    CategoricalDtype,
+    DataFrame,
+    Index,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+from pandas.core.arrays.boolean import BooleanDtype
+
+
+class TestMultiIndexBasic:
+    def test_multiindex_perf_warn(self):
+        df = DataFrame(
+            {
+                "jim": [0, 0, 1, 1],
+                "joe": ["x", "x", "z", "y"],
+                "jolie": np.random.default_rng(2).random(4),
+            }
+        ).set_index(["jim", "joe"])
+
+        with tm.assert_produces_warning(PerformanceWarning):
+            df.loc[(1, "z")]
+
+        df = df.iloc[[2, 1, 3, 0]]
+        with tm.assert_produces_warning(PerformanceWarning):
+            df.loc[(0,)]
+
+    @pytest.mark.parametrize("offset", [-5, 5])
+    def test_indexing_over_hashtable_size_cutoff(self, monkeypatch, offset):
+        size_cutoff = 20
+        n = size_cutoff + offset
+
+        with monkeypatch.context():
+            monkeypatch.setattr(libindex, "_SIZE_CUTOFF", size_cutoff)
+            s = Series(np.arange(n), MultiIndex.from_arrays((["a"] * n, np.arange(n))))
+
+            # hai it works!
+            assert s[("a", 5)] == 5
+            assert s[("a", 6)] == 6
+            assert s[("a", 7)] == 7
+
+    def test_multi_nan_indexing(self):
+        # GH 3588
+        df = DataFrame(
+            {
+                "a": ["R1", "R2", np.nan, "R4"],
+                "b": ["C1", "C2", "C3", "C4"],
+                "c": [10, 15, np.nan, 20],
+            }
+        )
+        result = df.set_index(["a", "b"], drop=False)
+        expected = DataFrame(
+            {
+                "a": ["R1", "R2", np.nan, "R4"],
+                "b": ["C1", "C2", "C3", "C4"],
+                "c": [10, 15, np.nan, 20],
+            },
+            index=[
+                Index(["R1", "R2", np.nan, "R4"], name="a"),
+                Index(["C1", "C2", "C3", "C4"], name="b"),
+            ],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_exclusive_nat_column_indexing(self):
+        # GH 38025
+        # test multi indexing when one column exclusively contains NaT values
+        df = DataFrame(
+            {
+                "a": [pd.NaT, pd.NaT, pd.NaT, pd.NaT],
+                "b": ["C1", "C2", "C3", "C4"],
+                "c": [10, 15, np.nan, 20],
+            }
+        )
+        df = df.set_index(["a", "b"])
+        expected = DataFrame(
+            {
+                "c": [10, 15, np.nan, 20],
+            },
+            index=[
+                Index([pd.NaT, pd.NaT, pd.NaT, pd.NaT], name="a"),
+                Index(["C1", "C2", "C3", "C4"], name="b"),
+            ],
+        )
+        tm.assert_frame_equal(df, expected)
+
+    def test_nested_tuples_duplicates(self):
+        # GH#30892
+
+        dti = pd.to_datetime(["20190101", "20190101", "20190102"])
+        idx = Index(["a", "a", "c"])
+        mi = MultiIndex.from_arrays([dti, idx], names=["index1", "index2"])
+
+        df = DataFrame({"c1": [1, 2, 3], "c2": [np.nan, np.nan, np.nan]}, index=mi)
+
+        expected = DataFrame({"c1": df["c1"], "c2": [1.0, 1.0, np.nan]}, index=mi)
+
+        df2 = df.copy(deep=True)
+        df2.loc[(dti[0], "a"), "c2"] = 1.0
+        tm.assert_frame_equal(df2, expected)
+
+        df3 = df.copy(deep=True)
+        df3.loc[[(dti[0], "a")], "c2"] = 1.0
+        tm.assert_frame_equal(df3, expected)
+
+    def test_multiindex_with_datatime_level_preserves_freq(self):
+        # https://github.com/pandas-dev/pandas/issues/35563
+        idx = Index(range(2), name="A")
+        dti = pd.date_range("2020-01-01", periods=7, freq="D", name="B")
+        mi = MultiIndex.from_product([idx, dti])
+        df = DataFrame(np.random.default_rng(2).standard_normal((14, 2)), index=mi)
+        result = df.loc[0].index
+        tm.assert_index_equal(result, dti)
+        assert result.freq == dti.freq
+
+    def test_multiindex_complex(self):
+        # GH#42145
+        complex_data = [1 + 2j, 4 - 3j, 10 - 1j]
+        non_complex_data = [3, 4, 5]
+        result = DataFrame(
+            {
+                "x": complex_data,
+                "y": non_complex_data,
+                "z": non_complex_data,
+            }
+        )
+        result.set_index(["x", "y"], inplace=True)
+        expected = DataFrame(
+            {"z": non_complex_data},
+            index=MultiIndex.from_arrays(
+                [complex_data, non_complex_data],
+                names=("x", "y"),
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_rename_multiindex_with_duplicates(self):
+        # GH 38015
+        mi = MultiIndex.from_tuples([("A", "cat"), ("B", "cat"), ("B", "cat")])
+        df = DataFrame(index=mi)
+        df = df.rename(index={"A": "Apple"}, level=0)
+
+        mi2 = MultiIndex.from_tuples([("Apple", "cat"), ("B", "cat"), ("B", "cat")])
+        expected = DataFrame(index=mi2)
+        tm.assert_frame_equal(df, expected)
+
+    def test_series_align_multiindex_with_nan_overlap_only(self):
+        # GH 38439
+        mi1 = MultiIndex.from_arrays([[81.0, np.nan], [np.nan, np.nan]])
+        mi2 = MultiIndex.from_arrays([[np.nan, 82.0], [np.nan, np.nan]])
+        ser1 = Series([1, 2], index=mi1)
+        ser2 = Series([1, 2], index=mi2)
+        result1, result2 = ser1.align(ser2)
+
+        mi = MultiIndex.from_arrays([[81.0, 82.0, np.nan], [np.nan, np.nan, np.nan]])
+        expected1 = Series([1.0, np.nan, 2.0], index=mi)
+        expected2 = Series([np.nan, 2.0, 1.0], index=mi)
+
+        tm.assert_series_equal(result1, expected1)
+        tm.assert_series_equal(result2, expected2)
+
+    def test_series_align_multiindex_with_nan(self):
+        # GH 38439
+        mi1 = MultiIndex.from_arrays([[81.0, np.nan], [np.nan, np.nan]])
+        mi2 = MultiIndex.from_arrays([[np.nan, 81.0], [np.nan, np.nan]])
+        ser1 = Series([1, 2], index=mi1)
+        ser2 = Series([1, 2], index=mi2)
+        result1, result2 = ser1.align(ser2)
+
+        mi = MultiIndex.from_arrays([[81.0, np.nan], [np.nan, np.nan]])
+        expected1 = Series([1, 2], index=mi)
+        expected2 = Series([2, 1], index=mi)
+
+        tm.assert_series_equal(result1, expected1)
+        tm.assert_series_equal(result2, expected2)
+
+    def test_nunique_smoke(self):
+        # GH 34019
+        n = DataFrame([[1, 2], [1, 2]]).set_index([0, 1]).index.nunique()
+        assert n == 1
+
+    def test_multiindex_repeated_keys(self):
+        # GH19414
+        tm.assert_series_equal(
+            Series([1, 2], MultiIndex.from_arrays([["a", "b"]])).loc[
+                ["a", "a", "b", "b"]
+            ],
+            Series([1, 1, 2, 2], MultiIndex.from_arrays([["a", "a", "b", "b"]])),
+        )
+
+    def test_multiindex_with_na_missing_key(self):
+        # GH46173
+        df = DataFrame.from_dict(
+            {
+                ("foo",): [1, 2, 3],
+                ("bar",): [5, 6, 7],
+                (None,): [8, 9, 0],
+            }
+        )
+        with pytest.raises(KeyError, match="missing_key"):
+            df[[("missing_key",)]]
+
+    def test_multiindex_dtype_preservation(self):
+        # GH51261
+        columns = MultiIndex.from_tuples([("A", "B")], names=["lvl1", "lvl2"])
+        df = DataFrame(["value"], columns=columns).astype("category")
+        df_no_multiindex = df["A"]
+        assert isinstance(df_no_multiindex["B"].dtype, CategoricalDtype)
+
+        # geopandas 1763 analogue
+        df = DataFrame(
+            [[1, 0], [0, 1]],
+            columns=[
+                ["foo", "foo"],
+                ["location", "location"],
+                ["x", "y"],
+            ],
+        ).assign(bools=Series([True, False], dtype="boolean"))
+        assert isinstance(df["bools"].dtype, BooleanDtype)
+
+    def test_multiindex_from_tuples_with_nan(self):
+        # GH#23578
+        result = MultiIndex.from_tuples([("a", "b", "c"), np.nan, ("d", "", "")])
+        expected = MultiIndex.from_tuples(
+            [("a", "b", "c"), (np.nan, np.nan, np.nan), ("d", "", "")]
+        )
+        tm.assert_index_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/indexing/multiindex/test_partial.py

@@ -0,0 +1,269 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    MultiIndex,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestMultiIndexPartial:
+    def test_getitem_partial_int(self):
+        # GH 12416
+        # with single item
+        l1 = [10, 20]
+        l2 = ["a", "b"]
+        df = DataFrame(index=range(2), columns=MultiIndex.from_product([l1, l2]))
+        expected = DataFrame(index=range(2), columns=l2)
+        result = df[20]
+        tm.assert_frame_equal(result, expected)
+
+        # with list
+        expected = DataFrame(
+            index=range(2), columns=MultiIndex.from_product([l1[1:], l2])
+        )
+        result = df[[20]]
+        tm.assert_frame_equal(result, expected)
+
+        # missing item:
+        with pytest.raises(KeyError, match="1"):
+            df[1]
+        with pytest.raises(KeyError, match=r"'\[1\] not in index'"):
+            df[[1]]
+
+    def test_series_slice_partial(self):
+        pass
+
+    def test_xs_partial(
+        self,
+        multiindex_dataframe_random_data,
+        multiindex_year_month_day_dataframe_random_data,
+    ):
+        frame = multiindex_dataframe_random_data
+        ymd = multiindex_year_month_day_dataframe_random_data
+        result = frame.xs("foo")
+        result2 = frame.loc["foo"]
+        expected = frame.T["foo"].T
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, result2)
+
+        result = ymd.xs((2000, 4))
+        expected = ymd.loc[2000, 4]
+        tm.assert_frame_equal(result, expected)
+
+        # ex from #1796
+        index = MultiIndex(
+            levels=[["foo", "bar"], ["one", "two"], [-1, 1]],
+            codes=[
+                [0, 0, 0, 0, 1, 1, 1, 1],
+                [0, 0, 1, 1, 0, 0, 1, 1],
+                [0, 1, 0, 1, 0, 1, 0, 1],
+            ],
+        )
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((8, 4)),
+            index=index,
+            columns=list("abcd"),
+        )
+
+        result = df.xs(("foo", "one"))
+        expected = df.loc["foo", "one"]
+        tm.assert_frame_equal(result, expected)
+
+    def test_getitem_partial(self, multiindex_year_month_day_dataframe_random_data):
+        ymd = multiindex_year_month_day_dataframe_random_data
+        ymd = ymd.T
+        result = ymd[2000, 2]
+
+        expected = ymd.reindex(columns=ymd.columns[ymd.columns.codes[1] == 1])
+        expected.columns = expected.columns.droplevel(0).droplevel(0)
+        tm.assert_frame_equal(result, expected)
+
+    def test_fancy_slice_partial(
+        self,
+        multiindex_dataframe_random_data,
+        multiindex_year_month_day_dataframe_random_data,
+    ):
+        frame = multiindex_dataframe_random_data
+        result = frame.loc["bar":"baz"]
+        expected = frame[3:7]
+        tm.assert_frame_equal(result, expected)
+
+        ymd = multiindex_year_month_day_dataframe_random_data
+        result = ymd.loc[(2000, 2):(2000, 4)]
+        lev = ymd.index.codes[1]
+        expected = ymd[(lev >= 1) & (lev <= 3)]
+        tm.assert_frame_equal(result, expected)
+
+    def test_getitem_partial_column_select(self):
+        idx = MultiIndex(
+            codes=[[0, 0, 0], [0, 1, 1], [1, 0, 1]],
+            levels=[["a", "b"], ["x", "y"], ["p", "q"]],
+        )
+        df = DataFrame(np.random.default_rng(2).random((3, 2)), index=idx)
+
+        result = df.loc[("a", "y"), :]
+        expected = df.loc[("a", "y")]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.loc[("a", "y"), [1, 0]]
+        expected = df.loc[("a", "y")][[1, 0]]
+        tm.assert_frame_equal(result, expected)
+
+        with pytest.raises(KeyError, match=r"\('a', 'foo'\)"):
+            df.loc[("a", "foo"), :]
+
+    # TODO(ArrayManager) rewrite test to not use .values
+    # exp.loc[2000, 4].values[:] select multiple columns -> .values is not a view
+    @td.skip_array_manager_invalid_test
+    def test_partial_set(
+        self,
+        multiindex_year_month_day_dataframe_random_data,
+        using_copy_on_write,
+        warn_copy_on_write,
+    ):
+        # GH #397
+        ymd = multiindex_year_month_day_dataframe_random_data
+        df = ymd.copy()
+        exp = ymd.copy()
+        df.loc[2000, 4] = 0
+        exp.iloc[65:85] = 0
+        tm.assert_frame_equal(df, exp)
+
+        if using_copy_on_write:
+            with tm.raises_chained_assignment_error():
+                df["A"].loc[2000, 4] = 1
+            df.loc[(2000, 4), "A"] = 1
+        else:
+            with tm.raises_chained_assignment_error():
+                df["A"].loc[2000, 4] = 1
+        exp.iloc[65:85, 0] = 1
+        tm.assert_frame_equal(df, exp)
+
+        df.loc[2000] = 5
+        exp.iloc[:100] = 5
+        tm.assert_frame_equal(df, exp)
+
+        # this works...for now
+        with tm.raises_chained_assignment_error():
+            df["A"].iloc[14] = 5
+        if using_copy_on_write:
+            assert df["A"].iloc[14] == exp["A"].iloc[14]
+        else:
+            assert df["A"].iloc[14] == 5
+
+    @pytest.mark.parametrize("dtype", [int, float])
+    def test_getitem_intkey_leading_level(
+        self, multiindex_year_month_day_dataframe_random_data, dtype
+    ):
+        # GH#33355 dont fall-back to positional when leading level is int
+        ymd = multiindex_year_month_day_dataframe_random_data
+        levels = ymd.index.levels
+        ymd.index = ymd.index.set_levels([levels[0].astype(dtype)] + levels[1:])
+        ser = ymd["A"]
+        mi = ser.index
+        assert isinstance(mi, MultiIndex)
+        if dtype is int:
+            assert mi.levels[0].dtype == np.dtype(int)
+        else:
+            assert mi.levels[0].dtype == np.float64
+
+        assert 14 not in mi.levels[0]
+        assert not mi.levels[0]._should_fallback_to_positional
+        assert not mi._should_fallback_to_positional
+
+        with pytest.raises(KeyError, match="14"):
+            ser[14]
+
+    # ---------------------------------------------------------------------
+
+    def test_setitem_multiple_partial(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+        expected = frame.copy()
+        result = frame.copy()
+        result.loc[["foo", "bar"]] = 0
+        expected.loc["foo"] = 0
+        expected.loc["bar"] = 0
+        tm.assert_frame_equal(result, expected)
+
+        expected = frame.copy()
+        result = frame.copy()
+        result.loc["foo":"bar"] = 0
+        expected.loc["foo"] = 0
+        expected.loc["bar"] = 0
+        tm.assert_frame_equal(result, expected)
+
+        expected = frame["A"].copy()
+        result = frame["A"].copy()
+        result.loc[["foo", "bar"]] = 0
+        expected.loc["foo"] = 0
+        expected.loc["bar"] = 0
+        tm.assert_series_equal(result, expected)
+
+        expected = frame["A"].copy()
+        result = frame["A"].copy()
+        result.loc["foo":"bar"] = 0
+        expected.loc["foo"] = 0
+        expected.loc["bar"] = 0
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "indexer, exp_idx, exp_values",
+        [
+            (
+                slice("2019-2", None),
+                DatetimeIndex(["2019-02-01"], dtype="M8[ns]"),
+                [2, 3],
+            ),
+            (
+                slice(None, "2019-2"),
+                date_range("2019", periods=2, freq="MS"),
+                [0, 1, 2, 3],
+            ),
+        ],
+    )
+    def test_partial_getitem_loc_datetime(self, indexer, exp_idx, exp_values):
+        # GH: 25165
+        date_idx = date_range("2019", periods=2, freq="MS")
+        df = DataFrame(
+            list(range(4)),
+            index=MultiIndex.from_product([date_idx, [0, 1]], names=["x", "y"]),
+        )
+        expected = DataFrame(
+            exp_values,
+            index=MultiIndex.from_product([exp_idx, [0, 1]], names=["x", "y"]),
+        )
+        result = df[indexer]
+        tm.assert_frame_equal(result, expected)
+        result = df.loc[indexer]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.loc(axis=0)[indexer]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.loc[indexer, :]
+        tm.assert_frame_equal(result, expected)
+
+        df2 = df.swaplevel(0, 1).sort_index()
+        expected = expected.swaplevel(0, 1).sort_index()
+
+        result = df2.loc[:, indexer, :]
+        tm.assert_frame_equal(result, expected)
+
+
+def test_loc_getitem_partial_both_axis():
+    # gh-12660
+    iterables = [["a", "b"], [2, 1]]
+    columns = MultiIndex.from_product(iterables, names=["col1", "col2"])
+    rows = MultiIndex.from_product(iterables, names=["row1", "row2"])
+    df = DataFrame(
+        np.random.default_rng(2).standard_normal((4, 4)), index=rows, columns=columns
+    )
+    expected = df.iloc[:2, 2:].droplevel("row1").droplevel("col1", axis=1)
+    result = df.loc["a", "b"]
+    tm.assert_frame_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/indexing/multiindex/test_setitem.py

@@ -0,0 +1,589 @@
+import numpy as np
+import pytest
+
+from pandas.errors import SettingWithCopyError
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    Series,
+    date_range,
+    isna,
+    notna,
+)
+import pandas._testing as tm
+
+
+def assert_equal(a, b):
+    assert a == b
+
+
+class TestMultiIndexSetItem:
+    def check(self, target, indexers, value, compare_fn=assert_equal, expected=None):
+        target.loc[indexers] = value
+        result = target.loc[indexers]
+        if expected is None:
+            expected = value
+        compare_fn(result, expected)
+
+    def test_setitem_multiindex(self):
+        # GH#7190
+        cols = ["A", "w", "l", "a", "x", "X", "d", "profit"]
+        index = MultiIndex.from_product(
+            [np.arange(0, 100), np.arange(0, 80)], names=["time", "firm"]
+        )
+        t, n = 0, 2
+
+        df = DataFrame(
+            np.nan,
+            columns=cols,
+            index=index,
+        )
+        self.check(target=df, indexers=((t, n), "X"), value=0)
+
+        df = DataFrame(-999, columns=cols, index=index)
+        self.check(target=df, indexers=((t, n), "X"), value=1)
+
+        df = DataFrame(columns=cols, index=index)
+        self.check(target=df, indexers=((t, n), "X"), value=2)
+
+        # gh-7218: assigning with 0-dim arrays
+        df = DataFrame(-999, columns=cols, index=index)
+        self.check(
+            target=df,
+            indexers=((t, n), "X"),
+            value=np.array(3),
+            expected=3,
+        )
+
+    def test_setitem_multiindex2(self):
+        # GH#5206
+        df = DataFrame(
+            np.arange(25).reshape(5, 5), columns="A,B,C,D,E".split(","), dtype=float
+        )
+        df["F"] = 99
+        row_selection = df["A"] % 2 == 0
+        col_selection = ["B", "C"]
+        df.loc[row_selection, col_selection] = df["F"]
+        output = DataFrame(99.0, index=[0, 2, 4], columns=["B", "C"])
+        tm.assert_frame_equal(df.loc[row_selection, col_selection], output)
+        self.check(
+            target=df,
+            indexers=(row_selection, col_selection),
+            value=df["F"],
+            compare_fn=tm.assert_frame_equal,
+            expected=output,
+        )
+
+    def test_setitem_multiindex3(self):
+        # GH#11372
+        idx = MultiIndex.from_product(
+            [["A", "B", "C"], date_range("2015-01-01", "2015-04-01", freq="MS")]
+        )
+        cols = MultiIndex.from_product(
+            [["foo", "bar"], date_range("2016-01-01", "2016-02-01", freq="MS")]
+        )
+
+        df = DataFrame(
+            np.random.default_rng(2).random((12, 4)), index=idx, columns=cols
+        )
+
+        subidx = MultiIndex.from_arrays(
+            [["A", "A"], date_range("2015-01-01", "2015-02-01", freq="MS")]
+        )
+        subcols = MultiIndex.from_arrays(
+            [["foo", "foo"], date_range("2016-01-01", "2016-02-01", freq="MS")]
+        )
+
+        vals = DataFrame(
+            np.random.default_rng(2).random((2, 2)), index=subidx, columns=subcols
+        )
+        self.check(
+            target=df,
+            indexers=(subidx, subcols),
+            value=vals,
+            compare_fn=tm.assert_frame_equal,
+        )
+        # set all columns
+        vals = DataFrame(
+            np.random.default_rng(2).random((2, 4)), index=subidx, columns=cols
+        )
+        self.check(
+            target=df,
+            indexers=(subidx, slice(None, None, None)),
+            value=vals,
+            compare_fn=tm.assert_frame_equal,
+        )
+        # identity
+        copy = df.copy()
+        self.check(
+            target=df,
+            indexers=(df.index, df.columns),
+            value=df,
+            compare_fn=tm.assert_frame_equal,
+            expected=copy,
+        )
+
+    # TODO(ArrayManager) df.loc["bar"] *= 2 doesn't raise an error but results in
+    # all NaNs -> doesn't work in the "split" path (also for BlockManager actually)
+    @td.skip_array_manager_not_yet_implemented
+    def test_multiindex_setitem(self):
+        # GH 3738
+        # setting with a multi-index right hand side
+        arrays = [
+            np.array(["bar", "bar", "baz", "qux", "qux", "bar"]),
+            np.array(["one", "two", "one", "one", "two", "one"]),
+            np.arange(0, 6, 1),
+        ]
+
+        df_orig = DataFrame(
+            np.random.default_rng(2).standard_normal((6, 3)),
+            index=arrays,
+            columns=["A", "B", "C"],
+        ).sort_index()
+
+        expected = df_orig.loc[["bar"]] * 2
+        df = df_orig.copy()
+        df.loc[["bar"]] *= 2
+        tm.assert_frame_equal(df.loc[["bar"]], expected)
+
+        # raise because these have differing levels
+        msg = "cannot align on a multi-index with out specifying the join levels"
+        with pytest.raises(TypeError, match=msg):
+            df.loc["bar"] *= 2
+
+    def test_multiindex_setitem2(self):
+        # from SO
+        # https://stackoverflow.com/questions/24572040/pandas-access-the-level-of-multiindex-for-inplace-operation
+        df_orig = DataFrame.from_dict(
+            {
+                "price": {
+                    ("DE", "Coal", "Stock"): 2,
+                    ("DE", "Gas", "Stock"): 4,
+                    ("DE", "Elec", "Demand"): 1,
+                    ("FR", "Gas", "Stock"): 5,
+                    ("FR", "Solar", "SupIm"): 0,
+                    ("FR", "Wind", "SupIm"): 0,
+                }
+            }
+        )
+        df_orig.index = MultiIndex.from_tuples(
+            df_orig.index, names=["Sit", "Com", "Type"]
+        )
+
+        expected = df_orig.copy()
+        expected.iloc[[0, 1, 3]] *= 2
+
+        idx = pd.IndexSlice
+        df = df_orig.copy()
+        df.loc[idx[:, :, "Stock"], :] *= 2
+        tm.assert_frame_equal(df, expected)
+
+        df = df_orig.copy()
+        df.loc[idx[:, :, "Stock"], "price"] *= 2
+        tm.assert_frame_equal(df, expected)
+
+    def test_multiindex_assignment(self):
+        # GH3777 part 2
+
+        # mixed dtype
+        df = DataFrame(
+            np.random.default_rng(2).integers(5, 10, size=9).reshape(3, 3),
+            columns=list("abc"),
+            index=[[4, 4, 8], [8, 10, 12]],
+        )
+        df["d"] = np.nan
+        arr = np.array([0.0, 1.0])
+
+        df.loc[4, "d"] = arr
+        tm.assert_series_equal(df.loc[4, "d"], Series(arr, index=[8, 10], name="d"))
+
+    def test_multiindex_assignment_single_dtype(
+        self, using_copy_on_write, warn_copy_on_write
+    ):
+        # GH3777 part 2b
+        # single dtype
+        arr = np.array([0.0, 1.0])
+
+        df = DataFrame(
+            np.random.default_rng(2).integers(5, 10, size=9).reshape(3, 3),
+            columns=list("abc"),
+            index=[[4, 4, 8], [8, 10, 12]],
+            dtype=np.int64,
+        )
+        view = df["c"].iloc[:2].values
+
+        # arr can be losslessly cast to int, so this setitem is inplace
+        # INFO(CoW-warn) this does not warn because we directly took .values
+        # above, so no reference to a pandas object is alive for `view`
+        df.loc[4, "c"] = arr
+        exp = Series(arr, index=[8, 10], name="c", dtype="int64")
+        result = df.loc[4, "c"]
+        tm.assert_series_equal(result, exp)
+
+        # extra check for inplace-ness
+        if not using_copy_on_write:
+            tm.assert_numpy_array_equal(view, exp.values)
+
+        # arr + 0.5 cannot be cast losslessly to int, so we upcast
+        with tm.assert_produces_warning(
+            FutureWarning, match="item of incompatible dtype"
+        ):
+            df.loc[4, "c"] = arr + 0.5
+        result = df.loc[4, "c"]
+        exp = exp + 0.5
+        tm.assert_series_equal(result, exp)
+
+        # scalar ok
+        with tm.assert_cow_warning(warn_copy_on_write):
+            df.loc[4, "c"] = 10
+        exp = Series(10, index=[8, 10], name="c", dtype="float64")
+        tm.assert_series_equal(df.loc[4, "c"], exp)
+
+        # invalid assignments
+        msg = "Must have equal len keys and value when setting with an iterable"
+        with pytest.raises(ValueError, match=msg):
+            df.loc[4, "c"] = [0, 1, 2, 3]
+
+        with pytest.raises(ValueError, match=msg):
+            df.loc[4, "c"] = [0]
+
+        # But with a length-1 listlike column indexer this behaves like
+        #  `df.loc[4, "c"] = 0
+        with tm.assert_cow_warning(warn_copy_on_write):
+            df.loc[4, ["c"]] = [0]
+        assert (df.loc[4, "c"] == 0).all()
+
+    def test_groupby_example(self):
+        # groupby example
+        NUM_ROWS = 100
+        NUM_COLS = 10
+        col_names = ["A" + num for num in map(str, np.arange(NUM_COLS).tolist())]
+        index_cols = col_names[:5]
+
+        df = DataFrame(
+            np.random.default_rng(2).integers(5, size=(NUM_ROWS, NUM_COLS)),
+            dtype=np.int64,
+            columns=col_names,
+        )
+        df = df.set_index(index_cols).sort_index()
+        grp = df.groupby(level=index_cols[:4])
+        df["new_col"] = np.nan
+
+        # we are actually operating on a copy here
+        # but in this case, that's ok
+        for name, df2 in grp:
+            new_vals = np.arange(df2.shape[0])
+            df.loc[name, "new_col"] = new_vals
+
+    def test_series_setitem(
+        self, multiindex_year_month_day_dataframe_random_data, warn_copy_on_write
+    ):
+        ymd = multiindex_year_month_day_dataframe_random_data
+        s = ymd["A"]
+
+        with tm.assert_cow_warning(warn_copy_on_write):
+            s[2000, 3] = np.nan
+        assert isna(s.values[42:65]).all()
+        assert notna(s.values[:42]).all()
+        assert notna(s.values[65:]).all()
+
+        with tm.assert_cow_warning(warn_copy_on_write):
+            s[2000, 3, 10] = np.nan
+        assert isna(s.iloc[49])
+
+        with pytest.raises(KeyError, match="49"):
+            # GH#33355 dont fall-back to positional when leading level is int
+            s[49]
+
+    def test_frame_getitem_setitem_boolean(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+        df = frame.T.copy()
+        values = df.values.copy()
+
+        result = df[df > 0]
+        expected = df.where(df > 0)
+        tm.assert_frame_equal(result, expected)
+
+        df[df > 0] = 5
+        values[values > 0] = 5
+        tm.assert_almost_equal(df.values, values)
+
+        df[df == 5] = 0
+        values[values == 5] = 0
+        tm.assert_almost_equal(df.values, values)
+
+        # a df that needs alignment first
+        df[df[:-1] < 0] = 2
+        np.putmask(values[:-1], values[:-1] < 0, 2)
+        tm.assert_almost_equal(df.values, values)
+
+        with pytest.raises(TypeError, match="boolean values only"):
+            df[df * 0] = 2
+
+    def test_frame_getitem_setitem_multislice(self):
+        levels = [["t1", "t2"], ["a", "b", "c"]]
+        codes = [[0, 0, 0, 1, 1], [0, 1, 2, 0, 1]]
+        midx = MultiIndex(codes=codes, levels=levels, names=[None, "id"])
+        df = DataFrame({"value": [1, 2, 3, 7, 8]}, index=midx)
+
+        result = df.loc[:, "value"]
+        tm.assert_series_equal(df["value"], result)
+
+        result = df.loc[df.index[1:3], "value"]
+        tm.assert_series_equal(df["value"][1:3], result)
+
+        result = df.loc[:, :]
+        tm.assert_frame_equal(df, result)
+
+        result = df
+        df.loc[:, "value"] = 10
+        result["value"] = 10
+        tm.assert_frame_equal(df, result)
+
+        df.loc[:, :] = 10
+        tm.assert_frame_equal(df, result)
+
+    def test_frame_setitem_multi_column(self):
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 4)),
+            columns=[["a", "a", "b", "b"], [0, 1, 0, 1]],
+        )
+
+        cp = df.copy()
+        cp["a"] = cp["b"]
+        tm.assert_frame_equal(cp["a"], cp["b"])
+
+        # set with ndarray
+        cp = df.copy()
+        cp["a"] = cp["b"].values
+        tm.assert_frame_equal(cp["a"], cp["b"])
+
+    def test_frame_setitem_multi_column2(self):
+        # ---------------------------------------
+        # GH#1803
+        columns = MultiIndex.from_tuples([("A", "1"), ("A", "2"), ("B", "1")])
+        df = DataFrame(index=[1, 3, 5], columns=columns)
+
+        # Works, but adds a column instead of updating the two existing ones
+        df["A"] = 0.0  # Doesn't work
+        assert (df["A"].values == 0).all()
+
+        # it broadcasts
+        df["B", "1"] = [1, 2, 3]
+        df["A"] = df["B", "1"]
+
+        sliced_a1 = df["A", "1"]
+        sliced_a2 = df["A", "2"]
+        sliced_b1 = df["B", "1"]
+        tm.assert_series_equal(sliced_a1, sliced_b1, check_names=False)
+        tm.assert_series_equal(sliced_a2, sliced_b1, check_names=False)
+        assert sliced_a1.name == ("A", "1")
+        assert sliced_a2.name == ("A", "2")
+        assert sliced_b1.name == ("B", "1")
+
+    def test_loc_getitem_tuple_plus_columns(
+        self, multiindex_year_month_day_dataframe_random_data
+    ):
+        # GH #1013
+        ymd = multiindex_year_month_day_dataframe_random_data
+        df = ymd[:5]
+
+        result = df.loc[(2000, 1, 6), ["A", "B", "C"]]
+        expected = df.loc[2000, 1, 6][["A", "B", "C"]]
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.filterwarnings("ignore:Setting a value on a view:FutureWarning")
+    def test_loc_getitem_setitem_slice_integers(self, frame_or_series):
+        index = MultiIndex(
+            levels=[[0, 1, 2], [0, 2]], codes=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]]
+        )
+
+        obj = DataFrame(
+            np.random.default_rng(2).standard_normal((len(index), 4)),
+            index=index,
+            columns=["a", "b", "c", "d"],
+        )
+        obj = tm.get_obj(obj, frame_or_series)
+
+        res = obj.loc[1:2]
+        exp = obj.reindex(obj.index[2:])
+        tm.assert_equal(res, exp)
+
+        obj.loc[1:2] = 7
+        assert (obj.loc[1:2] == 7).values.all()
+
+    def test_setitem_change_dtype(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+        dft = frame.T
+        s = dft["foo", "two"]
+        dft["foo", "two"] = s > s.median()
+        tm.assert_series_equal(dft["foo", "two"], s > s.median())
+        # assert isinstance(dft._data.blocks[1].items, MultiIndex)
+
+        reindexed = dft.reindex(columns=[("foo", "two")])
+        tm.assert_series_equal(reindexed["foo", "two"], s > s.median())
+
+    def test_set_column_scalar_with_loc(
+        self, multiindex_dataframe_random_data, using_copy_on_write, warn_copy_on_write
+    ):
+        frame = multiindex_dataframe_random_data
+        subset = frame.index[[1, 4, 5]]
+
+        frame.loc[subset] = 99
+        assert (frame.loc[subset].values == 99).all()
+
+        frame_original = frame.copy()
+        col = frame["B"]
+        with tm.assert_cow_warning(warn_copy_on_write):
+            col[subset] = 97
+        if using_copy_on_write:
+            # chained setitem doesn't work with CoW
+            tm.assert_frame_equal(frame, frame_original)
+        else:
+            assert (frame.loc[subset, "B"] == 97).all()
+
+    def test_nonunique_assignment_1750(self):
+        df = DataFrame(
+            [[1, 1, "x", "X"], [1, 1, "y", "Y"], [1, 2, "z", "Z"]], columns=list("ABCD")
+        )
+
+        df = df.set_index(["A", "B"])
+        mi = MultiIndex.from_tuples([(1, 1)])
+
+        df.loc[mi, "C"] = "_"
+
+        assert (df.xs((1, 1))["C"] == "_").all()
+
+    def test_astype_assignment_with_dups(self):
+        # GH 4686
+        # assignment with dups that has a dtype change
+        cols = MultiIndex.from_tuples([("A", "1"), ("B", "1"), ("A", "2")])
+        df = DataFrame(np.arange(3).reshape((1, 3)), columns=cols, dtype=object)
+        index = df.index.copy()
+
+        df["A"] = df["A"].astype(np.float64)
+        tm.assert_index_equal(df.index, index)
+
+    def test_setitem_nonmonotonic(self):
+        # https://github.com/pandas-dev/pandas/issues/31449
+        index = MultiIndex.from_tuples(
+            [("a", "c"), ("b", "x"), ("a", "d")], names=["l1", "l2"]
+        )
+        df = DataFrame(data=[0, 1, 2], index=index, columns=["e"])
+        df.loc["a", "e"] = np.arange(99, 101, dtype="int64")
+        expected = DataFrame({"e": [99, 1, 100]}, index=index)
+        tm.assert_frame_equal(df, expected)
+
+
+class TestSetitemWithExpansionMultiIndex:
+    def test_setitem_new_column_mixed_depth(self):
+        arrays = [
+            ["a", "top", "top", "routine1", "routine1", "routine2"],
+            ["", "OD", "OD", "result1", "result2", "result1"],
+            ["", "wx", "wy", "", "", ""],
+        ]
+
+        tuples = sorted(zip(*arrays))
+        index = MultiIndex.from_tuples(tuples)
+        df = DataFrame(np.random.default_rng(2).standard_normal((4, 6)), columns=index)
+
+        result = df.copy()
+        expected = df.copy()
+        result["b"] = [1, 2, 3, 4]
+        expected["b", "", ""] = [1, 2, 3, 4]
+        tm.assert_frame_equal(result, expected)
+
+    def test_setitem_new_column_all_na(self):
+        # GH#1534
+        mix = MultiIndex.from_tuples([("1a", "2a"), ("1a", "2b"), ("1a", "2c")])
+        df = DataFrame([[1, 2], [3, 4], [5, 6]], index=mix)
+        s = Series({(1, 1): 1, (1, 2): 2})
+        df["new"] = s
+        assert df["new"].isna().all()
+
+    def test_setitem_enlargement_keep_index_names(self):
+        # GH#53053
+        mi = MultiIndex.from_tuples([(1, 2, 3)], names=["i1", "i2", "i3"])
+        df = DataFrame(data=[[10, 20, 30]], index=mi, columns=["A", "B", "C"])
+        df.loc[(0, 0, 0)] = df.loc[(1, 2, 3)]
+        mi_expected = MultiIndex.from_tuples(
+            [(1, 2, 3), (0, 0, 0)], names=["i1", "i2", "i3"]
+        )
+        expected = DataFrame(
+            data=[[10, 20, 30], [10, 20, 30]],
+            index=mi_expected,
+            columns=["A", "B", "C"],
+        )
+        tm.assert_frame_equal(df, expected)
+
+
+@td.skip_array_manager_invalid_test  # df["foo"] select multiple columns -> .values
+# is not a view
+def test_frame_setitem_view_direct(
+    multiindex_dataframe_random_data, using_copy_on_write
+):
+    # this works because we are modifying the underlying array
+    # really a no-no
+    df = multiindex_dataframe_random_data.T
+    if using_copy_on_write:
+        with pytest.raises(ValueError, match="read-only"):
+            df["foo"].values[:] = 0
+        assert (df["foo"].values != 0).all()
+    else:
+        df["foo"].values[:] = 0
+        assert (df["foo"].values == 0).all()
+
+
+def test_frame_setitem_copy_raises(
+    multiindex_dataframe_random_data, using_copy_on_write, warn_copy_on_write
+):
+    # will raise/warn as its chained assignment
+    df = multiindex_dataframe_random_data.T
+    if using_copy_on_write or warn_copy_on_write:
+        with tm.raises_chained_assignment_error():
+            df["foo"]["one"] = 2
+    else:
+        msg = "A value is trying to be set on a copy of a slice from a DataFrame"
+        with pytest.raises(SettingWithCopyError, match=msg):
+            with tm.raises_chained_assignment_error():
+                df["foo"]["one"] = 2
+
+
+def test_frame_setitem_copy_no_write(
+    multiindex_dataframe_random_data, using_copy_on_write, warn_copy_on_write
+):
+    frame = multiindex_dataframe_random_data.T
+    expected = frame
+    df = frame.copy()
+    if using_copy_on_write or warn_copy_on_write:
+        with tm.raises_chained_assignment_error():
+            df["foo"]["one"] = 2
+    else:
+        msg = "A value is trying to be set on a copy of a slice from a DataFrame"
+        with pytest.raises(SettingWithCopyError, match=msg):
+            with tm.raises_chained_assignment_error():
+                df["foo"]["one"] = 2
+
+    result = df
+    tm.assert_frame_equal(result, expected)
+
+
+def test_frame_setitem_partial_multiindex():
+    # GH 54875
+    df = DataFrame(
+        {
+            "a": [1, 2, 3],
+            "b": [3, 4, 5],
+            "c": 6,
+            "d": 7,
+        }
+    ).set_index(["a", "b", "c"])
+    ser = Series(8, index=df.index.droplevel("c"))
+    result = df.copy()
+    result["d"] = ser
+    expected = df.copy()
+    expected["d"] = 8
+    tm.assert_frame_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/libs/test_hashtable.py

@@ -0,0 +1,748 @@
+from collections.abc import Generator
+from contextlib import contextmanager
+import re
+import struct
+import tracemalloc
+
+import numpy as np
+import pytest
+
+from pandas._libs import hashtable as ht
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.algorithms import isin
+
+
+@contextmanager
+def activated_tracemalloc() -> Generator[None, None, None]:
+    tracemalloc.start()
+    try:
+        yield
+    finally:
+        tracemalloc.stop()
+
+
+def get_allocated_khash_memory():
+    snapshot = tracemalloc.take_snapshot()
+    snapshot = snapshot.filter_traces(
+        (tracemalloc.DomainFilter(True, ht.get_hashtable_trace_domain()),)
+    )
+    return sum(x.size for x in snapshot.traces)
+
+
+@pytest.mark.parametrize(
+    "table_type, dtype",
+    [
+        (ht.PyObjectHashTable, np.object_),
+        (ht.Complex128HashTable, np.complex128),
+        (ht.Int64HashTable, np.int64),
+        (ht.UInt64HashTable, np.uint64),
+        (ht.Float64HashTable, np.float64),
+        (ht.Complex64HashTable, np.complex64),
+        (ht.Int32HashTable, np.int32),
+        (ht.UInt32HashTable, np.uint32),
+        (ht.Float32HashTable, np.float32),
+        (ht.Int16HashTable, np.int16),
+        (ht.UInt16HashTable, np.uint16),
+        (ht.Int8HashTable, np.int8),
+        (ht.UInt8HashTable, np.uint8),
+        (ht.IntpHashTable, np.intp),
+    ],
+)
+class TestHashTable:
+    def test_get_set_contains_len(self, table_type, dtype):
+        index = 5
+        table = table_type(55)
+        assert len(table) == 0
+        assert index not in table
+
+        table.set_item(index, 42)
+        assert len(table) == 1
+        assert index in table
+        assert table.get_item(index) == 42
+
+        table.set_item(index + 1, 41)
+        assert index in table
+        assert index + 1 in table
+        assert len(table) == 2
+        assert table.get_item(index) == 42
+        assert table.get_item(index + 1) == 41
+
+        table.set_item(index, 21)
+        assert index in table
+        assert index + 1 in table
+        assert len(table) == 2
+        assert table.get_item(index) == 21
+        assert table.get_item(index + 1) == 41
+        assert index + 2 not in table
+
+        table.set_item(index + 1, 21)
+        assert index in table
+        assert index + 1 in table
+        assert len(table) == 2
+        assert table.get_item(index) == 21
+        assert table.get_item(index + 1) == 21
+
+        with pytest.raises(KeyError, match=str(index + 2)):
+            table.get_item(index + 2)
+
+    def test_get_set_contains_len_mask(self, table_type, dtype):
+        if table_type == ht.PyObjectHashTable:
+            pytest.skip("Mask not supported for object")
+        index = 5
+        table = table_type(55, uses_mask=True)
+        assert len(table) == 0
+        assert index not in table
+
+        table.set_item(index, 42)
+        assert len(table) == 1
+        assert index in table
+        assert table.get_item(index) == 42
+        with pytest.raises(KeyError, match="NA"):
+            table.get_na()
+
+        table.set_item(index + 1, 41)
+        table.set_na(41)
+        assert pd.NA in table
+        assert index in table
+        assert index + 1 in table
+        assert len(table) == 3
+        assert table.get_item(index) == 42
+        assert table.get_item(index + 1) == 41
+        assert table.get_na() == 41
+
+        table.set_na(21)
+        assert index in table
+        assert index + 1 in table
+        assert len(table) == 3
+        assert table.get_item(index + 1) == 41
+        assert table.get_na() == 21
+        assert index + 2 not in table
+
+        with pytest.raises(KeyError, match=str(index + 2)):
+            table.get_item(index + 2)
+
+    def test_map_keys_to_values(self, table_type, dtype, writable):
+        # only Int64HashTable has this method
+        if table_type == ht.Int64HashTable:
+            N = 77
+            table = table_type()
+            keys = np.arange(N).astype(dtype)
+            vals = np.arange(N).astype(np.int64) + N
+            keys.flags.writeable = writable
+            vals.flags.writeable = writable
+            table.map_keys_to_values(keys, vals)
+            for i in range(N):
+                assert table.get_item(keys[i]) == i + N
+
+    def test_map_locations(self, table_type, dtype, writable):
+        N = 8
+        table = table_type()
+        keys = (np.arange(N) + N).astype(dtype)
+        keys.flags.writeable = writable
+        table.map_locations(keys)
+        for i in range(N):
+            assert table.get_item(keys[i]) == i
+
+    def test_map_locations_mask(self, table_type, dtype, writable):
+        if table_type == ht.PyObjectHashTable:
+            pytest.skip("Mask not supported for object")
+        N = 3
+        table = table_type(uses_mask=True)
+        keys = (np.arange(N) + N).astype(dtype)
+        keys.flags.writeable = writable
+        table.map_locations(keys, np.array([False, False, True]))
+        for i in range(N - 1):
+            assert table.get_item(keys[i]) == i
+
+        with pytest.raises(KeyError, match=re.escape(str(keys[N - 1]))):
+            table.get_item(keys[N - 1])
+
+        assert table.get_na() == 2
+
+    def test_lookup(self, table_type, dtype, writable):
+        N = 3
+        table = table_type()
+        keys = (np.arange(N) + N).astype(dtype)
+        keys.flags.writeable = writable
+        table.map_locations(keys)
+        result = table.lookup(keys)
+        expected = np.arange(N)
+        tm.assert_numpy_array_equal(result.astype(np.int64), expected.astype(np.int64))
+
+    def test_lookup_wrong(self, table_type, dtype):
+        if dtype in (np.int8, np.uint8):
+            N = 100
+        else:
+            N = 512
+        table = table_type()
+        keys = (np.arange(N) + N).astype(dtype)
+        table.map_locations(keys)
+        wrong_keys = np.arange(N).astype(dtype)
+        result = table.lookup(wrong_keys)
+        assert np.all(result == -1)
+
+    def test_lookup_mask(self, table_type, dtype, writable):
+        if table_type == ht.PyObjectHashTable:
+            pytest.skip("Mask not supported for object")
+        N = 3
+        table = table_type(uses_mask=True)
+        keys = (np.arange(N) + N).astype(dtype)
+        mask = np.array([False, True, False])
+        keys.flags.writeable = writable
+        table.map_locations(keys, mask)
+        result = table.lookup(keys, mask)
+        expected = np.arange(N)
+        tm.assert_numpy_array_equal(result.astype(np.int64), expected.astype(np.int64))
+
+        result = table.lookup(np.array([1 + N]).astype(dtype), np.array([False]))
+        tm.assert_numpy_array_equal(
+            result.astype(np.int64), np.array([-1], dtype=np.int64)
+        )
+
+    def test_unique(self, table_type, dtype, writable):
+        if dtype in (np.int8, np.uint8):
+            N = 88
+        else:
+            N = 1000
+        table = table_type()
+        expected = (np.arange(N) + N).astype(dtype)
+        keys = np.repeat(expected, 5)
+        keys.flags.writeable = writable
+        unique = table.unique(keys)
+        tm.assert_numpy_array_equal(unique, expected)
+
+    def test_tracemalloc_works(self, table_type, dtype):
+        if dtype in (np.int8, np.uint8):
+            N = 256
+        else:
+            N = 30000
+        keys = np.arange(N).astype(dtype)
+        with activated_tracemalloc():
+            table = table_type()
+            table.map_locations(keys)
+            used = get_allocated_khash_memory()
+            my_size = table.sizeof()
+            assert used == my_size
+            del table
+            assert get_allocated_khash_memory() == 0
+
+    def test_tracemalloc_for_empty(self, table_type, dtype):
+        with activated_tracemalloc():
+            table = table_type()
+            used = get_allocated_khash_memory()
+            my_size = table.sizeof()
+            assert used == my_size
+            del table
+            assert get_allocated_khash_memory() == 0
+
+    def test_get_state(self, table_type, dtype):
+        table = table_type(1000)
+        state = table.get_state()
+        assert state["size"] == 0
+        assert state["n_occupied"] == 0
+        assert "n_buckets" in state
+        assert "upper_bound" in state
+
+    @pytest.mark.parametrize("N", range(1, 110))
+    def test_no_reallocation(self, table_type, dtype, N):
+        keys = np.arange(N).astype(dtype)
+        preallocated_table = table_type(N)
+        n_buckets_start = preallocated_table.get_state()["n_buckets"]
+        preallocated_table.map_locations(keys)
+        n_buckets_end = preallocated_table.get_state()["n_buckets"]
+        # original number of buckets was enough:
+        assert n_buckets_start == n_buckets_end
+        # check with clean table (not too much preallocated)
+        clean_table = table_type()
+        clean_table.map_locations(keys)
+        assert n_buckets_start == clean_table.get_state()["n_buckets"]
+
+
+class TestHashTableUnsorted:
+    # TODO: moved from test_algos; may be redundancies with other tests
+    def test_string_hashtable_set_item_signature(self):
+        # GH#30419 fix typing in StringHashTable.set_item to prevent segfault
+        tbl = ht.StringHashTable()
+
+        tbl.set_item("key", 1)
+        assert tbl.get_item("key") == 1
+
+        with pytest.raises(TypeError, match="'key' has incorrect type"):
+            # key arg typed as string, not object
+            tbl.set_item(4, 6)
+        with pytest.raises(TypeError, match="'val' has incorrect type"):
+            tbl.get_item(4)
+
+    def test_lookup_nan(self, writable):
+        # GH#21688 ensure we can deal with readonly memory views
+        xs = np.array([2.718, 3.14, np.nan, -7, 5, 2, 3])
+        xs.setflags(write=writable)
+        m = ht.Float64HashTable()
+        m.map_locations(xs)
+        tm.assert_numpy_array_equal(m.lookup(xs), np.arange(len(xs), dtype=np.intp))
+
+    def test_add_signed_zeros(self):
+        # GH#21866 inconsistent hash-function for float64
+        # default hash-function would lead to different hash-buckets
+        # for 0.0 and -0.0 if there are more than 2^30 hash-buckets
+        # but this would mean 16GB
+        N = 4  # 12 * 10**8 would trigger the error, if you have enough memory
+        m = ht.Float64HashTable(N)
+        m.set_item(0.0, 0)
+        m.set_item(-0.0, 0)
+        assert len(m) == 1  # 0.0 and -0.0 are equivalent
+
+    def test_add_different_nans(self):
+        # GH#21866 inconsistent hash-function for float64
+        # create different nans from bit-patterns:
+        NAN1 = struct.unpack("d", struct.pack("=Q", 0x7FF8000000000000))[0]
+        NAN2 = struct.unpack("d", struct.pack("=Q", 0x7FF8000000000001))[0]
+        assert NAN1 != NAN1
+        assert NAN2 != NAN2
+        # default hash function would lead to different hash-buckets
+        # for NAN1 and NAN2 even if there are only 4 buckets:
+        m = ht.Float64HashTable()
+        m.set_item(NAN1, 0)
+        m.set_item(NAN2, 0)
+        assert len(m) == 1  # NAN1 and NAN2 are equivalent
+
+    def test_lookup_overflow(self, writable):
+        xs = np.array([1, 2, 2**63], dtype=np.uint64)
+        # GH 21688 ensure we can deal with readonly memory views
+        xs.setflags(write=writable)
+        m = ht.UInt64HashTable()
+        m.map_locations(xs)
+        tm.assert_numpy_array_equal(m.lookup(xs), np.arange(len(xs), dtype=np.intp))
+
+    @pytest.mark.parametrize("nvals", [0, 10])  # resizing to 0 is special case
+    @pytest.mark.parametrize(
+        "htable, uniques, dtype, safely_resizes",
+        [
+            (ht.PyObjectHashTable, ht.ObjectVector, "object", False),
+            (ht.StringHashTable, ht.ObjectVector, "object", True),
+            (ht.Float64HashTable, ht.Float64Vector, "float64", False),
+            (ht.Int64HashTable, ht.Int64Vector, "int64", False),
+            (ht.Int32HashTable, ht.Int32Vector, "int32", False),
+            (ht.UInt64HashTable, ht.UInt64Vector, "uint64", False),
+        ],
+    )
+    def test_vector_resize(
+        self, writable, htable, uniques, dtype, safely_resizes, nvals
+    ):
+        # Test for memory errors after internal vector
+        # reallocations (GH 7157)
+        # Changed from using np.random.default_rng(2).rand to range
+        # which could cause flaky CI failures when safely_resizes=False
+        vals = np.array(range(1000), dtype=dtype)
+
+        # GH 21688 ensures we can deal with read-only memory views
+        vals.setflags(write=writable)
+
+        # initialise instances; cannot initialise in parametrization,
+        # as otherwise external views would be held on the array (which is
+        # one of the things this test is checking)
+        htable = htable()
+        uniques = uniques()
+
+        # get_labels may append to uniques
+        htable.get_labels(vals[:nvals], uniques, 0, -1)
+        # to_array() sets an external_view_exists flag on uniques.
+        tmp = uniques.to_array()
+        oldshape = tmp.shape
+
+        # subsequent get_labels() calls can no longer append to it
+        # (except for StringHashTables + ObjectVector)
+        if safely_resizes:
+            htable.get_labels(vals, uniques, 0, -1)
+        else:
+            with pytest.raises(ValueError, match="external reference.*"):
+                htable.get_labels(vals, uniques, 0, -1)
+
+        uniques.to_array()  # should not raise here
+        assert tmp.shape == oldshape
+
+    @pytest.mark.parametrize(
+        "hashtable",
+        [
+            ht.PyObjectHashTable,
+            ht.StringHashTable,
+            ht.Float64HashTable,
+            ht.Int64HashTable,
+            ht.Int32HashTable,
+            ht.UInt64HashTable,
+        ],
+    )
+    def test_hashtable_large_sizehint(self, hashtable):
+        # GH#22729 smoketest for not raising when passing a large size_hint
+        size_hint = np.iinfo(np.uint32).max + 1
+        hashtable(size_hint=size_hint)
+
+
+class TestPyObjectHashTableWithNans:
+    def test_nan_float(self):
+        nan1 = float("nan")
+        nan2 = float("nan")
+        assert nan1 is not nan2
+        table = ht.PyObjectHashTable()
+        table.set_item(nan1, 42)
+        assert table.get_item(nan2) == 42
+
+    def test_nan_complex_both(self):
+        nan1 = complex(float("nan"), float("nan"))
+        nan2 = complex(float("nan"), float("nan"))
+        assert nan1 is not nan2
+        table = ht.PyObjectHashTable()
+        table.set_item(nan1, 42)
+        assert table.get_item(nan2) == 42
+
+    def test_nan_complex_real(self):
+        nan1 = complex(float("nan"), 1)
+        nan2 = complex(float("nan"), 1)
+        other = complex(float("nan"), 2)
+        assert nan1 is not nan2
+        table = ht.PyObjectHashTable()
+        table.set_item(nan1, 42)
+        assert table.get_item(nan2) == 42
+        with pytest.raises(KeyError, match=None) as error:
+            table.get_item(other)
+        assert str(error.value) == str(other)
+
+    def test_nan_complex_imag(self):
+        nan1 = complex(1, float("nan"))
+        nan2 = complex(1, float("nan"))
+        other = complex(2, float("nan"))
+        assert nan1 is not nan2
+        table = ht.PyObjectHashTable()
+        table.set_item(nan1, 42)
+        assert table.get_item(nan2) == 42
+        with pytest.raises(KeyError, match=None) as error:
+            table.get_item(other)
+        assert str(error.value) == str(other)
+
+    def test_nan_in_tuple(self):
+        nan1 = (float("nan"),)
+        nan2 = (float("nan"),)
+        assert nan1[0] is not nan2[0]
+        table = ht.PyObjectHashTable()
+        table.set_item(nan1, 42)
+        assert table.get_item(nan2) == 42
+
+    def test_nan_in_nested_tuple(self):
+        nan1 = (1, (2, (float("nan"),)))
+        nan2 = (1, (2, (float("nan"),)))
+        other = (1, 2)
+        table = ht.PyObjectHashTable()
+        table.set_item(nan1, 42)
+        assert table.get_item(nan2) == 42
+        with pytest.raises(KeyError, match=None) as error:
+            table.get_item(other)
+        assert str(error.value) == str(other)
+
+
+def test_hash_equal_tuple_with_nans():
+    a = (float("nan"), (float("nan"), float("nan")))
+    b = (float("nan"), (float("nan"), float("nan")))
+    assert ht.object_hash(a) == ht.object_hash(b)
+    assert ht.objects_are_equal(a, b)
+
+
+def test_get_labels_groupby_for_Int64(writable):
+    table = ht.Int64HashTable()
+    vals = np.array([1, 2, -1, 2, 1, -1], dtype=np.int64)
+    vals.flags.writeable = writable
+    arr, unique = table.get_labels_groupby(vals)
+    expected_arr = np.array([0, 1, -1, 1, 0, -1], dtype=np.intp)
+    expected_unique = np.array([1, 2], dtype=np.int64)
+    tm.assert_numpy_array_equal(arr, expected_arr)
+    tm.assert_numpy_array_equal(unique, expected_unique)
+
+
+def test_tracemalloc_works_for_StringHashTable():
+    N = 1000
+    keys = np.arange(N).astype(np.str_).astype(np.object_)
+    with activated_tracemalloc():
+        table = ht.StringHashTable()
+        table.map_locations(keys)
+        used = get_allocated_khash_memory()
+        my_size = table.sizeof()
+        assert used == my_size
+        del table
+        assert get_allocated_khash_memory() == 0
+
+
+def test_tracemalloc_for_empty_StringHashTable():
+    with activated_tracemalloc():
+        table = ht.StringHashTable()
+        used = get_allocated_khash_memory()
+        my_size = table.sizeof()
+        assert used == my_size
+        del table
+        assert get_allocated_khash_memory() == 0
+
+
+@pytest.mark.parametrize("N", range(1, 110))
+def test_no_reallocation_StringHashTable(N):
+    keys = np.arange(N).astype(np.str_).astype(np.object_)
+    preallocated_table = ht.StringHashTable(N)
+    n_buckets_start = preallocated_table.get_state()["n_buckets"]
+    preallocated_table.map_locations(keys)
+    n_buckets_end = preallocated_table.get_state()["n_buckets"]
+    # original number of buckets was enough:
+    assert n_buckets_start == n_buckets_end
+    # check with clean table (not too much preallocated)
+    clean_table = ht.StringHashTable()
+    clean_table.map_locations(keys)
+    assert n_buckets_start == clean_table.get_state()["n_buckets"]
+
+
+@pytest.mark.parametrize(
+    "table_type, dtype",
+    [
+        (ht.Float64HashTable, np.float64),
+        (ht.Float32HashTable, np.float32),
+        (ht.Complex128HashTable, np.complex128),
+        (ht.Complex64HashTable, np.complex64),
+    ],
+)
+class TestHashTableWithNans:
+    def test_get_set_contains_len(self, table_type, dtype):
+        index = float("nan")
+        table = table_type()
+        assert index not in table
+
+        table.set_item(index, 42)
+        assert len(table) == 1
+        assert index in table
+        assert table.get_item(index) == 42
+
+        table.set_item(index, 41)
+        assert len(table) == 1
+        assert index in table
+        assert table.get_item(index) == 41
+
+    def test_map_locations(self, table_type, dtype):
+        N = 10
+        table = table_type()
+        keys = np.full(N, np.nan, dtype=dtype)
+        table.map_locations(keys)
+        assert len(table) == 1
+        assert table.get_item(np.nan) == N - 1
+
+    def test_unique(self, table_type, dtype):
+        N = 1020
+        table = table_type()
+        keys = np.full(N, np.nan, dtype=dtype)
+        unique = table.unique(keys)
+        assert np.all(np.isnan(unique)) and len(unique) == 1
+
+
+def test_unique_for_nan_objects_floats():
+    table = ht.PyObjectHashTable()
+    keys = np.array([float("nan") for i in range(50)], dtype=np.object_)
+    unique = table.unique(keys)
+    assert len(unique) == 1
+
+
+def test_unique_for_nan_objects_complex():
+    table = ht.PyObjectHashTable()
+    keys = np.array([complex(float("nan"), 1.0) for i in range(50)], dtype=np.object_)
+    unique = table.unique(keys)
+    assert len(unique) == 1
+
+
+def test_unique_for_nan_objects_tuple():
+    table = ht.PyObjectHashTable()
+    keys = np.array(
+        [1] + [(1.0, (float("nan"), 1.0)) for i in range(50)], dtype=np.object_
+    )
+    unique = table.unique(keys)
+    assert len(unique) == 2
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    [
+        np.object_,
+        np.complex128,
+        np.int64,
+        np.uint64,
+        np.float64,
+        np.complex64,
+        np.int32,
+        np.uint32,
+        np.float32,
+        np.int16,
+        np.uint16,
+        np.int8,
+        np.uint8,
+        np.intp,
+    ],
+)
+class TestHelpFunctions:
+    def test_value_count(self, dtype, writable):
+        N = 43
+        expected = (np.arange(N) + N).astype(dtype)
+        values = np.repeat(expected, 5)
+        values.flags.writeable = writable
+        keys, counts, _ = ht.value_count(values, False)
+        tm.assert_numpy_array_equal(np.sort(keys), expected)
+        assert np.all(counts == 5)
+
+    def test_value_count_mask(self, dtype):
+        if dtype == np.object_:
+            pytest.skip("mask not implemented for object dtype")
+        values = np.array([1] * 5, dtype=dtype)
+        mask = np.zeros((5,), dtype=np.bool_)
+        mask[1] = True
+        mask[4] = True
+        keys, counts, na_counter = ht.value_count(values, False, mask=mask)
+        assert len(keys) == 2
+        assert na_counter == 2
+
+    def test_value_count_stable(self, dtype, writable):
+        # GH12679
+        values = np.array([2, 1, 5, 22, 3, -1, 8]).astype(dtype)
+        values.flags.writeable = writable
+        keys, counts, _ = ht.value_count(values, False)
+        tm.assert_numpy_array_equal(keys, values)
+        assert np.all(counts == 1)
+
+    def test_duplicated_first(self, dtype, writable):
+        N = 100
+        values = np.repeat(np.arange(N).astype(dtype), 5)
+        values.flags.writeable = writable
+        result = ht.duplicated(values)
+        expected = np.ones_like(values, dtype=np.bool_)
+        expected[::5] = False
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_ismember_yes(self, dtype, writable):
+        N = 127
+        arr = np.arange(N).astype(dtype)
+        values = np.arange(N).astype(dtype)
+        arr.flags.writeable = writable
+        values.flags.writeable = writable
+        result = ht.ismember(arr, values)
+        expected = np.ones_like(values, dtype=np.bool_)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_ismember_no(self, dtype):
+        N = 17
+        arr = np.arange(N).astype(dtype)
+        values = (np.arange(N) + N).astype(dtype)
+        result = ht.ismember(arr, values)
+        expected = np.zeros_like(values, dtype=np.bool_)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_mode(self, dtype, writable):
+        if dtype in (np.int8, np.uint8):
+            N = 53
+        else:
+            N = 11111
+        values = np.repeat(np.arange(N).astype(dtype), 5)
+        values[0] = 42
+        values.flags.writeable = writable
+        result = ht.mode(values, False)[0]
+        assert result == 42
+
+    def test_mode_stable(self, dtype, writable):
+        values = np.array([2, 1, 5, 22, 3, -1, 8]).astype(dtype)
+        values.flags.writeable = writable
+        keys = ht.mode(values, False)[0]
+        tm.assert_numpy_array_equal(keys, values)
+
+
+def test_modes_with_nans():
+    # GH42688, nans aren't mangled
+    nulls = [pd.NA, np.nan, pd.NaT, None]
+    values = np.array([True] + nulls * 2, dtype=np.object_)
+    modes = ht.mode(values, False)[0]
+    assert modes.size == len(nulls)
+
+
+def test_unique_label_indices_intp(writable):
+    keys = np.array([1, 2, 2, 2, 1, 3], dtype=np.intp)
+    keys.flags.writeable = writable
+    result = ht.unique_label_indices(keys)
+    expected = np.array([0, 1, 5], dtype=np.intp)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_unique_label_indices():
+    a = np.random.default_rng(2).integers(1, 1 << 10, 1 << 15).astype(np.intp)
+
+    left = ht.unique_label_indices(a)
+    right = np.unique(a, return_index=True)[1]
+
+    tm.assert_numpy_array_equal(left, right, check_dtype=False)
+
+    a[np.random.default_rng(2).choice(len(a), 10)] = -1
+    left = ht.unique_label_indices(a)
+    right = np.unique(a, return_index=True)[1][1:]
+    tm.assert_numpy_array_equal(left, right, check_dtype=False)
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    [
+        np.float64,
+        np.float32,
+        np.complex128,
+        np.complex64,
+    ],
+)
+class TestHelpFunctionsWithNans:
+    def test_value_count(self, dtype):
+        values = np.array([np.nan, np.nan, np.nan], dtype=dtype)
+        keys, counts, _ = ht.value_count(values, True)
+        assert len(keys) == 0
+        keys, counts, _ = ht.value_count(values, False)
+        assert len(keys) == 1 and np.all(np.isnan(keys))
+        assert counts[0] == 3
+
+    def test_duplicated_first(self, dtype):
+        values = np.array([np.nan, np.nan, np.nan], dtype=dtype)
+        result = ht.duplicated(values)
+        expected = np.array([False, True, True])
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_ismember_yes(self, dtype):
+        arr = np.array([np.nan, np.nan, np.nan], dtype=dtype)
+        values = np.array([np.nan, np.nan], dtype=dtype)
+        result = ht.ismember(arr, values)
+        expected = np.array([True, True, True], dtype=np.bool_)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_ismember_no(self, dtype):
+        arr = np.array([np.nan, np.nan, np.nan], dtype=dtype)
+        values = np.array([1], dtype=dtype)
+        result = ht.ismember(arr, values)
+        expected = np.array([False, False, False], dtype=np.bool_)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_mode(self, dtype):
+        values = np.array([42, np.nan, np.nan, np.nan], dtype=dtype)
+        assert ht.mode(values, True)[0] == 42
+        assert np.isnan(ht.mode(values, False)[0])
+
+
+def test_ismember_tuple_with_nans():
+    # GH-41836
+    values = [("a", float("nan")), ("b", 1)]
+    comps = [("a", float("nan"))]
+
+    msg = "isin with argument that is not not a Series"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = isin(values, comps)
+    expected = np.array([True, False], dtype=np.bool_)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_float_complex_int_are_equal_as_objects():
+    values = ["a", 5, 5.0, 5.0 + 0j]
+    comps = list(range(129))
+    result = isin(np.array(values, dtype=object), np.asarray(comps))
+    expected = np.array([False, True, True, True], dtype=np.bool_)
+    tm.assert_numpy_array_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/libs/test_join.py

@@ -0,0 +1,390 @@
+import numpy as np
+import pytest
+
+from pandas._libs import join as libjoin
+from pandas._libs.join import (
+    inner_join,
+    left_outer_join,
+)
+
+import pandas._testing as tm
+
+
+class TestIndexer:
+    @pytest.mark.parametrize(
+        "dtype", ["int32", "int64", "float32", "float64", "object"]
+    )
+    def test_outer_join_indexer(self, dtype):
+        indexer = libjoin.outer_join_indexer
+
+        left = np.arange(3, dtype=dtype)
+        right = np.arange(2, 5, dtype=dtype)
+        empty = np.array([], dtype=dtype)
+
+        result, lindexer, rindexer = indexer(left, right)
+        assert isinstance(result, np.ndarray)
+        assert isinstance(lindexer, np.ndarray)
+        assert isinstance(rindexer, np.ndarray)
+        tm.assert_numpy_array_equal(result, np.arange(5, dtype=dtype))
+        exp = np.array([0, 1, 2, -1, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(lindexer, exp)
+        exp = np.array([-1, -1, 0, 1, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(rindexer, exp)
+
+        result, lindexer, rindexer = indexer(empty, right)
+        tm.assert_numpy_array_equal(result, right)
+        exp = np.array([-1, -1, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(lindexer, exp)
+        exp = np.array([0, 1, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(rindexer, exp)
+
+        result, lindexer, rindexer = indexer(left, empty)
+        tm.assert_numpy_array_equal(result, left)
+        exp = np.array([0, 1, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(lindexer, exp)
+        exp = np.array([-1, -1, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(rindexer, exp)
+
+    def test_cython_left_outer_join(self):
+        left = np.array([0, 1, 2, 1, 2, 0, 0, 1, 2, 3, 3], dtype=np.intp)
+        right = np.array([1, 1, 0, 4, 2, 2, 1], dtype=np.intp)
+        max_group = 5
+
+        ls, rs = left_outer_join(left, right, max_group)
+
+        exp_ls = left.argsort(kind="mergesort")
+        exp_rs = right.argsort(kind="mergesort")
+
+        exp_li = np.array([0, 1, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 7, 7, 8, 8, 9, 10])
+        exp_ri = np.array(
+            [0, 0, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 4, 5, 4, 5, 4, 5, -1, -1]
+        )
+
+        exp_ls = exp_ls.take(exp_li)
+        exp_ls[exp_li == -1] = -1
+
+        exp_rs = exp_rs.take(exp_ri)
+        exp_rs[exp_ri == -1] = -1
+
+        tm.assert_numpy_array_equal(ls, exp_ls, check_dtype=False)
+        tm.assert_numpy_array_equal(rs, exp_rs, check_dtype=False)
+
+    def test_cython_right_outer_join(self):
+        left = np.array([0, 1, 2, 1, 2, 0, 0, 1, 2, 3, 3], dtype=np.intp)
+        right = np.array([1, 1, 0, 4, 2, 2, 1], dtype=np.intp)
+        max_group = 5
+
+        rs, ls = left_outer_join(right, left, max_group)
+
+        exp_ls = left.argsort(kind="mergesort")
+        exp_rs = right.argsort(kind="mergesort")
+
+        #            0        1        1        1
+        exp_li = np.array(
+            [
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                3,
+                4,
+                5,
+                3,
+                4,
+                5,
+                #            2        2        4
+                6,
+                7,
+                8,
+                6,
+                7,
+                8,
+                -1,
+            ]
+        )
+        exp_ri = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6])
+
+        exp_ls = exp_ls.take(exp_li)
+        exp_ls[exp_li == -1] = -1
+
+        exp_rs = exp_rs.take(exp_ri)
+        exp_rs[exp_ri == -1] = -1
+
+        tm.assert_numpy_array_equal(ls, exp_ls)
+        tm.assert_numpy_array_equal(rs, exp_rs)
+
+    def test_cython_inner_join(self):
+        left = np.array([0, 1, 2, 1, 2, 0, 0, 1, 2, 3, 3], dtype=np.intp)
+        right = np.array([1, 1, 0, 4, 2, 2, 1, 4], dtype=np.intp)
+        max_group = 5
+
+        ls, rs = inner_join(left, right, max_group)
+
+        exp_ls = left.argsort(kind="mergesort")
+        exp_rs = right.argsort(kind="mergesort")
+
+        exp_li = np.array([0, 1, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 7, 7, 8, 8])
+        exp_ri = np.array([0, 0, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 4, 5, 4, 5, 4, 5])
+
+        exp_ls = exp_ls.take(exp_li)
+        exp_ls[exp_li == -1] = -1
+
+        exp_rs = exp_rs.take(exp_ri)
+        exp_rs[exp_ri == -1] = -1
+
+        tm.assert_numpy_array_equal(ls, exp_ls)
+        tm.assert_numpy_array_equal(rs, exp_rs)
+
+
+@pytest.mark.parametrize("readonly", [True, False])
+def test_left_join_indexer_unique(readonly):
+    a = np.array([1, 2, 3, 4, 5], dtype=np.int64)
+    b = np.array([2, 2, 3, 4, 4], dtype=np.int64)
+    if readonly:
+        # GH#37312, GH#37264
+        a.setflags(write=False)
+        b.setflags(write=False)
+
+    result = libjoin.left_join_indexer_unique(b, a)
+    expected = np.array([1, 1, 2, 3, 3], dtype=np.intp)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_left_outer_join_bug():
+    left = np.array(
+        [
+            0,
+            1,
+            0,
+            1,
+            1,
+            2,
+            3,
+            1,
+            0,
+            2,
+            1,
+            2,
+            0,
+            1,
+            1,
+            2,
+            3,
+            2,
+            3,
+            2,
+            1,
+            1,
+            3,
+            0,
+            3,
+            2,
+            3,
+            0,
+            0,
+            2,
+            3,
+            2,
+            0,
+            3,
+            1,
+            3,
+            0,
+            1,
+            3,
+            0,
+            0,
+            1,
+            0,
+            3,
+            1,
+            0,
+            1,
+            0,
+            1,
+            1,
+            0,
+            2,
+            2,
+            2,
+            2,
+            2,
+            0,
+            3,
+            1,
+            2,
+            0,
+            0,
+            3,
+            1,
+            3,
+            2,
+            2,
+            0,
+            1,
+            3,
+            0,
+            2,
+            3,
+            2,
+            3,
+            3,
+            2,
+            3,
+            3,
+            1,
+            3,
+            2,
+            0,
+            0,
+            3,
+            1,
+            1,
+            1,
+            0,
+            2,
+            3,
+            3,
+            1,
+            2,
+            0,
+            3,
+            1,
+            2,
+            0,
+            2,
+        ],
+        dtype=np.intp,
+    )
+
+    right = np.array([3, 1], dtype=np.intp)
+    max_groups = 4
+
+    lidx, ridx = libjoin.left_outer_join(left, right, max_groups, sort=False)
+
+    exp_lidx = np.arange(len(left), dtype=np.intp)
+    exp_ridx = -np.ones(len(left), dtype=np.intp)
+
+    exp_ridx[left == 1] = 1
+    exp_ridx[left == 3] = 0
+
+    tm.assert_numpy_array_equal(lidx, exp_lidx)
+    tm.assert_numpy_array_equal(ridx, exp_ridx)
+
+
+def test_inner_join_indexer():
+    a = np.array([1, 2, 3, 4, 5], dtype=np.int64)
+    b = np.array([0, 3, 5, 7, 9], dtype=np.int64)
+
+    index, ares, bres = libjoin.inner_join_indexer(a, b)
+
+    index_exp = np.array([3, 5], dtype=np.int64)
+    tm.assert_almost_equal(index, index_exp)
+
+    aexp = np.array([2, 4], dtype=np.intp)
+    bexp = np.array([1, 2], dtype=np.intp)
+    tm.assert_almost_equal(ares, aexp)
+    tm.assert_almost_equal(bres, bexp)
+
+    a = np.array([5], dtype=np.int64)
+    b = np.array([5], dtype=np.int64)
+
+    index, ares, bres = libjoin.inner_join_indexer(a, b)
+    tm.assert_numpy_array_equal(index, np.array([5], dtype=np.int64))
+    tm.assert_numpy_array_equal(ares, np.array([0], dtype=np.intp))
+    tm.assert_numpy_array_equal(bres, np.array([0], dtype=np.intp))
+
+
+def test_outer_join_indexer():
+    a = np.array([1, 2, 3, 4, 5], dtype=np.int64)
+    b = np.array([0, 3, 5, 7, 9], dtype=np.int64)
+
+    index, ares, bres = libjoin.outer_join_indexer(a, b)
+
+    index_exp = np.array([0, 1, 2, 3, 4, 5, 7, 9], dtype=np.int64)
+    tm.assert_almost_equal(index, index_exp)
+
+    aexp = np.array([-1, 0, 1, 2, 3, 4, -1, -1], dtype=np.intp)
+    bexp = np.array([0, -1, -1, 1, -1, 2, 3, 4], dtype=np.intp)
+    tm.assert_almost_equal(ares, aexp)
+    tm.assert_almost_equal(bres, bexp)
+
+    a = np.array([5], dtype=np.int64)
+    b = np.array([5], dtype=np.int64)
+
+    index, ares, bres = libjoin.outer_join_indexer(a, b)
+    tm.assert_numpy_array_equal(index, np.array([5], dtype=np.int64))
+    tm.assert_numpy_array_equal(ares, np.array([0], dtype=np.intp))
+    tm.assert_numpy_array_equal(bres, np.array([0], dtype=np.intp))
+
+
+def test_left_join_indexer():
+    a = np.array([1, 2, 3, 4, 5], dtype=np.int64)
+    b = np.array([0, 3, 5, 7, 9], dtype=np.int64)
+
+    index, ares, bres = libjoin.left_join_indexer(a, b)
+
+    tm.assert_almost_equal(index, a)
+
+    aexp = np.array([0, 1, 2, 3, 4], dtype=np.intp)
+    bexp = np.array([-1, -1, 1, -1, 2], dtype=np.intp)
+    tm.assert_almost_equal(ares, aexp)
+    tm.assert_almost_equal(bres, bexp)
+
+    a = np.array([5], dtype=np.int64)
+    b = np.array([5], dtype=np.int64)
+
+    index, ares, bres = libjoin.left_join_indexer(a, b)
+    tm.assert_numpy_array_equal(index, np.array([5], dtype=np.int64))
+    tm.assert_numpy_array_equal(ares, np.array([0], dtype=np.intp))
+    tm.assert_numpy_array_equal(bres, np.array([0], dtype=np.intp))
+
+
+def test_left_join_indexer2():
+    idx = np.array([1, 1, 2, 5], dtype=np.int64)
+    idx2 = np.array([1, 2, 5, 7, 9], dtype=np.int64)
+
+    res, lidx, ridx = libjoin.left_join_indexer(idx2, idx)
+
+    exp_res = np.array([1, 1, 2, 5, 7, 9], dtype=np.int64)
+    tm.assert_almost_equal(res, exp_res)
+
+    exp_lidx = np.array([0, 0, 1, 2, 3, 4], dtype=np.intp)
+    tm.assert_almost_equal(lidx, exp_lidx)
+
+    exp_ridx = np.array([0, 1, 2, 3, -1, -1], dtype=np.intp)
+    tm.assert_almost_equal(ridx, exp_ridx)
+
+
+def test_outer_join_indexer2():
+    idx = np.array([1, 1, 2, 5], dtype=np.int64)
+    idx2 = np.array([1, 2, 5, 7, 9], dtype=np.int64)
+
+    res, lidx, ridx = libjoin.outer_join_indexer(idx2, idx)
+
+    exp_res = np.array([1, 1, 2, 5, 7, 9], dtype=np.int64)
+    tm.assert_almost_equal(res, exp_res)
+
+    exp_lidx = np.array([0, 0, 1, 2, 3, 4], dtype=np.intp)
+    tm.assert_almost_equal(lidx, exp_lidx)
+
+    exp_ridx = np.array([0, 1, 2, 3, -1, -1], dtype=np.intp)
+    tm.assert_almost_equal(ridx, exp_ridx)
+
+
+def test_inner_join_indexer2():
+    idx = np.array([1, 1, 2, 5], dtype=np.int64)
+    idx2 = np.array([1, 2, 5, 7, 9], dtype=np.int64)
+
+    res, lidx, ridx = libjoin.inner_join_indexer(idx2, idx)
+
+    exp_res = np.array([1, 1, 2, 5], dtype=np.int64)
+    tm.assert_almost_equal(res, exp_res)
+
+    exp_lidx = np.array([0, 0, 1, 2], dtype=np.intp)
+    tm.assert_almost_equal(lidx, exp_lidx)
+
+    exp_ridx = np.array([0, 1, 2, 3], dtype=np.intp)
+    tm.assert_almost_equal(ridx, exp_ridx)

env-llmeval/lib/python3.10/site-packages/pandas/tests/libs/test_lib.py

@@ -0,0 +1,285 @@
+import numpy as np
+import pytest
+
+from pandas._libs import (
+    Timedelta,
+    lib,
+    writers as libwriters,
+)
+from pandas.compat import IS64
+
+from pandas import Index
+import pandas._testing as tm
+
+
+class TestMisc:
+    def test_max_len_string_array(self):
+        arr = a = np.array(["foo", "b", np.nan], dtype="object")
+        assert libwriters.max_len_string_array(arr) == 3
+
+        # unicode
+        arr = a.astype("U").astype(object)
+        assert libwriters.max_len_string_array(arr) == 3
+
+        # bytes for python3
+        arr = a.astype("S").astype(object)
+        assert libwriters.max_len_string_array(arr) == 3
+
+        # raises
+        msg = "No matching signature found"
+        with pytest.raises(TypeError, match=msg):
+            libwriters.max_len_string_array(arr.astype("U"))
+
+    def test_fast_unique_multiple_list_gen_sort(self):
+        keys = [["p", "a"], ["n", "d"], ["a", "s"]]
+
+        gen = (key for key in keys)
+        expected = np.array(["a", "d", "n", "p", "s"])
+        out = lib.fast_unique_multiple_list_gen(gen, sort=True)
+        tm.assert_numpy_array_equal(np.array(out), expected)
+
+        gen = (key for key in keys)
+        expected = np.array(["p", "a", "n", "d", "s"])
+        out = lib.fast_unique_multiple_list_gen(gen, sort=False)
+        tm.assert_numpy_array_equal(np.array(out), expected)
+
+    def test_fast_multiget_timedelta_resos(self):
+        # This will become relevant for test_constructor_dict_timedelta64_index
+        #  once Timedelta constructor preserves reso when passed a
+        #  np.timedelta64 object
+        td = Timedelta(days=1)
+
+        mapping1 = {td: 1}
+        mapping2 = {td.as_unit("s"): 1}
+
+        oindex = Index([td * n for n in range(3)])._values.astype(object)
+
+        expected = lib.fast_multiget(mapping1, oindex)
+        result = lib.fast_multiget(mapping2, oindex)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # case that can't be cast to td64ns
+        td = Timedelta(np.timedelta64(146000, "D"))
+        assert hash(td) == hash(td.as_unit("ms"))
+        assert hash(td) == hash(td.as_unit("us"))
+        mapping1 = {td: 1}
+        mapping2 = {td.as_unit("ms"): 1}
+
+        oindex = Index([td * n for n in range(3)])._values.astype(object)
+
+        expected = lib.fast_multiget(mapping1, oindex)
+        result = lib.fast_multiget(mapping2, oindex)
+        tm.assert_numpy_array_equal(result, expected)
+
+
+class TestIndexing:
+    def test_maybe_indices_to_slice_left_edge(self):
+        target = np.arange(100)
+
+        # slice
+        indices = np.array([], dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+
+        assert isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+
+    @pytest.mark.parametrize("end", [1, 2, 5, 20, 99])
+    @pytest.mark.parametrize("step", [1, 2, 4])
+    def test_maybe_indices_to_slice_left_edge_not_slice_end_steps(self, end, step):
+        target = np.arange(100)
+        indices = np.arange(0, end, step, dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+
+        assert isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+
+        # reverse
+        indices = indices[::-1]
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+
+        assert isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+
+    @pytest.mark.parametrize(
+        "case", [[2, 1, 2, 0], [2, 2, 1, 0], [0, 1, 2, 1], [-2, 0, 2], [2, 0, -2]]
+    )
+    def test_maybe_indices_to_slice_left_edge_not_slice(self, case):
+        # not slice
+        target = np.arange(100)
+        indices = np.array(case, dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+
+        assert not isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(maybe_slice, indices)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+
+    @pytest.mark.parametrize("start", [0, 2, 5, 20, 97, 98])
+    @pytest.mark.parametrize("step", [1, 2, 4])
+    def test_maybe_indices_to_slice_right_edge(self, start, step):
+        target = np.arange(100)
+
+        # slice
+        indices = np.arange(start, 99, step, dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+
+        assert isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+
+        # reverse
+        indices = indices[::-1]
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+
+        assert isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+
+    def test_maybe_indices_to_slice_right_edge_not_slice(self):
+        # not slice
+        target = np.arange(100)
+        indices = np.array([97, 98, 99, 100], dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+
+        assert not isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(maybe_slice, indices)
+
+        msg = "index 100 is out of bounds for axis (0|1) with size 100"
+
+        with pytest.raises(IndexError, match=msg):
+            target[indices]
+        with pytest.raises(IndexError, match=msg):
+            target[maybe_slice]
+
+        indices = np.array([100, 99, 98, 97], dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+
+        assert not isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(maybe_slice, indices)
+
+        with pytest.raises(IndexError, match=msg):
+            target[indices]
+        with pytest.raises(IndexError, match=msg):
+            target[maybe_slice]
+
+    @pytest.mark.parametrize(
+        "case", [[99, 97, 99, 96], [99, 99, 98, 97], [98, 98, 97, 96]]
+    )
+    def test_maybe_indices_to_slice_right_edge_cases(self, case):
+        target = np.arange(100)
+        indices = np.array(case, dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+
+        assert not isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(maybe_slice, indices)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+
+    @pytest.mark.parametrize("step", [1, 2, 4, 5, 8, 9])
+    def test_maybe_indices_to_slice_both_edges(self, step):
+        target = np.arange(10)
+
+        # slice
+        indices = np.arange(0, 9, step, dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+        assert isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+
+        # reverse
+        indices = indices[::-1]
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+        assert isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+
+    @pytest.mark.parametrize("case", [[4, 2, 0, -2], [2, 2, 1, 0], [0, 1, 2, 1]])
+    def test_maybe_indices_to_slice_both_edges_not_slice(self, case):
+        # not slice
+        target = np.arange(10)
+        indices = np.array(case, dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+        assert not isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(maybe_slice, indices)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+
+    @pytest.mark.parametrize("start, end", [(2, 10), (5, 25), (65, 97)])
+    @pytest.mark.parametrize("step", [1, 2, 4, 20])
+    def test_maybe_indices_to_slice_middle(self, start, end, step):
+        target = np.arange(100)
+
+        # slice
+        indices = np.arange(start, end, step, dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+
+        assert isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+
+        # reverse
+        indices = indices[::-1]
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+
+        assert isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+
+    @pytest.mark.parametrize(
+        "case", [[14, 12, 10, 12], [12, 12, 11, 10], [10, 11, 12, 11]]
+    )
+    def test_maybe_indices_to_slice_middle_not_slice(self, case):
+        # not slice
+        target = np.arange(100)
+        indices = np.array(case, dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(target))
+
+        assert not isinstance(maybe_slice, slice)
+        tm.assert_numpy_array_equal(maybe_slice, indices)
+        tm.assert_numpy_array_equal(target[indices], target[maybe_slice])
+
+    def test_maybe_booleans_to_slice(self):
+        arr = np.array([0, 0, 1, 1, 1, 0, 1], dtype=np.uint8)
+        result = lib.maybe_booleans_to_slice(arr)
+        assert result.dtype == np.bool_
+
+        result = lib.maybe_booleans_to_slice(arr[:0])
+        assert result == slice(0, 0)
+
+    def test_get_reverse_indexer(self):
+        indexer = np.array([-1, -1, 1, 2, 0, -1, 3, 4], dtype=np.intp)
+        result = lib.get_reverse_indexer(indexer, 5)
+        expected = np.array([4, 2, 3, 6, 7], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", ["int64", "int32"])
+    def test_is_range_indexer(self, dtype):
+        # GH#50592
+        left = np.arange(0, 100, dtype=dtype)
+        assert lib.is_range_indexer(left, 100)
+
+    @pytest.mark.skipif(
+        not IS64,
+        reason="2**31 is too big for Py_ssize_t on 32-bit. "
+        "It doesn't matter though since you cannot create an array that long on 32-bit",
+    )
+    @pytest.mark.parametrize("dtype", ["int64", "int32"])
+    def test_is_range_indexer_big_n(self, dtype):
+        # GH53616
+        left = np.arange(0, 100, dtype=dtype)
+
+        assert not lib.is_range_indexer(left, 2**31)
+
+    @pytest.mark.parametrize("dtype", ["int64", "int32"])
+    def test_is_range_indexer_not_equal(self, dtype):
+        # GH#50592
+        left = np.array([1, 2], dtype=dtype)
+        assert not lib.is_range_indexer(left, 2)
+
+    @pytest.mark.parametrize("dtype", ["int64", "int32"])
+    def test_is_range_indexer_not_equal_shape(self, dtype):
+        # GH#50592
+        left = np.array([0, 1, 2], dtype=dtype)
+        assert not lib.is_range_indexer(left, 2)
+
+
+def test_cache_readonly_preserve_docstrings():
+    # GH18197
+    assert Index.hasnans.__doc__ is not None
+
+
+def test_no_default_pickle():
+    # GH#40397
+    obj = tm.round_trip_pickle(lib.no_default)
+    assert obj is lib.no_default

env-llmeval/lib/python3.10/site-packages/pandas/tests/libs/test_libalgos.py

@@ -0,0 +1,162 @@
+from datetime import datetime
+from itertools import permutations
+
+import numpy as np
+
+from pandas._libs import algos as libalgos
+
+import pandas._testing as tm
+
+
+def test_ensure_platform_int():
+    arr = np.arange(100, dtype=np.intp)
+
+    result = libalgos.ensure_platform_int(arr)
+    assert result is arr
+
+
+def test_is_lexsorted():
+    failure = [
+        np.array(
+            ([3] * 32) + ([2] * 32) + ([1] * 32) + ([0] * 32),
+            dtype="int64",
+        ),
+        np.array(
+            list(range(31))[::-1] * 4,
+            dtype="int64",
+        ),
+    ]
+
+    assert not libalgos.is_lexsorted(failure)
+
+
+def test_groupsort_indexer():
+    a = np.random.default_rng(2).integers(0, 1000, 100).astype(np.intp)
+    b = np.random.default_rng(2).integers(0, 1000, 100).astype(np.intp)
+
+    result = libalgos.groupsort_indexer(a, 1000)[0]
+
+    # need to use a stable sort
+    # np.argsort returns int, groupsort_indexer
+    # always returns intp
+    expected = np.argsort(a, kind="mergesort")
+    expected = expected.astype(np.intp)
+
+    tm.assert_numpy_array_equal(result, expected)
+
+    # compare with lexsort
+    # np.lexsort returns int, groupsort_indexer
+    # always returns intp
+    key = a * 1000 + b
+    result = libalgos.groupsort_indexer(key, 1000000)[0]
+    expected = np.lexsort((b, a))
+    expected = expected.astype(np.intp)
+
+    tm.assert_numpy_array_equal(result, expected)
+
+
+class TestPadBackfill:
+    def test_backfill(self):
+        old = np.array([1, 5, 10], dtype=np.int64)
+        new = np.array(list(range(12)), dtype=np.int64)
+
+        filler = libalgos.backfill["int64_t"](old, new)
+
+        expect_filler = np.array([0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(filler, expect_filler)
+
+        # corner case
+        old = np.array([1, 4], dtype=np.int64)
+        new = np.array(list(range(5, 10)), dtype=np.int64)
+        filler = libalgos.backfill["int64_t"](old, new)
+
+        expect_filler = np.array([-1, -1, -1, -1, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(filler, expect_filler)
+
+    def test_pad(self):
+        old = np.array([1, 5, 10], dtype=np.int64)
+        new = np.array(list(range(12)), dtype=np.int64)
+
+        filler = libalgos.pad["int64_t"](old, new)
+
+        expect_filler = np.array([-1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(filler, expect_filler)
+
+        # corner case
+        old = np.array([5, 10], dtype=np.int64)
+        new = np.arange(5, dtype=np.int64)
+        filler = libalgos.pad["int64_t"](old, new)
+        expect_filler = np.array([-1, -1, -1, -1, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(filler, expect_filler)
+
+    def test_pad_backfill_object_segfault(self):
+        old = np.array([], dtype="O")
+        new = np.array([datetime(2010, 12, 31)], dtype="O")
+
+        result = libalgos.pad["object"](old, new)
+        expected = np.array([-1], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = libalgos.pad["object"](new, old)
+        expected = np.array([], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = libalgos.backfill["object"](old, new)
+        expected = np.array([-1], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = libalgos.backfill["object"](new, old)
+        expected = np.array([], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+
+class TestInfinity:
+    def test_infinity_sort(self):
+        # GH#13445
+        # numpy's argsort can be unhappy if something is less than
+        # itself.  Instead, let's give our infinities a self-consistent
+        # ordering, but outside the float extended real line.
+
+        Inf = libalgos.Infinity()
+        NegInf = libalgos.NegInfinity()
+
+        ref_nums = [NegInf, float("-inf"), -1e100, 0, 1e100, float("inf"), Inf]
+
+        assert all(Inf >= x for x in ref_nums)
+        assert all(Inf > x or x is Inf for x in ref_nums)
+        assert Inf >= Inf and Inf == Inf
+        assert not Inf < Inf and not Inf > Inf
+        assert libalgos.Infinity() == libalgos.Infinity()
+        assert not libalgos.Infinity() != libalgos.Infinity()
+
+        assert all(NegInf <= x for x in ref_nums)
+        assert all(NegInf < x or x is NegInf for x in ref_nums)
+        assert NegInf <= NegInf and NegInf == NegInf
+        assert not NegInf < NegInf and not NegInf > NegInf
+        assert libalgos.NegInfinity() == libalgos.NegInfinity()
+        assert not libalgos.NegInfinity() != libalgos.NegInfinity()
+
+        for perm in permutations(ref_nums):
+            assert sorted(perm) == ref_nums
+
+        # smoke tests
+        np.array([libalgos.Infinity()] * 32).argsort()
+        np.array([libalgos.NegInfinity()] * 32).argsort()
+
+    def test_infinity_against_nan(self):
+        Inf = libalgos.Infinity()
+        NegInf = libalgos.NegInfinity()
+
+        assert not Inf > np.nan
+        assert not Inf >= np.nan
+        assert not Inf < np.nan
+        assert not Inf <= np.nan
+        assert not Inf == np.nan
+        assert Inf != np.nan
+
+        assert not NegInf > np.nan
+        assert not NegInf >= np.nan
+        assert not NegInf < np.nan
+        assert not NegInf <= np.nan
+        assert not NegInf == np.nan
+        assert NegInf != np.nan

env-llmeval/lib/python3.10/site-packages/pandas/tests/tseries/frequencies/test_freq_code.py

@@ -0,0 +1,69 @@
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import (
+    Period,
+    to_offset,
+)
+
+
+@pytest.mark.parametrize(
+    "freqstr,exp_freqstr",
+    [("D", "D"), ("W", "D"), ("ME", "D"), ("s", "s"), ("min", "s"), ("h", "s")],
+)
+def test_get_to_timestamp_base(freqstr, exp_freqstr):
+    off = to_offset(freqstr)
+    per = Period._from_ordinal(1, off)
+    exp_code = to_offset(exp_freqstr)._period_dtype_code
+
+    result_code = per._dtype._get_to_timestamp_base()
+    assert result_code == exp_code
+
+
+@pytest.mark.parametrize(
+    "args,expected",
+    [
+        ((1.5, "min"), (90, "s")),
+        ((62.4, "min"), (3744, "s")),
+        ((1.04, "h"), (3744, "s")),
+        ((1, "D"), (1, "D")),
+        ((0.342931, "h"), (1234551600, "us")),
+        ((1.2345, "D"), (106660800, "ms")),
+    ],
+)
+def test_resolution_bumping(args, expected):
+    # see gh-14378
+    off = to_offset(str(args[0]) + args[1])
+    assert off.n == expected[0]
+    assert off._prefix == expected[1]
+
+
+@pytest.mark.parametrize(
+    "args",
+    [
+        (0.5, "ns"),
+        # Too much precision in the input can prevent.
+        (0.3429324798798269273987982, "h"),
+    ],
+)
+def test_cat(args):
+    msg = "Invalid frequency"
+
+    with pytest.raises(ValueError, match=msg):
+        to_offset(str(args[0]) + args[1])
+
+
+@pytest.mark.parametrize(
+    "freqstr,expected",
+    [
+        ("1h", "2021-01-01T09:00:00"),
+        ("1D", "2021-01-02T08:00:00"),
+        ("1W", "2021-01-03T08:00:00"),
+        ("1ME", "2021-01-31T08:00:00"),
+        ("1YE", "2021-12-31T08:00:00"),
+    ],
+)
+def test_compatibility(freqstr, expected):
+    ts_np = np.datetime64("2021-01-01T08:00:00.00")
+    do = to_offset(freqstr)
+    assert ts_np + do == np.datetime64(expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/tseries/frequencies/test_frequencies.py

@@ -0,0 +1,29 @@
+import pytest
+
+from pandas._libs.tslibs import offsets
+
+from pandas.tseries.frequencies import (
+    is_subperiod,
+    is_superperiod,
+)
+
+
+@pytest.mark.parametrize(
+    "p1,p2,expected",
+    [
+        # Input validation.
+        (offsets.MonthEnd(), None, False),
+        (offsets.YearEnd(), None, False),
+        (None, offsets.YearEnd(), False),
+        (None, offsets.MonthEnd(), False),
+        (None, None, False),
+        (offsets.YearEnd(), offsets.MonthEnd(), True),
+        (offsets.Hour(), offsets.Minute(), True),
+        (offsets.Second(), offsets.Milli(), True),
+        (offsets.Milli(), offsets.Micro(), True),
+        (offsets.Micro(), offsets.Nano(), True),
+    ],
+)
+def test_super_sub_symmetry(p1, p2, expected):
+    assert is_superperiod(p1, p2) is expected
+    assert is_subperiod(p2, p1) is expected

env-llmeval/lib/python3.10/site-packages/pandas/tests/tseries/frequencies/test_inference.py

@@ -0,0 +1,558 @@
+from datetime import (
+    datetime,
+    timedelta,
+)
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs.ccalendar import (
+    DAYS,
+    MONTHS,
+)
+from pandas._libs.tslibs.offsets import _get_offset
+from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
+from pandas.compat import is_platform_windows
+
+from pandas import (
+    DatetimeIndex,
+    Index,
+    RangeIndex,
+    Series,
+    Timestamp,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+from pandas.core.arrays import (
+    DatetimeArray,
+    TimedeltaArray,
+)
+from pandas.core.tools.datetimes import to_datetime
+
+from pandas.tseries import (
+    frequencies,
+    offsets,
+)
+
+
+@pytest.fixture(
+    params=[
+        (timedelta(1), "D"),
+        (timedelta(hours=1), "h"),
+        (timedelta(minutes=1), "min"),
+        (timedelta(seconds=1), "s"),
+        (np.timedelta64(1, "ns"), "ns"),
+        (timedelta(microseconds=1), "us"),
+        (timedelta(microseconds=1000), "ms"),
+    ]
+)
+def base_delta_code_pair(request):
+    return request.param
+
+
+freqs = (
+    [f"QE-{month}" for month in MONTHS]
+    + [f"{annual}-{month}" for annual in ["YE", "BYE"] for month in MONTHS]
+    + ["ME", "BME", "BMS"]
+    + [f"WOM-{count}{day}" for count in range(1, 5) for day in DAYS]
+    + [f"W-{day}" for day in DAYS]
+)
+
+
+@pytest.mark.parametrize("freq", freqs)
+@pytest.mark.parametrize("periods", [5, 7])
+def test_infer_freq_range(periods, freq):
+    freq = freq.upper()
+
+    gen = date_range("1/1/2000", periods=periods, freq=freq)
+    index = DatetimeIndex(gen.values)
+
+    if not freq.startswith("QE-"):
+        assert frequencies.infer_freq(index) == gen.freqstr
+    else:
+        inf_freq = frequencies.infer_freq(index)
+        is_dec_range = inf_freq == "QE-DEC" and gen.freqstr in (
+            "QE",
+            "QE-DEC",
+            "QE-SEP",
+            "QE-JUN",
+            "QE-MAR",
+        )
+        is_nov_range = inf_freq == "QE-NOV" and gen.freqstr in (
+            "QE-NOV",
+            "QE-AUG",
+            "QE-MAY",
+            "QE-FEB",
+        )
+        is_oct_range = inf_freq == "QE-OCT" and gen.freqstr in (
+            "QE-OCT",
+            "QE-JUL",
+            "QE-APR",
+            "QE-JAN",
+        )
+        assert is_dec_range or is_nov_range or is_oct_range
+
+
+def test_raise_if_period_index():
+    index = period_range(start="1/1/1990", periods=20, freq="M")
+    msg = "Check the `freq` attribute instead of using infer_freq"
+
+    with pytest.raises(TypeError, match=msg):
+        frequencies.infer_freq(index)
+
+
+def test_raise_if_too_few():
+    index = DatetimeIndex(["12/31/1998", "1/3/1999"])
+    msg = "Need at least 3 dates to infer frequency"
+
+    with pytest.raises(ValueError, match=msg):
+        frequencies.infer_freq(index)
+
+
+def test_business_daily():
+    index = DatetimeIndex(["01/01/1999", "1/4/1999", "1/5/1999"])
+    assert frequencies.infer_freq(index) == "B"
+
+
+def test_business_daily_look_alike():
+    # see gh-16624
+    #
+    # Do not infer "B when "weekend" (2-day gap) in wrong place.
+    index = DatetimeIndex(["12/31/1998", "1/3/1999", "1/4/1999"])
+    assert frequencies.infer_freq(index) is None
+
+
+def test_day_corner():
+    index = DatetimeIndex(["1/1/2000", "1/2/2000", "1/3/2000"])
+    assert frequencies.infer_freq(index) == "D"
+
+
+def test_non_datetime_index():
+    dates = to_datetime(["1/1/2000", "1/2/2000", "1/3/2000"])
+    assert frequencies.infer_freq(dates) == "D"
+
+
+def test_fifth_week_of_month_infer():
+    # see gh-9425
+    #
+    # Only attempt to infer up to WOM-4.
+    index = DatetimeIndex(["2014-03-31", "2014-06-30", "2015-03-30"])
+    assert frequencies.infer_freq(index) is None
+
+
+def test_week_of_month_fake():
+    # All of these dates are on same day
+    # of week and are 4 or 5 weeks apart.
+    index = DatetimeIndex(["2013-08-27", "2013-10-01", "2013-10-29", "2013-11-26"])
+    assert frequencies.infer_freq(index) != "WOM-4TUE"
+
+
+def test_fifth_week_of_month():
+    # see gh-9425
+    #
+    # Only supports freq up to WOM-4.
+    msg = (
+        "Of the four parameters: start, end, periods, "
+        "and freq, exactly three must be specified"
+    )
+
+    with pytest.raises(ValueError, match=msg):
+        date_range("2014-01-01", freq="WOM-5MON")
+
+
+def test_monthly_ambiguous():
+    rng = DatetimeIndex(["1/31/2000", "2/29/2000", "3/31/2000"])
+    assert rng.inferred_freq == "ME"
+
+
+def test_annual_ambiguous():
+    rng = DatetimeIndex(["1/31/2000", "1/31/2001", "1/31/2002"])
+    assert rng.inferred_freq == "YE-JAN"
+
+
+@pytest.mark.parametrize("count", range(1, 5))
+def test_infer_freq_delta(base_delta_code_pair, count):
+    b = Timestamp(datetime.now())
+    base_delta, code = base_delta_code_pair
+
+    inc = base_delta * count
+    index = DatetimeIndex([b + inc * j for j in range(3)])
+
+    exp_freq = f"{count:d}{code}" if count > 1 else code
+    assert frequencies.infer_freq(index) == exp_freq
+
+
+@pytest.mark.parametrize(
+    "constructor",
+    [
+        lambda now, delta: DatetimeIndex(
+            [now + delta * 7] + [now + delta * j for j in range(3)]
+        ),
+        lambda now, delta: DatetimeIndex(
+            [now + delta * j for j in range(3)] + [now + delta * 7]
+        ),
+    ],
+)
+def test_infer_freq_custom(base_delta_code_pair, constructor):
+    b = Timestamp(datetime.now())
+    base_delta, _ = base_delta_code_pair
+
+    index = constructor(b, base_delta)
+    assert frequencies.infer_freq(index) is None
+
+
+@pytest.mark.parametrize(
+    "freq,expected", [("Q", "QE-DEC"), ("Q-NOV", "QE-NOV"), ("Q-OCT", "QE-OCT")]
+)
+def test_infer_freq_index(freq, expected):
+    rng = period_range("1959Q2", "2009Q3", freq=freq)
+    with tm.assert_produces_warning(FutureWarning, match="Dtype inference"):
+        rng = Index(rng.to_timestamp("D", how="e").astype(object))
+
+    assert rng.inferred_freq == expected
+
+
+@pytest.mark.parametrize(
+    "expected,dates",
+    list(
+        {
+            "YS-JAN": ["2009-01-01", "2010-01-01", "2011-01-01", "2012-01-01"],
+            "QE-OCT": ["2009-01-31", "2009-04-30", "2009-07-31", "2009-10-31"],
+            "ME": ["2010-11-30", "2010-12-31", "2011-01-31", "2011-02-28"],
+            "W-SAT": ["2010-12-25", "2011-01-01", "2011-01-08", "2011-01-15"],
+            "D": ["2011-01-01", "2011-01-02", "2011-01-03", "2011-01-04"],
+            "h": [
+                "2011-12-31 22:00",
+                "2011-12-31 23:00",
+                "2012-01-01 00:00",
+                "2012-01-01 01:00",
+            ],
+        }.items()
+    ),
+)
+@pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
+def test_infer_freq_tz(tz_naive_fixture, expected, dates, unit):
+    # see gh-7310, GH#55609
+    tz = tz_naive_fixture
+    idx = DatetimeIndex(dates, tz=tz).as_unit(unit)
+    assert idx.inferred_freq == expected
+
+
+def test_infer_freq_tz_series(tz_naive_fixture):
+    # infer_freq should work with both tz-naive and tz-aware series. See gh-52456
+    tz = tz_naive_fixture
+    idx = date_range("2021-01-01", "2021-01-04", tz=tz)
+    series = idx.to_series().reset_index(drop=True)
+    inferred_freq = frequencies.infer_freq(series)
+    assert inferred_freq == "D"
+
+
+@pytest.mark.parametrize(
+    "date_pair",
+    [
+        ["2013-11-02", "2013-11-5"],  # Fall DST
+        ["2014-03-08", "2014-03-11"],  # Spring DST
+        ["2014-01-01", "2014-01-03"],  # Regular Time
+    ],
+)
+@pytest.mark.parametrize(
+    "freq",
+    ["h", "3h", "10min", "3601s", "3600001ms", "3600000001us", "3600000000001ns"],
+)
+def test_infer_freq_tz_transition(tz_naive_fixture, date_pair, freq):
+    # see gh-8772
+    tz = tz_naive_fixture
+    idx = date_range(date_pair[0], date_pair[1], freq=freq, tz=tz)
+    assert idx.inferred_freq == freq
+
+
+def test_infer_freq_tz_transition_custom():
+    index = date_range("2013-11-03", periods=5, freq="3h").tz_localize(
+        "America/Chicago"
+    )
+    assert index.inferred_freq is None
+
+
+@pytest.mark.parametrize(
+    "data,expected",
+    [
+        # Hourly freq in a day must result in "h"
+        (
+            [
+                "2014-07-01 09:00",
+                "2014-07-01 10:00",
+                "2014-07-01 11:00",
+                "2014-07-01 12:00",
+                "2014-07-01 13:00",
+                "2014-07-01 14:00",
+            ],
+            "h",
+        ),
+        (
+            [
+                "2014-07-01 09:00",
+                "2014-07-01 10:00",
+                "2014-07-01 11:00",
+                "2014-07-01 12:00",
+                "2014-07-01 13:00",
+                "2014-07-01 14:00",
+                "2014-07-01 15:00",
+                "2014-07-01 16:00",
+                "2014-07-02 09:00",
+                "2014-07-02 10:00",
+                "2014-07-02 11:00",
+            ],
+            "bh",
+        ),
+        (
+            [
+                "2014-07-04 09:00",
+                "2014-07-04 10:00",
+                "2014-07-04 11:00",
+                "2014-07-04 12:00",
+                "2014-07-04 13:00",
+                "2014-07-04 14:00",
+                "2014-07-04 15:00",
+                "2014-07-04 16:00",
+                "2014-07-07 09:00",
+                "2014-07-07 10:00",
+                "2014-07-07 11:00",
+            ],
+            "bh",
+        ),
+        (
+            [
+                "2014-07-04 09:00",
+                "2014-07-04 10:00",
+                "2014-07-04 11:00",
+                "2014-07-04 12:00",
+                "2014-07-04 13:00",
+                "2014-07-04 14:00",
+                "2014-07-04 15:00",
+                "2014-07-04 16:00",
+                "2014-07-07 09:00",
+                "2014-07-07 10:00",
+                "2014-07-07 11:00",
+                "2014-07-07 12:00",
+                "2014-07-07 13:00",
+                "2014-07-07 14:00",
+                "2014-07-07 15:00",
+                "2014-07-07 16:00",
+                "2014-07-08 09:00",
+                "2014-07-08 10:00",
+                "2014-07-08 11:00",
+                "2014-07-08 12:00",
+                "2014-07-08 13:00",
+                "2014-07-08 14:00",
+                "2014-07-08 15:00",
+                "2014-07-08 16:00",
+            ],
+            "bh",
+        ),
+    ],
+)
+def test_infer_freq_business_hour(data, expected):
+    # see gh-7905
+    idx = DatetimeIndex(data)
+    assert idx.inferred_freq == expected
+
+
+def test_not_monotonic():
+    rng = DatetimeIndex(["1/31/2000", "1/31/2001", "1/31/2002"])
+    rng = rng[::-1]
+
+    assert rng.inferred_freq == "-1YE-JAN"
+
+
+def test_non_datetime_index2():
+    rng = DatetimeIndex(["1/31/2000", "1/31/2001", "1/31/2002"])
+    vals = rng.to_pydatetime()
+
+    result = frequencies.infer_freq(vals)
+    assert result == rng.inferred_freq
+
+
+@pytest.mark.parametrize(
+    "idx",
+    [
+        Index(np.arange(5), dtype=np.int64),
+        Index(np.arange(5), dtype=np.float64),
+        period_range("2020-01-01", periods=5),
+        RangeIndex(5),
+    ],
+)
+def test_invalid_index_types(idx):
+    # see gh-48439
+    msg = "|".join(
+        [
+            "cannot infer freq from a non-convertible",
+            "Check the `freq` attribute instead of using infer_freq",
+        ]
+    )
+
+    with pytest.raises(TypeError, match=msg):
+        frequencies.infer_freq(idx)
+
+
+@pytest.mark.skipif(is_platform_windows(), reason="see gh-10822: Windows issue")
+def test_invalid_index_types_unicode():
+    # see gh-10822
+    #
+    # Odd error message on conversions to datetime for unicode.
+    msg = "Unknown datetime string format"
+
+    with pytest.raises(ValueError, match=msg):
+        frequencies.infer_freq(Index(["ZqgszYBfuL"]))
+
+
+def test_string_datetime_like_compat():
+    # see gh-6463
+    data = ["2004-01", "2004-02", "2004-03", "2004-04"]
+
+    expected = frequencies.infer_freq(data)
+    result = frequencies.infer_freq(Index(data))
+
+    assert result == expected
+
+
+def test_series():
+    # see gh-6407
+    s = Series(date_range("20130101", "20130110"))
+    inferred = frequencies.infer_freq(s)
+    assert inferred == "D"
+
+
+@pytest.mark.parametrize("end", [10, 10.0])
+def test_series_invalid_type(end):
+    # see gh-6407
+    msg = "cannot infer freq from a non-convertible dtype on a Series"
+    s = Series(np.arange(end))
+
+    with pytest.raises(TypeError, match=msg):
+        frequencies.infer_freq(s)
+
+
+def test_series_inconvertible_string(using_infer_string):
+    # see gh-6407
+    if using_infer_string:
+        msg = "cannot infer freq from"
+
+        with pytest.raises(TypeError, match=msg):
+            frequencies.infer_freq(Series(["foo", "bar"]))
+    else:
+        msg = "Unknown datetime string format"
+
+        with pytest.raises(ValueError, match=msg):
+            frequencies.infer_freq(Series(["foo", "bar"]))
+
+
+@pytest.mark.parametrize("freq", [None, "ms"])
+def test_series_period_index(freq):
+    # see gh-6407
+    #
+    # Cannot infer on PeriodIndex
+    msg = "cannot infer freq from a non-convertible dtype on a Series"
+    s = Series(period_range("2013", periods=10, freq=freq))
+
+    with pytest.raises(TypeError, match=msg):
+        frequencies.infer_freq(s)
+
+
+@pytest.mark.parametrize("freq", ["ME", "ms", "s"])
+def test_series_datetime_index(freq):
+    s = Series(date_range("20130101", periods=10, freq=freq))
+    inferred = frequencies.infer_freq(s)
+    assert inferred == freq
+
+
+@pytest.mark.parametrize(
+    "offset_func",
+    [
+        _get_offset,
+        lambda freq: date_range("2011-01-01", periods=5, freq=freq),
+    ],
+)
+@pytest.mark.parametrize(
+    "freq",
+    [
+        "WEEKDAY",
+        "EOM",
+        "W@MON",
+        "W@TUE",
+        "W@WED",
+        "W@THU",
+        "W@FRI",
+        "W@SAT",
+        "W@SUN",
+        "QE@JAN",
+        "QE@FEB",
+        "QE@MAR",
+        "YE@JAN",
+        "YE@FEB",
+        "YE@MAR",
+        "YE@APR",
+        "YE@MAY",
+        "YE@JUN",
+        "YE@JUL",
+        "YE@AUG",
+        "YE@SEP",
+        "YE@OCT",
+        "YE@NOV",
+        "YE@DEC",
+        "YE@JAN",
+        "WOM@1MON",
+        "WOM@2MON",
+        "WOM@3MON",
+        "WOM@4MON",
+        "WOM@1TUE",
+        "WOM@2TUE",
+        "WOM@3TUE",
+        "WOM@4TUE",
+        "WOM@1WED",
+        "WOM@2WED",
+        "WOM@3WED",
+        "WOM@4WED",
+        "WOM@1THU",
+        "WOM@2THU",
+        "WOM@3THU",
+        "WOM@4THU",
+        "WOM@1FRI",
+        "WOM@2FRI",
+        "WOM@3FRI",
+        "WOM@4FRI",
+    ],
+)
+def test_legacy_offset_warnings(offset_func, freq):
+    with pytest.raises(ValueError, match=INVALID_FREQ_ERR_MSG):
+        offset_func(freq)
+
+
+def test_ms_vs_capital_ms():
+    left = _get_offset("ms")
+    right = _get_offset("MS")
+
+    assert left == offsets.Milli()
+    assert right == offsets.MonthBegin()
+
+
+def test_infer_freq_non_nano():
+    arr = np.arange(10).astype(np.int64).view("M8[s]")
+    dta = DatetimeArray._simple_new(arr, dtype=arr.dtype)
+    res = frequencies.infer_freq(dta)
+    assert res == "s"
+
+    arr2 = arr.view("m8[ms]")
+    tda = TimedeltaArray._simple_new(arr2, dtype=arr2.dtype)
+    res2 = frequencies.infer_freq(tda)
+    assert res2 == "ms"
+
+
+def test_infer_freq_non_nano_tzaware(tz_aware_fixture):
+    tz = tz_aware_fixture
+
+    dti = date_range("2016-01-01", periods=365, freq="B", tz=tz)
+    dta = dti._data.as_unit("s")
+
+    res = frequencies.infer_freq(dta)
+    assert res == "B"