Add files using upload-large-folder tool

llmeval-env/lib/python3.10/site-packages/pandas/tests/generic/test_duplicate_labels.py

@@ -0,0 +1,413 @@
+"""Tests dealing with the NDFrame.allows_duplicates."""
+import operator
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+not_implemented = pytest.mark.xfail(reason="Not implemented.")
+
+# ----------------------------------------------------------------------------
+# Preservation
+
+
+class TestPreserves:
+    @pytest.mark.parametrize(
+        "cls, data",
+        [
+            (pd.Series, np.array([])),
+            (pd.Series, [1, 2]),
+            (pd.DataFrame, {}),
+            (pd.DataFrame, {"A": [1, 2]}),
+        ],
+    )
+    def test_construction_ok(self, cls, data):
+        result = cls(data)
+        assert result.flags.allows_duplicate_labels is True
+
+        result = cls(data).set_flags(allows_duplicate_labels=False)
+        assert result.flags.allows_duplicate_labels is False
+
+    @pytest.mark.parametrize(
+        "func",
+        [
+            operator.itemgetter(["a"]),
+            operator.methodcaller("add", 1),
+            operator.methodcaller("rename", str.upper),
+            operator.methodcaller("rename", "name"),
+            operator.methodcaller("abs"),
+            np.abs,
+        ],
+    )
+    def test_preserved_series(self, func):
+        s = pd.Series([0, 1], index=["a", "b"]).set_flags(allows_duplicate_labels=False)
+        assert func(s).flags.allows_duplicate_labels is False
+
+    @pytest.mark.parametrize(
+        "other", [pd.Series(0, index=["a", "b", "c"]), pd.Series(0, index=["a", "b"])]
+    )
+    # TODO: frame
+    @not_implemented
+    def test_align(self, other):
+        s = pd.Series([0, 1], index=["a", "b"]).set_flags(allows_duplicate_labels=False)
+        a, b = s.align(other)
+        assert a.flags.allows_duplicate_labels is False
+        assert b.flags.allows_duplicate_labels is False
+
+    def test_preserved_frame(self):
+        df = pd.DataFrame({"A": [1, 2], "B": [3, 4]}, index=["a", "b"]).set_flags(
+            allows_duplicate_labels=False
+        )
+        assert df.loc[["a"]].flags.allows_duplicate_labels is False
+        assert df.loc[:, ["A", "B"]].flags.allows_duplicate_labels is False
+
+    def test_to_frame(self):
+        ser = pd.Series(dtype=float).set_flags(allows_duplicate_labels=False)
+        assert ser.to_frame().flags.allows_duplicate_labels is False
+
+    @pytest.mark.parametrize("func", ["add", "sub"])
+    @pytest.mark.parametrize("frame", [False, True])
+    @pytest.mark.parametrize("other", [1, pd.Series([1, 2], name="A")])
+    def test_binops(self, func, other, frame):
+        df = pd.Series([1, 2], name="A", index=["a", "b"]).set_flags(
+            allows_duplicate_labels=False
+        )
+        if frame:
+            df = df.to_frame()
+        if isinstance(other, pd.Series) and frame:
+            other = other.to_frame()
+        func = operator.methodcaller(func, other)
+        assert df.flags.allows_duplicate_labels is False
+        assert func(df).flags.allows_duplicate_labels is False
+
+    def test_preserve_getitem(self):
+        df = pd.DataFrame({"A": [1, 2]}).set_flags(allows_duplicate_labels=False)
+        assert df[["A"]].flags.allows_duplicate_labels is False
+        assert df["A"].flags.allows_duplicate_labels is False
+        assert df.loc[0].flags.allows_duplicate_labels is False
+        assert df.loc[[0]].flags.allows_duplicate_labels is False
+        assert df.loc[0, ["A"]].flags.allows_duplicate_labels is False
+
+    def test_ndframe_getitem_caching_issue(
+        self, request, using_copy_on_write, warn_copy_on_write
+    ):
+        if not (using_copy_on_write or warn_copy_on_write):
+            request.applymarker(pytest.mark.xfail(reason="Unclear behavior."))
+        # NDFrame.__getitem__ will cache the first df['A']. May need to
+        # invalidate that cache? Update the cached entries?
+        df = pd.DataFrame({"A": [0]}).set_flags(allows_duplicate_labels=False)
+        assert df["A"].flags.allows_duplicate_labels is False
+        df.flags.allows_duplicate_labels = True
+        assert df["A"].flags.allows_duplicate_labels is True
+
+    @pytest.mark.parametrize(
+        "objs, kwargs",
+        [
+            # Series
+            (
+                [
+                    pd.Series(1, index=["a", "b"]),
+                    pd.Series(2, index=["c", "d"]),
+                ],
+                {},
+            ),
+            (
+                [
+                    pd.Series(1, index=["a", "b"]),
+                    pd.Series(2, index=["a", "b"]),
+                ],
+                {"ignore_index": True},
+            ),
+            (
+                [
+                    pd.Series(1, index=["a", "b"]),
+                    pd.Series(2, index=["a", "b"]),
+                ],
+                {"axis": 1},
+            ),
+            # Frame
+            (
+                [
+                    pd.DataFrame({"A": [1, 2]}, index=["a", "b"]),
+                    pd.DataFrame({"A": [1, 2]}, index=["c", "d"]),
+                ],
+                {},
+            ),
+            (
+                [
+                    pd.DataFrame({"A": [1, 2]}, index=["a", "b"]),
+                    pd.DataFrame({"A": [1, 2]}, index=["a", "b"]),
+                ],
+                {"ignore_index": True},
+            ),
+            (
+                [
+                    pd.DataFrame({"A": [1, 2]}, index=["a", "b"]),
+                    pd.DataFrame({"B": [1, 2]}, index=["a", "b"]),
+                ],
+                {"axis": 1},
+            ),
+            # Series / Frame
+            (
+                [
+                    pd.DataFrame({"A": [1, 2]}, index=["a", "b"]),
+                    pd.Series([1, 2], index=["a", "b"], name="B"),
+                ],
+                {"axis": 1},
+            ),
+        ],
+    )
+    def test_concat(self, objs, kwargs):
+        objs = [x.set_flags(allows_duplicate_labels=False) for x in objs]
+        result = pd.concat(objs, **kwargs)
+        assert result.flags.allows_duplicate_labels is False
+
+    @pytest.mark.parametrize(
+        "left, right, expected",
+        [
+            # false false false
+            pytest.param(
+                pd.DataFrame({"A": [0, 1]}, index=["a", "b"]).set_flags(
+                    allows_duplicate_labels=False
+                ),
+                pd.DataFrame({"B": [0, 1]}, index=["a", "d"]).set_flags(
+                    allows_duplicate_labels=False
+                ),
+                False,
+                marks=not_implemented,
+            ),
+            # false true false
+            pytest.param(
+                pd.DataFrame({"A": [0, 1]}, index=["a", "b"]).set_flags(
+                    allows_duplicate_labels=False
+                ),
+                pd.DataFrame({"B": [0, 1]}, index=["a", "d"]),
+                False,
+                marks=not_implemented,
+            ),
+            # true true true
+            (
+                pd.DataFrame({"A": [0, 1]}, index=["a", "b"]),
+                pd.DataFrame({"B": [0, 1]}, index=["a", "d"]),
+                True,
+            ),
+        ],
+    )
+    def test_merge(self, left, right, expected):
+        result = pd.merge(left, right, left_index=True, right_index=True)
+        assert result.flags.allows_duplicate_labels is expected
+
+    @not_implemented
+    def test_groupby(self):
+        # XXX: This is under tested
+        # TODO:
+        #  - apply
+        #  - transform
+        #  - Should passing a grouper that disallows duplicates propagate?
+        df = pd.DataFrame({"A": [1, 2, 3]}).set_flags(allows_duplicate_labels=False)
+        result = df.groupby([0, 0, 1]).agg("count")
+        assert result.flags.allows_duplicate_labels is False
+
+    @pytest.mark.parametrize("frame", [True, False])
+    @not_implemented
+    def test_window(self, frame):
+        df = pd.Series(
+            1,
+            index=pd.date_range("2000", periods=12),
+            name="A",
+            allows_duplicate_labels=False,
+        )
+        if frame:
+            df = df.to_frame()
+        assert df.rolling(3).mean().flags.allows_duplicate_labels is False
+        assert df.ewm(3).mean().flags.allows_duplicate_labels is False
+        assert df.expanding(3).mean().flags.allows_duplicate_labels is False
+
+
+# ----------------------------------------------------------------------------
+# Raises
+
+
+class TestRaises:
+    @pytest.mark.parametrize(
+        "cls, axes",
+        [
+            (pd.Series, {"index": ["a", "a"], "dtype": float}),
+            (pd.DataFrame, {"index": ["a", "a"]}),
+            (pd.DataFrame, {"index": ["a", "a"], "columns": ["b", "b"]}),
+            (pd.DataFrame, {"columns": ["b", "b"]}),
+        ],
+    )
+    def test_set_flags_with_duplicates(self, cls, axes):
+        result = cls(**axes)
+        assert result.flags.allows_duplicate_labels is True
+
+        msg = "Index has duplicates."
+        with pytest.raises(pd.errors.DuplicateLabelError, match=msg):
+            cls(**axes).set_flags(allows_duplicate_labels=False)
+
+    @pytest.mark.parametrize(
+        "data",
+        [
+            pd.Series(index=[0, 0], dtype=float),
+            pd.DataFrame(index=[0, 0]),
+            pd.DataFrame(columns=[0, 0]),
+        ],
+    )
+    def test_setting_allows_duplicate_labels_raises(self, data):
+        msg = "Index has duplicates."
+        with pytest.raises(pd.errors.DuplicateLabelError, match=msg):
+            data.flags.allows_duplicate_labels = False
+
+        assert data.flags.allows_duplicate_labels is True
+
+    def test_series_raises(self):
+        a = pd.Series(0, index=["a", "b"])
+        b = pd.Series([0, 1], index=["a", "b"]).set_flags(allows_duplicate_labels=False)
+        msg = "Index has duplicates."
+        with pytest.raises(pd.errors.DuplicateLabelError, match=msg):
+            pd.concat([a, b])
+
+    @pytest.mark.parametrize(
+        "getter, target",
+        [
+            (operator.itemgetter(["A", "A"]), None),
+            # loc
+            (operator.itemgetter(["a", "a"]), "loc"),
+            pytest.param(operator.itemgetter(("a", ["A", "A"])), "loc"),
+            (operator.itemgetter((["a", "a"], "A")), "loc"),
+            # iloc
+            (operator.itemgetter([0, 0]), "iloc"),
+            pytest.param(operator.itemgetter((0, [0, 0])), "iloc"),
+            pytest.param(operator.itemgetter(([0, 0], 0)), "iloc"),
+        ],
+    )
+    def test_getitem_raises(self, getter, target):
+        df = pd.DataFrame({"A": [1, 2], "B": [3, 4]}, index=["a", "b"]).set_flags(
+            allows_duplicate_labels=False
+        )
+        if target:
+            # df, df.loc, or df.iloc
+            target = getattr(df, target)
+        else:
+            target = df
+
+        msg = "Index has duplicates."
+        with pytest.raises(pd.errors.DuplicateLabelError, match=msg):
+            getter(target)
+
+    @pytest.mark.parametrize(
+        "objs, kwargs",
+        [
+            (
+                [
+                    pd.Series(1, index=[0, 1], name="a"),
+                    pd.Series(2, index=[0, 1], name="a"),
+                ],
+                {"axis": 1},
+            )
+        ],
+    )
+    def test_concat_raises(self, objs, kwargs):
+        objs = [x.set_flags(allows_duplicate_labels=False) for x in objs]
+        msg = "Index has duplicates."
+        with pytest.raises(pd.errors.DuplicateLabelError, match=msg):
+            pd.concat(objs, **kwargs)
+
+    @not_implemented
+    def test_merge_raises(self):
+        a = pd.DataFrame({"A": [0, 1, 2]}, index=["a", "b", "c"]).set_flags(
+            allows_duplicate_labels=False
+        )
+        b = pd.DataFrame({"B": [0, 1, 2]}, index=["a", "b", "b"])
+        msg = "Index has duplicates."
+        with pytest.raises(pd.errors.DuplicateLabelError, match=msg):
+            pd.merge(a, b, left_index=True, right_index=True)
+
+
+@pytest.mark.parametrize(
+    "idx",
+    [
+        pd.Index([1, 1]),
+        pd.Index(["a", "a"]),
+        pd.Index([1.1, 1.1]),
+        pd.PeriodIndex([pd.Period("2000", "D")] * 2),
+        pd.DatetimeIndex([pd.Timestamp("2000")] * 2),
+        pd.TimedeltaIndex([pd.Timedelta("1D")] * 2),
+        pd.CategoricalIndex(["a", "a"]),
+        pd.IntervalIndex([pd.Interval(0, 1)] * 2),
+        pd.MultiIndex.from_tuples([("a", 1), ("a", 1)]),
+    ],
+    ids=lambda x: type(x).__name__,
+)
+def test_raises_basic(idx):
+    msg = "Index has duplicates."
+    with pytest.raises(pd.errors.DuplicateLabelError, match=msg):
+        pd.Series(1, index=idx).set_flags(allows_duplicate_labels=False)
+
+    with pytest.raises(pd.errors.DuplicateLabelError, match=msg):
+        pd.DataFrame({"A": [1, 1]}, index=idx).set_flags(allows_duplicate_labels=False)
+
+    with pytest.raises(pd.errors.DuplicateLabelError, match=msg):
+        pd.DataFrame([[1, 2]], columns=idx).set_flags(allows_duplicate_labels=False)
+
+
+def test_format_duplicate_labels_message():
+    idx = pd.Index(["a", "b", "a", "b", "c"])
+    result = idx._format_duplicate_message()
+    expected = pd.DataFrame(
+        {"positions": [[0, 2], [1, 3]]}, index=pd.Index(["a", "b"], name="label")
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_format_duplicate_labels_message_multi():
+    idx = pd.MultiIndex.from_product([["A"], ["a", "b", "a", "b", "c"]])
+    result = idx._format_duplicate_message()
+    expected = pd.DataFrame(
+        {"positions": [[0, 2], [1, 3]]},
+        index=pd.MultiIndex.from_product([["A"], ["a", "b"]]),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_dataframe_insert_raises():
+    df = pd.DataFrame({"A": [1, 2]}).set_flags(allows_duplicate_labels=False)
+    msg = "Cannot specify"
+    with pytest.raises(ValueError, match=msg):
+        df.insert(0, "A", [3, 4], allow_duplicates=True)
+
+
+@pytest.mark.parametrize(
+    "method, frame_only",
+    [
+        (operator.methodcaller("set_index", "A", inplace=True), True),
+        (operator.methodcaller("reset_index", inplace=True), True),
+        (operator.methodcaller("rename", lambda x: x, inplace=True), False),
+    ],
+)
+def test_inplace_raises(method, frame_only):
+    df = pd.DataFrame({"A": [0, 0], "B": [1, 2]}).set_flags(
+        allows_duplicate_labels=False
+    )
+    s = df["A"]
+    s.flags.allows_duplicate_labels = False
+    msg = "Cannot specify"
+
+    with pytest.raises(ValueError, match=msg):
+        method(df)
+    if not frame_only:
+        with pytest.raises(ValueError, match=msg):
+            method(s)
+
+
+def test_pickle():
+    a = pd.Series([1, 2]).set_flags(allows_duplicate_labels=False)
+    b = tm.round_trip_pickle(a)
+    tm.assert_series_equal(a, b)
+
+    a = pd.DataFrame({"A": []}).set_flags(allows_duplicate_labels=False)
+    b = tm.round_trip_pickle(a)
+    tm.assert_frame_equal(a, b)

llmeval-env/lib/python3.10/site-packages/pandas/tests/generic/test_finalize.py

@@ -0,0 +1,767 @@
+"""
+An exhaustive list of pandas methods exercising NDFrame.__finalize__.
+"""
+import operator
+import re
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+# TODO:
+# * Binary methods (mul, div, etc.)
+# * Binary outputs (align, etc.)
+# * top-level methods (concat, merge, get_dummies, etc.)
+# * window
+# * cumulative reductions
+
+not_implemented_mark = pytest.mark.xfail(reason="not implemented")
+
+mi = pd.MultiIndex.from_product([["a", "b"], [0, 1]], names=["A", "B"])
+
+frame_data = ({"A": [1]},)
+frame_mi_data = ({"A": [1, 2, 3, 4]}, mi)
+
+
+# Tuple of
+# - Callable: Constructor (Series, DataFrame)
+# - Tuple: Constructor args
+# - Callable: pass the constructed value with attrs set to this.
+
+_all_methods = [
+    (pd.Series, ([0],), operator.methodcaller("take", [])),
+    (pd.Series, ([0],), operator.methodcaller("__getitem__", [True])),
+    (pd.Series, ([0],), operator.methodcaller("repeat", 2)),
+    (pd.Series, ([0],), operator.methodcaller("reset_index")),
+    (pd.Series, ([0],), operator.methodcaller("reset_index", drop=True)),
+    (pd.Series, ([0],), operator.methodcaller("to_frame")),
+    (pd.Series, ([0, 0],), operator.methodcaller("drop_duplicates")),
+    (pd.Series, ([0, 0],), operator.methodcaller("duplicated")),
+    (pd.Series, ([0, 0],), operator.methodcaller("round")),
+    (pd.Series, ([0, 0],), operator.methodcaller("rename", lambda x: x + 1)),
+    (pd.Series, ([0, 0],), operator.methodcaller("rename", "name")),
+    (pd.Series, ([0, 0],), operator.methodcaller("set_axis", ["a", "b"])),
+    (pd.Series, ([0, 0],), operator.methodcaller("reindex", [1, 0])),
+    (pd.Series, ([0, 0],), operator.methodcaller("drop", [0])),
+    (pd.Series, (pd.array([0, pd.NA]),), operator.methodcaller("fillna", 0)),
+    (pd.Series, ([0, 0],), operator.methodcaller("replace", {0: 1})),
+    (pd.Series, ([0, 0],), operator.methodcaller("shift")),
+    (pd.Series, ([0, 0],), operator.methodcaller("isin", [0, 1])),
+    (pd.Series, ([0, 0],), operator.methodcaller("between", 0, 2)),
+    (pd.Series, ([0, 0],), operator.methodcaller("isna")),
+    (pd.Series, ([0, 0],), operator.methodcaller("isnull")),
+    (pd.Series, ([0, 0],), operator.methodcaller("notna")),
+    (pd.Series, ([0, 0],), operator.methodcaller("notnull")),
+    (pd.Series, ([1],), operator.methodcaller("add", pd.Series([1]))),
+    # TODO: mul, div, etc.
+    (
+        pd.Series,
+        ([0], pd.period_range("2000", periods=1)),
+        operator.methodcaller("to_timestamp"),
+    ),
+    (
+        pd.Series,
+        ([0], pd.date_range("2000", periods=1)),
+        operator.methodcaller("to_period"),
+    ),
+    pytest.param(
+        (
+            pd.DataFrame,
+            frame_data,
+            operator.methodcaller("dot", pd.DataFrame(index=["A"])),
+        ),
+        marks=pytest.mark.xfail(reason="Implement binary finalize"),
+    ),
+    (pd.DataFrame, frame_data, operator.methodcaller("transpose")),
+    (pd.DataFrame, frame_data, operator.methodcaller("__getitem__", "A")),
+    (pd.DataFrame, frame_data, operator.methodcaller("__getitem__", ["A"])),
+    (pd.DataFrame, frame_data, operator.methodcaller("__getitem__", np.array([True]))),
+    (pd.DataFrame, ({("A", "a"): [1]},), operator.methodcaller("__getitem__", ["A"])),
+    (pd.DataFrame, frame_data, operator.methodcaller("query", "A == 1")),
+    (pd.DataFrame, frame_data, operator.methodcaller("eval", "A + 1", engine="python")),
+    (pd.DataFrame, frame_data, operator.methodcaller("select_dtypes", include="int")),
+    (pd.DataFrame, frame_data, operator.methodcaller("assign", b=1)),
+    (pd.DataFrame, frame_data, operator.methodcaller("set_axis", ["A"])),
+    (pd.DataFrame, frame_data, operator.methodcaller("reindex", [0, 1])),
+    (pd.DataFrame, frame_data, operator.methodcaller("drop", columns=["A"])),
+    (pd.DataFrame, frame_data, operator.methodcaller("drop", index=[0])),
+    (pd.DataFrame, frame_data, operator.methodcaller("rename", columns={"A": "a"})),
+    (pd.DataFrame, frame_data, operator.methodcaller("rename", index=lambda x: x)),
+    (pd.DataFrame, frame_data, operator.methodcaller("fillna", "A")),
+    (pd.DataFrame, frame_data, operator.methodcaller("fillna", method="ffill")),
+    (pd.DataFrame, frame_data, operator.methodcaller("set_index", "A")),
+    (pd.DataFrame, frame_data, operator.methodcaller("reset_index")),
+    (pd.DataFrame, frame_data, operator.methodcaller("isna")),
+    (pd.DataFrame, frame_data, operator.methodcaller("isnull")),
+    (pd.DataFrame, frame_data, operator.methodcaller("notna")),
+    (pd.DataFrame, frame_data, operator.methodcaller("notnull")),
+    (pd.DataFrame, frame_data, operator.methodcaller("dropna")),
+    (pd.DataFrame, frame_data, operator.methodcaller("drop_duplicates")),
+    (pd.DataFrame, frame_data, operator.methodcaller("duplicated")),
+    (pd.DataFrame, frame_data, operator.methodcaller("sort_values", by="A")),
+    (pd.DataFrame, frame_data, operator.methodcaller("sort_index")),
+    (pd.DataFrame, frame_data, operator.methodcaller("nlargest", 1, "A")),
+    (pd.DataFrame, frame_data, operator.methodcaller("nsmallest", 1, "A")),
+    (pd.DataFrame, frame_mi_data, operator.methodcaller("swaplevel")),
+    (
+        pd.DataFrame,
+        frame_data,
+        operator.methodcaller("add", pd.DataFrame(*frame_data)),
+    ),
+    # TODO: div, mul, etc.
+    (
+        pd.DataFrame,
+        frame_data,
+        operator.methodcaller("combine", pd.DataFrame(*frame_data), operator.add),
+    ),
+    (
+        pd.DataFrame,
+        frame_data,
+        operator.methodcaller("combine_first", pd.DataFrame(*frame_data)),
+    ),
+    pytest.param(
+        (
+            pd.DataFrame,
+            frame_data,
+            operator.methodcaller("update", pd.DataFrame(*frame_data)),
+        ),
+        marks=not_implemented_mark,
+    ),
+    (pd.DataFrame, frame_data, operator.methodcaller("pivot", columns="A")),
+    (
+        pd.DataFrame,
+        ({"A": [1], "B": [1]},),
+        operator.methodcaller("pivot_table", columns="A"),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [1], "B": [1]},),
+        operator.methodcaller("pivot_table", columns="A", aggfunc=["mean", "sum"]),
+    ),
+    (pd.DataFrame, frame_data, operator.methodcaller("stack")),
+    (pd.DataFrame, frame_data, operator.methodcaller("explode", "A")),
+    (pd.DataFrame, frame_mi_data, operator.methodcaller("unstack")),
+    (
+        pd.DataFrame,
+        ({"A": ["a", "b", "c"], "B": [1, 3, 5], "C": [2, 4, 6]},),
+        operator.methodcaller("melt", id_vars=["A"], value_vars=["B"]),
+    ),
+    (pd.DataFrame, frame_data, operator.methodcaller("map", lambda x: x)),
+    pytest.param(
+        (
+            pd.DataFrame,
+            frame_data,
+            operator.methodcaller("merge", pd.DataFrame({"A": [1]})),
+        ),
+        marks=not_implemented_mark,
+    ),
+    (pd.DataFrame, frame_data, operator.methodcaller("round", 2)),
+    (pd.DataFrame, frame_data, operator.methodcaller("corr")),
+    pytest.param(
+        (pd.DataFrame, frame_data, operator.methodcaller("cov")),
+        marks=[
+            pytest.mark.filterwarnings("ignore::RuntimeWarning"),
+        ],
+    ),
+    (
+        pd.DataFrame,
+        frame_data,
+        operator.methodcaller("corrwith", pd.DataFrame(*frame_data)),
+    ),
+    (pd.DataFrame, frame_data, operator.methodcaller("count")),
+    (pd.DataFrame, frame_data, operator.methodcaller("nunique")),
+    (pd.DataFrame, frame_data, operator.methodcaller("idxmin")),
+    (pd.DataFrame, frame_data, operator.methodcaller("idxmax")),
+    (pd.DataFrame, frame_data, operator.methodcaller("mode")),
+    (pd.Series, [0], operator.methodcaller("mode")),
+    (pd.DataFrame, frame_data, operator.methodcaller("median")),
+    (
+        pd.DataFrame,
+        frame_data,
+        operator.methodcaller("quantile", numeric_only=True),
+    ),
+    (
+        pd.DataFrame,
+        frame_data,
+        operator.methodcaller("quantile", q=[0.25, 0.75], numeric_only=True),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [pd.Timedelta(days=1), pd.Timedelta(days=2)]},),
+        operator.methodcaller("quantile", numeric_only=False),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [np.datetime64("2022-01-01"), np.datetime64("2022-01-02")]},),
+        operator.methodcaller("quantile", numeric_only=True),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [1]}, [pd.Period("2000", "D")]),
+        operator.methodcaller("to_timestamp"),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [1]}, [pd.Timestamp("2000")]),
+        operator.methodcaller("to_period", freq="D"),
+    ),
+    (pd.DataFrame, frame_mi_data, operator.methodcaller("isin", [1])),
+    (pd.DataFrame, frame_mi_data, operator.methodcaller("isin", pd.Series([1]))),
+    (
+        pd.DataFrame,
+        frame_mi_data,
+        operator.methodcaller("isin", pd.DataFrame({"A": [1]})),
+    ),
+    (pd.DataFrame, frame_mi_data, operator.methodcaller("droplevel", "A")),
+    (pd.DataFrame, frame_data, operator.methodcaller("pop", "A")),
+    # Squeeze on columns, otherwise we'll end up with a scalar
+    (pd.DataFrame, frame_data, operator.methodcaller("squeeze", axis="columns")),
+    (pd.Series, ([1, 2],), operator.methodcaller("squeeze")),
+    (pd.Series, ([1, 2],), operator.methodcaller("rename_axis", index="a")),
+    (pd.DataFrame, frame_data, operator.methodcaller("rename_axis", columns="a")),
+    # Unary ops
+    (pd.DataFrame, frame_data, operator.neg),
+    (pd.Series, [1], operator.neg),
+    (pd.DataFrame, frame_data, operator.pos),
+    (pd.Series, [1], operator.pos),
+    (pd.DataFrame, frame_data, operator.inv),
+    (pd.Series, [1], operator.inv),
+    (pd.DataFrame, frame_data, abs),
+    (pd.Series, [1], abs),
+    (pd.DataFrame, frame_data, round),
+    (pd.Series, [1], round),
+    (pd.DataFrame, frame_data, operator.methodcaller("take", [0, 0])),
+    (pd.DataFrame, frame_mi_data, operator.methodcaller("xs", "a")),
+    (pd.Series, (1, mi), operator.methodcaller("xs", "a")),
+    (pd.DataFrame, frame_data, operator.methodcaller("get", "A")),
+    (
+        pd.DataFrame,
+        frame_data,
+        operator.methodcaller("reindex_like", pd.DataFrame({"A": [1, 2, 3]})),
+    ),
+    (
+        pd.Series,
+        frame_data,
+        operator.methodcaller("reindex_like", pd.Series([0, 1, 2])),
+    ),
+    (pd.DataFrame, frame_data, operator.methodcaller("add_prefix", "_")),
+    (pd.DataFrame, frame_data, operator.methodcaller("add_suffix", "_")),
+    (pd.Series, (1, ["a", "b"]), operator.methodcaller("add_prefix", "_")),
+    (pd.Series, (1, ["a", "b"]), operator.methodcaller("add_suffix", "_")),
+    (pd.Series, ([3, 2],), operator.methodcaller("sort_values")),
+    (pd.Series, ([1] * 10,), operator.methodcaller("head")),
+    (pd.DataFrame, ({"A": [1] * 10},), operator.methodcaller("head")),
+    (pd.Series, ([1] * 10,), operator.methodcaller("tail")),
+    (pd.DataFrame, ({"A": [1] * 10},), operator.methodcaller("tail")),
+    (pd.Series, ([1, 2],), operator.methodcaller("sample", n=2, replace=True)),
+    (pd.DataFrame, (frame_data,), operator.methodcaller("sample", n=2, replace=True)),
+    (pd.Series, ([1, 2],), operator.methodcaller("astype", float)),
+    (pd.DataFrame, frame_data, operator.methodcaller("astype", float)),
+    (pd.Series, ([1, 2],), operator.methodcaller("copy")),
+    (pd.DataFrame, frame_data, operator.methodcaller("copy")),
+    (pd.Series, ([1, 2], None, object), operator.methodcaller("infer_objects")),
+    (
+        pd.DataFrame,
+        ({"A": np.array([1, 2], dtype=object)},),
+        operator.methodcaller("infer_objects"),
+    ),
+    (pd.Series, ([1, 2],), operator.methodcaller("convert_dtypes")),
+    (pd.DataFrame, frame_data, operator.methodcaller("convert_dtypes")),
+    (pd.Series, ([1, None, 3],), operator.methodcaller("interpolate")),
+    (pd.DataFrame, ({"A": [1, None, 3]},), operator.methodcaller("interpolate")),
+    (pd.Series, ([1, 2],), operator.methodcaller("clip", lower=1)),
+    (pd.DataFrame, frame_data, operator.methodcaller("clip", lower=1)),
+    (
+        pd.Series,
+        (1, pd.date_range("2000", periods=4)),
+        operator.methodcaller("asfreq", "h"),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
+        operator.methodcaller("asfreq", "h"),
+    ),
+    (
+        pd.Series,
+        (1, pd.date_range("2000", periods=4)),
+        operator.methodcaller("at_time", "12:00"),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
+        operator.methodcaller("at_time", "12:00"),
+    ),
+    (
+        pd.Series,
+        (1, pd.date_range("2000", periods=4)),
+        operator.methodcaller("between_time", "12:00", "13:00"),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
+        operator.methodcaller("between_time", "12:00", "13:00"),
+    ),
+    (
+        pd.Series,
+        (1, pd.date_range("2000", periods=4)),
+        operator.methodcaller("last", "3D"),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
+        operator.methodcaller("last", "3D"),
+    ),
+    (pd.Series, ([1, 2],), operator.methodcaller("rank")),
+    (pd.DataFrame, frame_data, operator.methodcaller("rank")),
+    (pd.Series, ([1, 2],), operator.methodcaller("where", np.array([True, False]))),
+    (pd.DataFrame, frame_data, operator.methodcaller("where", np.array([[True]]))),
+    (pd.Series, ([1, 2],), operator.methodcaller("mask", np.array([True, False]))),
+    (pd.DataFrame, frame_data, operator.methodcaller("mask", np.array([[True]]))),
+    (pd.Series, ([1, 2],), operator.methodcaller("truncate", before=0)),
+    (pd.DataFrame, frame_data, operator.methodcaller("truncate", before=0)),
+    (
+        pd.Series,
+        (1, pd.date_range("2000", periods=4, tz="UTC")),
+        operator.methodcaller("tz_convert", "CET"),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4, tz="UTC")),
+        operator.methodcaller("tz_convert", "CET"),
+    ),
+    (
+        pd.Series,
+        (1, pd.date_range("2000", periods=4)),
+        operator.methodcaller("tz_localize", "CET"),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
+        operator.methodcaller("tz_localize", "CET"),
+    ),
+    (pd.Series, ([1, 2],), operator.methodcaller("describe")),
+    (pd.DataFrame, frame_data, operator.methodcaller("describe")),
+    (pd.Series, ([1, 2],), operator.methodcaller("pct_change")),
+    (pd.DataFrame, frame_data, operator.methodcaller("pct_change")),
+    (pd.Series, ([1],), operator.methodcaller("transform", lambda x: x - x.min())),
+    (
+        pd.DataFrame,
+        frame_mi_data,
+        operator.methodcaller("transform", lambda x: x - x.min()),
+    ),
+    (pd.Series, ([1],), operator.methodcaller("apply", lambda x: x)),
+    (pd.DataFrame, frame_mi_data, operator.methodcaller("apply", lambda x: x)),
+    # Cumulative reductions
+    (pd.Series, ([1],), operator.methodcaller("cumsum")),
+    (pd.DataFrame, frame_data, operator.methodcaller("cumsum")),
+    (pd.Series, ([1],), operator.methodcaller("cummin")),
+    (pd.DataFrame, frame_data, operator.methodcaller("cummin")),
+    (pd.Series, ([1],), operator.methodcaller("cummax")),
+    (pd.DataFrame, frame_data, operator.methodcaller("cummax")),
+    (pd.Series, ([1],), operator.methodcaller("cumprod")),
+    (pd.DataFrame, frame_data, operator.methodcaller("cumprod")),
+    # Reductions
+    (pd.DataFrame, frame_data, operator.methodcaller("any")),
+    (pd.DataFrame, frame_data, operator.methodcaller("all")),
+    (pd.DataFrame, frame_data, operator.methodcaller("min")),
+    (pd.DataFrame, frame_data, operator.methodcaller("max")),
+    (pd.DataFrame, frame_data, operator.methodcaller("sum")),
+    (pd.DataFrame, frame_data, operator.methodcaller("std")),
+    (pd.DataFrame, frame_data, operator.methodcaller("mean")),
+    (pd.DataFrame, frame_data, operator.methodcaller("prod")),
+    (pd.DataFrame, frame_data, operator.methodcaller("sem")),
+    (pd.DataFrame, frame_data, operator.methodcaller("skew")),
+    (pd.DataFrame, frame_data, operator.methodcaller("kurt")),
+]
+
+
+def idfn(x):
+    xpr = re.compile(r"'(.*)?'")
+    m = xpr.search(str(x))
+    if m:
+        return m.group(1)
+    else:
+        return str(x)
+
+
+@pytest.fixture(params=_all_methods, ids=lambda x: idfn(x[-1]))
+def ndframe_method(request):
+    """
+    An NDFrame method returning an NDFrame.
+    """
+    return request.param
+
+
+@pytest.mark.filterwarnings(
+    "ignore:DataFrame.fillna with 'method' is deprecated:FutureWarning",
+    "ignore:last is deprecated:FutureWarning",
+)
+def test_finalize_called(ndframe_method):
+    cls, init_args, method = ndframe_method
+    ndframe = cls(*init_args)
+
+    ndframe.attrs = {"a": 1}
+    result = method(ndframe)
+
+    assert result.attrs == {"a": 1}
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        pd.Series(1, pd.date_range("2000", periods=4)),
+        pd.DataFrame({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
+    ],
+)
+def test_finalize_first(data):
+    deprecated_msg = "first is deprecated"
+
+    data.attrs = {"a": 1}
+    with tm.assert_produces_warning(FutureWarning, match=deprecated_msg):
+        result = data.first("3D")
+        assert result.attrs == {"a": 1}
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        pd.Series(1, pd.date_range("2000", periods=4)),
+        pd.DataFrame({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
+    ],
+)
+def test_finalize_last(data):
+    # GH 53710
+    deprecated_msg = "last is deprecated"
+
+    data.attrs = {"a": 1}
+    with tm.assert_produces_warning(FutureWarning, match=deprecated_msg):
+        result = data.last("3D")
+        assert result.attrs == {"a": 1}
+
+
+@not_implemented_mark
+def test_finalize_called_eval_numexpr():
+    pytest.importorskip("numexpr")
+    df = pd.DataFrame({"A": [1, 2]})
+    df.attrs["A"] = 1
+    result = df.eval("A + 1", engine="numexpr")
+    assert result.attrs == {"A": 1}
+
+
+# ----------------------------------------------------------------------------
+# Binary operations
+
+
+@pytest.mark.parametrize("annotate", ["left", "right", "both"])
+@pytest.mark.parametrize(
+    "args",
+    [
+        (1, pd.Series([1])),
+        (1, pd.DataFrame({"A": [1]})),
+        (pd.Series([1]), 1),
+        (pd.DataFrame({"A": [1]}), 1),
+        (pd.Series([1]), pd.Series([1])),
+        (pd.DataFrame({"A": [1]}), pd.DataFrame({"A": [1]})),
+        (pd.Series([1]), pd.DataFrame({"A": [1]})),
+        (pd.DataFrame({"A": [1]}), pd.Series([1])),
+    ],
+    ids=lambda x: f"({type(x[0]).__name__},{type(x[1]).__name__})",
+)
+def test_binops(request, args, annotate, all_binary_operators):
+    # This generates 624 tests... Is that needed?
+    left, right = args
+    if isinstance(left, (pd.DataFrame, pd.Series)):
+        left.attrs = {}
+    if isinstance(right, (pd.DataFrame, pd.Series)):
+        right.attrs = {}
+
+    if annotate == "left" and isinstance(left, int):
+        pytest.skip("left is an int and doesn't support .attrs")
+    if annotate == "right" and isinstance(right, int):
+        pytest.skip("right is an int and doesn't support .attrs")
+
+    if not (isinstance(left, int) or isinstance(right, int)) and annotate != "both":
+        if not all_binary_operators.__name__.startswith("r"):
+            if annotate == "right" and isinstance(left, type(right)):
+                request.applymarker(
+                    pytest.mark.xfail(
+                        reason=f"{all_binary_operators} doesn't work when right has "
+                        f"attrs and both are {type(left)}"
+                    )
+                )
+            if not isinstance(left, type(right)):
+                if annotate == "left" and isinstance(left, pd.Series):
+                    request.applymarker(
+                        pytest.mark.xfail(
+                            reason=f"{all_binary_operators} doesn't work when the "
+                            "objects are different Series has attrs"
+                        )
+                    )
+                elif annotate == "right" and isinstance(right, pd.Series):
+                    request.applymarker(
+                        pytest.mark.xfail(
+                            reason=f"{all_binary_operators} doesn't work when the "
+                            "objects are different Series has attrs"
+                        )
+                    )
+        else:
+            if annotate == "left" and isinstance(left, type(right)):
+                request.applymarker(
+                    pytest.mark.xfail(
+                        reason=f"{all_binary_operators} doesn't work when left has "
+                        f"attrs and both are {type(left)}"
+                    )
+                )
+            if not isinstance(left, type(right)):
+                if annotate == "right" and isinstance(right, pd.Series):
+                    request.applymarker(
+                        pytest.mark.xfail(
+                            reason=f"{all_binary_operators} doesn't work when the "
+                            "objects are different Series has attrs"
+                        )
+                    )
+                elif annotate == "left" and isinstance(left, pd.Series):
+                    request.applymarker(
+                        pytest.mark.xfail(
+                            reason=f"{all_binary_operators} doesn't work when the "
+                            "objects are different Series has attrs"
+                        )
+                    )
+    if annotate in {"left", "both"} and not isinstance(left, int):
+        left.attrs = {"a": 1}
+    if annotate in {"right", "both"} and not isinstance(right, int):
+        right.attrs = {"a": 1}
+
+    is_cmp = all_binary_operators in [
+        operator.eq,
+        operator.ne,
+        operator.gt,
+        operator.ge,
+        operator.lt,
+        operator.le,
+    ]
+    if is_cmp and isinstance(left, pd.DataFrame) and isinstance(right, pd.Series):
+        # in 2.0 silent alignment on comparisons was removed xref GH#28759
+        left, right = left.align(right, axis=1, copy=False)
+    elif is_cmp and isinstance(left, pd.Series) and isinstance(right, pd.DataFrame):
+        right, left = right.align(left, axis=1, copy=False)
+
+    result = all_binary_operators(left, right)
+    assert result.attrs == {"a": 1}
+
+
+# ----------------------------------------------------------------------------
+# Accessors
+
+
+@pytest.mark.parametrize(
+    "method",
+    [
+        operator.methodcaller("capitalize"),
+        operator.methodcaller("casefold"),
+        operator.methodcaller("cat", ["a"]),
+        operator.methodcaller("contains", "a"),
+        operator.methodcaller("count", "a"),
+        operator.methodcaller("encode", "utf-8"),
+        operator.methodcaller("endswith", "a"),
+        operator.methodcaller("extract", r"(\w)(\d)"),
+        operator.methodcaller("extract", r"(\w)(\d)", expand=False),
+        operator.methodcaller("find", "a"),
+        operator.methodcaller("findall", "a"),
+        operator.methodcaller("get", 0),
+        operator.methodcaller("index", "a"),
+        operator.methodcaller("len"),
+        operator.methodcaller("ljust", 4),
+        operator.methodcaller("lower"),
+        operator.methodcaller("lstrip"),
+        operator.methodcaller("match", r"\w"),
+        operator.methodcaller("normalize", "NFC"),
+        operator.methodcaller("pad", 4),
+        operator.methodcaller("partition", "a"),
+        operator.methodcaller("repeat", 2),
+        operator.methodcaller("replace", "a", "b"),
+        operator.methodcaller("rfind", "a"),
+        operator.methodcaller("rindex", "a"),
+        operator.methodcaller("rjust", 4),
+        operator.methodcaller("rpartition", "a"),
+        operator.methodcaller("rstrip"),
+        operator.methodcaller("slice", 4),
+        operator.methodcaller("slice_replace", 1, repl="a"),
+        operator.methodcaller("startswith", "a"),
+        operator.methodcaller("strip"),
+        operator.methodcaller("swapcase"),
+        operator.methodcaller("translate", {"a": "b"}),
+        operator.methodcaller("upper"),
+        operator.methodcaller("wrap", 4),
+        operator.methodcaller("zfill", 4),
+        operator.methodcaller("isalnum"),
+        operator.methodcaller("isalpha"),
+        operator.methodcaller("isdigit"),
+        operator.methodcaller("isspace"),
+        operator.methodcaller("islower"),
+        operator.methodcaller("isupper"),
+        operator.methodcaller("istitle"),
+        operator.methodcaller("isnumeric"),
+        operator.methodcaller("isdecimal"),
+        operator.methodcaller("get_dummies"),
+    ],
+    ids=idfn,
+)
+def test_string_method(method):
+    s = pd.Series(["a1"])
+    s.attrs = {"a": 1}
+    result = method(s.str)
+    assert result.attrs == {"a": 1}
+
+
+@pytest.mark.parametrize(
+    "method",
+    [
+        operator.methodcaller("to_period"),
+        operator.methodcaller("tz_localize", "CET"),
+        operator.methodcaller("normalize"),
+        operator.methodcaller("strftime", "%Y"),
+        operator.methodcaller("round", "h"),
+        operator.methodcaller("floor", "h"),
+        operator.methodcaller("ceil", "h"),
+        operator.methodcaller("month_name"),
+        operator.methodcaller("day_name"),
+    ],
+    ids=idfn,
+)
+def test_datetime_method(method):
+    s = pd.Series(pd.date_range("2000", periods=4))
+    s.attrs = {"a": 1}
+    result = method(s.dt)
+    assert result.attrs == {"a": 1}
+
+
+@pytest.mark.parametrize(
+    "attr",
+    [
+        "date",
+        "time",
+        "timetz",
+        "year",
+        "month",
+        "day",
+        "hour",
+        "minute",
+        "second",
+        "microsecond",
+        "nanosecond",
+        "dayofweek",
+        "day_of_week",
+        "dayofyear",
+        "day_of_year",
+        "quarter",
+        "is_month_start",
+        "is_month_end",
+        "is_quarter_start",
+        "is_quarter_end",
+        "is_year_start",
+        "is_year_end",
+        "is_leap_year",
+        "daysinmonth",
+        "days_in_month",
+    ],
+)
+def test_datetime_property(attr):
+    s = pd.Series(pd.date_range("2000", periods=4))
+    s.attrs = {"a": 1}
+    result = getattr(s.dt, attr)
+    assert result.attrs == {"a": 1}
+
+
+@pytest.mark.parametrize(
+    "attr", ["days", "seconds", "microseconds", "nanoseconds", "components"]
+)
+def test_timedelta_property(attr):
+    s = pd.Series(pd.timedelta_range("2000", periods=4))
+    s.attrs = {"a": 1}
+    result = getattr(s.dt, attr)
+    assert result.attrs == {"a": 1}
+
+
+@pytest.mark.parametrize("method", [operator.methodcaller("total_seconds")])
+def test_timedelta_methods(method):
+    s = pd.Series(pd.timedelta_range("2000", periods=4))
+    s.attrs = {"a": 1}
+    result = method(s.dt)
+    assert result.attrs == {"a": 1}
+
+
+@pytest.mark.parametrize(
+    "method",
+    [
+        operator.methodcaller("add_categories", ["c"]),
+        operator.methodcaller("as_ordered"),
+        operator.methodcaller("as_unordered"),
+        lambda x: getattr(x, "codes"),
+        operator.methodcaller("remove_categories", "a"),
+        operator.methodcaller("remove_unused_categories"),
+        operator.methodcaller("rename_categories", {"a": "A", "b": "B"}),
+        operator.methodcaller("reorder_categories", ["b", "a"]),
+        operator.methodcaller("set_categories", ["A", "B"]),
+    ],
+)
+@not_implemented_mark
+def test_categorical_accessor(method):
+    s = pd.Series(["a", "b"], dtype="category")
+    s.attrs = {"a": 1}
+    result = method(s.cat)
+    assert result.attrs == {"a": 1}
+
+
+# ----------------------------------------------------------------------------
+# Groupby
+
+
+@pytest.mark.parametrize(
+    "obj", [pd.Series([0, 0]), pd.DataFrame({"A": [0, 1], "B": [1, 2]})]
+)
+@pytest.mark.parametrize(
+    "method",
+    [
+        operator.methodcaller("sum"),
+        lambda x: x.apply(lambda y: y),
+        lambda x: x.agg("sum"),
+        lambda x: x.agg("mean"),
+        lambda x: x.agg("median"),
+    ],
+)
+def test_groupby_finalize(obj, method):
+    obj.attrs = {"a": 1}
+    result = method(obj.groupby([0, 0], group_keys=False))
+    assert result.attrs == {"a": 1}
+
+
+@pytest.mark.parametrize(
+    "obj", [pd.Series([0, 0]), pd.DataFrame({"A": [0, 1], "B": [1, 2]})]
+)
+@pytest.mark.parametrize(
+    "method",
+    [
+        lambda x: x.agg(["sum", "count"]),
+        lambda x: x.agg("std"),
+        lambda x: x.agg("var"),
+        lambda x: x.agg("sem"),
+        lambda x: x.agg("size"),
+        lambda x: x.agg("ohlc"),
+    ],
+)
+@not_implemented_mark
+def test_groupby_finalize_not_implemented(obj, method):
+    obj.attrs = {"a": 1}
+    result = method(obj.groupby([0, 0]))
+    assert result.attrs == {"a": 1}
+
+
+def test_finalize_frame_series_name():
+    # https://github.com/pandas-dev/pandas/pull/37186/files#r506978889
+    # ensure we don't copy the column `name` to the Series.
+    df = pd.DataFrame({"name": [1, 2]})
+    result = pd.Series([1, 2]).__finalize__(df)
+    assert result.name is None

llmeval-env/lib/python3.10/site-packages/pandas/tests/generic/test_series.py

@@ -0,0 +1,159 @@
+from operator import methodcaller
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    MultiIndex,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestSeries:
+    @pytest.mark.parametrize("func", ["rename_axis", "_set_axis_name"])
+    def test_set_axis_name_mi(self, func):
+        ser = Series(
+            [11, 21, 31],
+            index=MultiIndex.from_tuples(
+                [("A", x) for x in ["a", "B", "c"]], names=["l1", "l2"]
+            ),
+        )
+
+        result = methodcaller(func, ["L1", "L2"])(ser)
+        assert ser.index.name is None
+        assert ser.index.names == ["l1", "l2"]
+        assert result.index.name is None
+        assert result.index.names, ["L1", "L2"]
+
+    def test_set_axis_name_raises(self):
+        ser = Series([1])
+        msg = "No axis named 1 for object type Series"
+        with pytest.raises(ValueError, match=msg):
+            ser._set_axis_name(name="a", axis=1)
+
+    def test_get_bool_data_preserve_dtype(self):
+        ser = Series([True, False, True])
+        result = ser._get_bool_data()
+        tm.assert_series_equal(result, ser)
+
+    def test_nonzero_single_element(self):
+        # allow single item via bool method
+        msg_warn = (
+            "Series.bool is now deprecated and will be removed "
+            "in future version of pandas"
+        )
+        ser = Series([True])
+        ser1 = Series([False])
+        with tm.assert_produces_warning(FutureWarning, match=msg_warn):
+            assert ser.bool()
+        with tm.assert_produces_warning(FutureWarning, match=msg_warn):
+            assert not ser1.bool()
+
+    @pytest.mark.parametrize("data", [np.nan, pd.NaT, True, False])
+    def test_nonzero_single_element_raise_1(self, data):
+        # single item nan to raise
+        series = Series([data])
+
+        msg = "The truth value of a Series is ambiguous"
+        with pytest.raises(ValueError, match=msg):
+            bool(series)
+
+    @pytest.mark.parametrize("data", [np.nan, pd.NaT])
+    def test_nonzero_single_element_raise_2(self, data):
+        msg_warn = (
+            "Series.bool is now deprecated and will be removed "
+            "in future version of pandas"
+        )
+        msg_err = "bool cannot act on a non-boolean single element Series"
+        series = Series([data])
+        with tm.assert_produces_warning(FutureWarning, match=msg_warn):
+            with pytest.raises(ValueError, match=msg_err):
+                series.bool()
+
+    @pytest.mark.parametrize("data", [(True, True), (False, False)])
+    def test_nonzero_multiple_element_raise(self, data):
+        # multiple bool are still an error
+        msg_warn = (
+            "Series.bool is now deprecated and will be removed "
+            "in future version of pandas"
+        )
+        msg_err = "The truth value of a Series is ambiguous"
+        series = Series([data])
+        with pytest.raises(ValueError, match=msg_err):
+            bool(series)
+        with tm.assert_produces_warning(FutureWarning, match=msg_warn):
+            with pytest.raises(ValueError, match=msg_err):
+                series.bool()
+
+    @pytest.mark.parametrize("data", [1, 0, "a", 0.0])
+    def test_nonbool_single_element_raise(self, data):
+        # single non-bool are an error
+        msg_warn = (
+            "Series.bool is now deprecated and will be removed "
+            "in future version of pandas"
+        )
+        msg_err1 = "The truth value of a Series is ambiguous"
+        msg_err2 = "bool cannot act on a non-boolean single element Series"
+        series = Series([data])
+        with pytest.raises(ValueError, match=msg_err1):
+            bool(series)
+        with tm.assert_produces_warning(FutureWarning, match=msg_warn):
+            with pytest.raises(ValueError, match=msg_err2):
+                series.bool()
+
+    def test_metadata_propagation_indiv_resample(self):
+        # resample
+        ts = Series(
+            np.random.default_rng(2).random(1000),
+            index=date_range("20130101", periods=1000, freq="s"),
+            name="foo",
+        )
+        result = ts.resample("1min").mean()
+        tm.assert_metadata_equivalent(ts, result)
+
+        result = ts.resample("1min").min()
+        tm.assert_metadata_equivalent(ts, result)
+
+        result = ts.resample("1min").apply(lambda x: x.sum())
+        tm.assert_metadata_equivalent(ts, result)
+
+    def test_metadata_propagation_indiv(self, monkeypatch):
+        # check that the metadata matches up on the resulting ops
+
+        ser = Series(range(3), range(3))
+        ser.name = "foo"
+        ser2 = Series(range(3), range(3))
+        ser2.name = "bar"
+
+        result = ser.T
+        tm.assert_metadata_equivalent(ser, result)
+
+        def finalize(self, other, method=None, **kwargs):
+            for name in self._metadata:
+                if method == "concat" and name == "filename":
+                    value = "+".join(
+                        [
+                            getattr(obj, name)
+                            for obj in other.objs
+                            if getattr(obj, name, None)
+                        ]
+                    )
+                    object.__setattr__(self, name, value)
+                else:
+                    object.__setattr__(self, name, getattr(other, name, None))
+
+            return self
+
+        with monkeypatch.context() as m:
+            m.setattr(Series, "_metadata", ["name", "filename"])
+            m.setattr(Series, "__finalize__", finalize)
+
+            ser.filename = "foo"
+            ser2.filename = "bar"
+
+            result = pd.concat([ser, ser2])
+            assert result.filename == "foo+bar"
+            assert result.name is None

llmeval-env/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/test_drop_duplicates.py

@@ -0,0 +1,89 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    PeriodIndex,
+    Series,
+    date_range,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+
+
+class DropDuplicates:
+    def test_drop_duplicates_metadata(self, idx):
+        # GH#10115
+        result = idx.drop_duplicates()
+        tm.assert_index_equal(idx, result)
+        assert idx.freq == result.freq
+
+        idx_dup = idx.append(idx)
+        result = idx_dup.drop_duplicates()
+
+        expected = idx
+        if not isinstance(idx, PeriodIndex):
+            # freq is reset except for PeriodIndex
+            assert idx_dup.freq is None
+            assert result.freq is None
+            expected = idx._with_freq(None)
+        else:
+            assert result.freq == expected.freq
+
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "keep, expected, index",
+        [
+            (
+                "first",
+                np.concatenate(([False] * 10, [True] * 5)),
+                np.arange(0, 10, dtype=np.int64),
+            ),
+            (
+                "last",
+                np.concatenate(([True] * 5, [False] * 10)),
+                np.arange(5, 15, dtype=np.int64),
+            ),
+            (
+                False,
+                np.concatenate(([True] * 5, [False] * 5, [True] * 5)),
+                np.arange(5, 10, dtype=np.int64),
+            ),
+        ],
+    )
+    def test_drop_duplicates(self, keep, expected, index, idx):
+        # to check Index/Series compat
+        idx = idx.append(idx[:5])
+
+        tm.assert_numpy_array_equal(idx.duplicated(keep=keep), expected)
+        expected = idx[~expected]
+
+        result = idx.drop_duplicates(keep=keep)
+        tm.assert_index_equal(result, expected)
+
+        result = Series(idx).drop_duplicates(keep=keep)
+        expected = Series(expected, index=index)
+        tm.assert_series_equal(result, expected)
+
+
+class TestDropDuplicatesPeriodIndex(DropDuplicates):
+    @pytest.fixture(params=["D", "3D", "h", "2h", "min", "2min", "s", "3s"])
+    def freq(self, request):
+        return request.param
+
+    @pytest.fixture
+    def idx(self, freq):
+        return period_range("2011-01-01", periods=10, freq=freq, name="idx")
+
+
+class TestDropDuplicatesDatetimeIndex(DropDuplicates):
+    @pytest.fixture
+    def idx(self, freq_sample):
+        return date_range("2011-01-01", freq=freq_sample, periods=10, name="idx")
+
+
+class TestDropDuplicatesTimedeltaIndex(DropDuplicates):
+    @pytest.fixture
+    def idx(self, freq_sample):
+        return timedelta_range("1 day", periods=10, freq=freq_sample, name="idx")

llmeval-env/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/test_equals.py

@@ -0,0 +1,181 @@
+"""
+Tests shared for DatetimeIndex/TimedeltaIndex/PeriodIndex
+"""
+from datetime import (
+    datetime,
+    timedelta,
+)
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    CategoricalIndex,
+    DatetimeIndex,
+    Index,
+    PeriodIndex,
+    TimedeltaIndex,
+    date_range,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+
+
+class EqualsTests:
+    def test_not_equals_numeric(self, index):
+        assert not index.equals(Index(index.asi8))
+        assert not index.equals(Index(index.asi8.astype("u8")))
+        assert not index.equals(Index(index.asi8).astype("f8"))
+
+    def test_equals(self, index):
+        assert index.equals(index)
+        assert index.equals(index.astype(object))
+        assert index.equals(CategoricalIndex(index))
+        assert index.equals(CategoricalIndex(index.astype(object)))
+
+    def test_not_equals_non_arraylike(self, index):
+        assert not index.equals(list(index))
+
+    def test_not_equals_strings(self, index):
+        other = Index([str(x) for x in index], dtype=object)
+        assert not index.equals(other)
+        assert not index.equals(CategoricalIndex(other))
+
+    def test_not_equals_misc_strs(self, index):
+        other = Index(list("abc"))
+        assert not index.equals(other)
+
+
+class TestPeriodIndexEquals(EqualsTests):
+    @pytest.fixture
+    def index(self):
+        return period_range("2013-01-01", periods=5, freq="D")
+
+    # TODO: de-duplicate with other test_equals2 methods
+    @pytest.mark.parametrize("freq", ["D", "M"])
+    def test_equals2(self, freq):
+        # GH#13107
+        idx = PeriodIndex(["2011-01-01", "2011-01-02", "NaT"], freq=freq)
+        assert idx.equals(idx)
+        assert idx.equals(idx.copy())
+        assert idx.equals(idx.astype(object))
+        assert idx.astype(object).equals(idx)
+        assert idx.astype(object).equals(idx.astype(object))
+        assert not idx.equals(list(idx))
+        assert not idx.equals(pd.Series(idx))
+
+        idx2 = PeriodIndex(["2011-01-01", "2011-01-02", "NaT"], freq="h")
+        assert not idx.equals(idx2)
+        assert not idx.equals(idx2.copy())
+        assert not idx.equals(idx2.astype(object))
+        assert not idx.astype(object).equals(idx2)
+        assert not idx.equals(list(idx2))
+        assert not idx.equals(pd.Series(idx2))
+
+        # same internal, different tz
+        idx3 = PeriodIndex._simple_new(
+            idx._values._simple_new(idx._values.asi8, dtype=pd.PeriodDtype("h"))
+        )
+        tm.assert_numpy_array_equal(idx.asi8, idx3.asi8)
+        assert not idx.equals(idx3)
+        assert not idx.equals(idx3.copy())
+        assert not idx.equals(idx3.astype(object))
+        assert not idx.astype(object).equals(idx3)
+        assert not idx.equals(list(idx3))
+        assert not idx.equals(pd.Series(idx3))
+
+
+class TestDatetimeIndexEquals(EqualsTests):
+    @pytest.fixture
+    def index(self):
+        return date_range("2013-01-01", periods=5)
+
+    def test_equals2(self):
+        # GH#13107
+        idx = DatetimeIndex(["2011-01-01", "2011-01-02", "NaT"])
+        assert idx.equals(idx)
+        assert idx.equals(idx.copy())
+        assert idx.equals(idx.astype(object))
+        assert idx.astype(object).equals(idx)
+        assert idx.astype(object).equals(idx.astype(object))
+        assert not idx.equals(list(idx))
+        assert not idx.equals(pd.Series(idx))
+
+        idx2 = DatetimeIndex(["2011-01-01", "2011-01-02", "NaT"], tz="US/Pacific")
+        assert not idx.equals(idx2)
+        assert not idx.equals(idx2.copy())
+        assert not idx.equals(idx2.astype(object))
+        assert not idx.astype(object).equals(idx2)
+        assert not idx.equals(list(idx2))
+        assert not idx.equals(pd.Series(idx2))
+
+        # same internal, different tz
+        idx3 = DatetimeIndex(idx.asi8, tz="US/Pacific")
+        tm.assert_numpy_array_equal(idx.asi8, idx3.asi8)
+        assert not idx.equals(idx3)
+        assert not idx.equals(idx3.copy())
+        assert not idx.equals(idx3.astype(object))
+        assert not idx.astype(object).equals(idx3)
+        assert not idx.equals(list(idx3))
+        assert not idx.equals(pd.Series(idx3))
+
+        # check that we do not raise when comparing with OutOfBounds objects
+        oob = Index([datetime(2500, 1, 1)] * 3, dtype=object)
+        assert not idx.equals(oob)
+        assert not idx2.equals(oob)
+        assert not idx3.equals(oob)
+
+        # check that we do not raise when comparing with OutOfBounds dt64
+        oob2 = oob.map(np.datetime64)
+        assert not idx.equals(oob2)
+        assert not idx2.equals(oob2)
+        assert not idx3.equals(oob2)
+
+    @pytest.mark.parametrize("freq", ["B", "C"])
+    def test_not_equals_bday(self, freq):
+        rng = date_range("2009-01-01", "2010-01-01", freq=freq)
+        assert not rng.equals(list(rng))
+
+
+class TestTimedeltaIndexEquals(EqualsTests):
+    @pytest.fixture
+    def index(self):
+        return timedelta_range("1 day", periods=10)
+
+    def test_equals2(self):
+        # GH#13107
+        idx = TimedeltaIndex(["1 days", "2 days", "NaT"])
+        assert idx.equals(idx)
+        assert idx.equals(idx.copy())
+        assert idx.equals(idx.astype(object))
+        assert idx.astype(object).equals(idx)
+        assert idx.astype(object).equals(idx.astype(object))
+        assert not idx.equals(list(idx))
+        assert not idx.equals(pd.Series(idx))
+
+        idx2 = TimedeltaIndex(["2 days", "1 days", "NaT"])
+        assert not idx.equals(idx2)
+        assert not idx.equals(idx2.copy())
+        assert not idx.equals(idx2.astype(object))
+        assert not idx.astype(object).equals(idx2)
+        assert not idx.astype(object).equals(idx2.astype(object))
+        assert not idx.equals(list(idx2))
+        assert not idx.equals(pd.Series(idx2))
+
+        # Check that we dont raise OverflowError on comparisons outside the
+        #  implementation range GH#28532
+        oob = Index([timedelta(days=10**6)] * 3, dtype=object)
+        assert not idx.equals(oob)
+        assert not idx2.equals(oob)
+
+        oob2 = Index([np.timedelta64(x) for x in oob], dtype=object)
+        assert (oob == oob2).all()
+        assert not idx.equals(oob2)
+        assert not idx2.equals(oob2)
+
+        oob3 = oob.map(np.timedelta64)
+        assert (oob3 == oob).all()
+        assert not idx.equals(oob3)
+        assert not idx2.equals(oob3)

llmeval-env/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/test_indexing.py

@@ -0,0 +1,45 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DatetimeIndex,
+    Index,
+)
+import pandas._testing as tm
+
+dtlike_dtypes = [
+    np.dtype("timedelta64[ns]"),
+    np.dtype("datetime64[ns]"),
+    pd.DatetimeTZDtype("ns", "Asia/Tokyo"),
+    pd.PeriodDtype("ns"),
+]
+
+
+@pytest.mark.parametrize("ldtype", dtlike_dtypes)
+@pytest.mark.parametrize("rdtype", dtlike_dtypes)
+def test_get_indexer_non_unique_wrong_dtype(ldtype, rdtype):
+    vals = np.tile(3600 * 10**9 * np.arange(3), 2)
+
+    def construct(dtype):
+        if dtype is dtlike_dtypes[-1]:
+            # PeriodArray will try to cast ints to strings
+            return DatetimeIndex(vals).astype(dtype)
+        return Index(vals, dtype=dtype)
+
+    left = construct(ldtype)
+    right = construct(rdtype)
+
+    result = left.get_indexer_non_unique(right)
+
+    if ldtype is rdtype:
+        ex1 = np.array([0, 3, 1, 4, 2, 5] * 2, dtype=np.intp)
+        ex2 = np.array([], dtype=np.intp)
+        tm.assert_numpy_array_equal(result[0], ex1)
+        tm.assert_numpy_array_equal(result[1], ex2)
+
+    else:
+        no_matches = np.array([-1] * 6, dtype=np.intp)
+        missing = np.arange(6, dtype=np.intp)
+        tm.assert_numpy_array_equal(result[0], no_matches)
+        tm.assert_numpy_array_equal(result[1], missing)

llmeval-env/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/test_is_monotonic.py

@@ -0,0 +1,46 @@
+from pandas import (
+    Index,
+    NaT,
+    date_range,
+)
+
+
+def test_is_monotonic_with_nat():
+    # GH#31437
+    # PeriodIndex.is_monotonic_increasing should behave analogously to DatetimeIndex,
+    #  in particular never be monotonic when we have NaT
+    dti = date_range("2016-01-01", periods=3)
+    pi = dti.to_period("D")
+    tdi = Index(dti.view("timedelta64[ns]"))
+
+    for obj in [pi, pi._engine, dti, dti._engine, tdi, tdi._engine]:
+        if isinstance(obj, Index):
+            # i.e. not Engines
+            assert obj.is_monotonic_increasing
+        assert obj.is_monotonic_increasing
+        assert not obj.is_monotonic_decreasing
+        assert obj.is_unique
+
+    dti1 = dti.insert(0, NaT)
+    pi1 = dti1.to_period("D")
+    tdi1 = Index(dti1.view("timedelta64[ns]"))
+
+    for obj in [pi1, pi1._engine, dti1, dti1._engine, tdi1, tdi1._engine]:
+        if isinstance(obj, Index):
+            # i.e. not Engines
+            assert not obj.is_monotonic_increasing
+        assert not obj.is_monotonic_increasing
+        assert not obj.is_monotonic_decreasing
+        assert obj.is_unique
+
+    dti2 = dti.insert(3, NaT)
+    pi2 = dti2.to_period("h")
+    tdi2 = Index(dti2.view("timedelta64[ns]"))
+
+    for obj in [pi2, pi2._engine, dti2, dti2._engine, tdi2, tdi2._engine]:
+        if isinstance(obj, Index):
+            # i.e. not Engines
+            assert not obj.is_monotonic_increasing
+        assert not obj.is_monotonic_increasing
+        assert not obj.is_monotonic_decreasing
+        assert obj.is_unique

llmeval-env/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/test_nat.py

@@ -0,0 +1,53 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DatetimeIndex,
+    NaT,
+    PeriodIndex,
+    TimedeltaIndex,
+)
+import pandas._testing as tm
+
+
+class NATests:
+    def test_nat(self, index_without_na):
+        empty_index = index_without_na[:0]
+
+        index_with_na = index_without_na.copy(deep=True)
+        index_with_na._data[1] = NaT
+
+        assert empty_index._na_value is NaT
+        assert index_with_na._na_value is NaT
+        assert index_without_na._na_value is NaT
+
+        idx = index_without_na
+        assert idx._can_hold_na
+
+        tm.assert_numpy_array_equal(idx._isnan, np.array([False, False]))
+        assert idx.hasnans is False
+
+        idx = index_with_na
+        assert idx._can_hold_na
+
+        tm.assert_numpy_array_equal(idx._isnan, np.array([False, True]))
+        assert idx.hasnans is True
+
+
+class TestDatetimeIndexNA(NATests):
+    @pytest.fixture
+    def index_without_na(self, tz_naive_fixture):
+        tz = tz_naive_fixture
+        return DatetimeIndex(["2011-01-01", "2011-01-02"], tz=tz)
+
+
+class TestTimedeltaIndexNA(NATests):
+    @pytest.fixture
+    def index_without_na(self):
+        return TimedeltaIndex(["1 days", "2 days"])
+
+
+class TestPeriodIndexNA(NATests):
+    @pytest.fixture
+    def index_without_na(self):
+        return PeriodIndex(["2011-01-01", "2011-01-02"], freq="D")

llmeval-env/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/test_sort_values.py

@@ -0,0 +1,315 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DatetimeIndex,
+    Index,
+    NaT,
+    PeriodIndex,
+    TimedeltaIndex,
+    timedelta_range,
+)
+import pandas._testing as tm
+
+
+def check_freq_ascending(ordered, orig, ascending):
+    """
+    Check the expected freq on a PeriodIndex/DatetimeIndex/TimedeltaIndex
+    when the original index is generated (or generate-able) with
+    period_range/date_range/timedelta_range.
+    """
+    if isinstance(ordered, PeriodIndex):
+        assert ordered.freq == orig.freq
+    elif isinstance(ordered, (DatetimeIndex, TimedeltaIndex)):
+        if ascending:
+            assert ordered.freq.n == orig.freq.n
+        else:
+            assert ordered.freq.n == -1 * orig.freq.n
+
+
+def check_freq_nonmonotonic(ordered, orig):
+    """
+    Check the expected freq on a PeriodIndex/DatetimeIndex/TimedeltaIndex
+    when the original index is _not_ generated (or generate-able) with
+    period_range/date_range//timedelta_range.
+    """
+    if isinstance(ordered, PeriodIndex):
+        assert ordered.freq == orig.freq
+    elif isinstance(ordered, (DatetimeIndex, TimedeltaIndex)):
+        assert ordered.freq is None
+
+
+class TestSortValues:
+    @pytest.fixture(params=[DatetimeIndex, TimedeltaIndex, PeriodIndex])
+    def non_monotonic_idx(self, request):
+        if request.param is DatetimeIndex:
+            return DatetimeIndex(["2000-01-04", "2000-01-01", "2000-01-02"])
+        elif request.param is PeriodIndex:
+            dti = DatetimeIndex(["2000-01-04", "2000-01-01", "2000-01-02"])
+            return dti.to_period("D")
+        else:
+            return TimedeltaIndex(
+                ["1 day 00:00:05", "1 day 00:00:01", "1 day 00:00:02"]
+            )
+
+    def test_argmin_argmax(self, non_monotonic_idx):
+        assert non_monotonic_idx.argmin() == 1
+        assert non_monotonic_idx.argmax() == 0
+
+    def test_sort_values(self, non_monotonic_idx):
+        idx = non_monotonic_idx
+        ordered = idx.sort_values()
+        assert ordered.is_monotonic_increasing
+        ordered = idx.sort_values(ascending=False)
+        assert ordered[::-1].is_monotonic_increasing
+
+        ordered, dexer = idx.sort_values(return_indexer=True)
+        assert ordered.is_monotonic_increasing
+        tm.assert_numpy_array_equal(dexer, np.array([1, 2, 0], dtype=np.intp))
+
+        ordered, dexer = idx.sort_values(return_indexer=True, ascending=False)
+        assert ordered[::-1].is_monotonic_increasing
+        tm.assert_numpy_array_equal(dexer, np.array([0, 2, 1], dtype=np.intp))
+
+    def check_sort_values_with_freq(self, idx):
+        ordered = idx.sort_values()
+        tm.assert_index_equal(ordered, idx)
+        check_freq_ascending(ordered, idx, True)
+
+        ordered = idx.sort_values(ascending=False)
+        expected = idx[::-1]
+        tm.assert_index_equal(ordered, expected)
+        check_freq_ascending(ordered, idx, False)
+
+        ordered, indexer = idx.sort_values(return_indexer=True)
+        tm.assert_index_equal(ordered, idx)
+        tm.assert_numpy_array_equal(indexer, np.array([0, 1, 2], dtype=np.intp))
+        check_freq_ascending(ordered, idx, True)
+
+        ordered, indexer = idx.sort_values(return_indexer=True, ascending=False)
+        expected = idx[::-1]
+        tm.assert_index_equal(ordered, expected)
+        tm.assert_numpy_array_equal(indexer, np.array([2, 1, 0], dtype=np.intp))
+        check_freq_ascending(ordered, idx, False)
+
+    @pytest.mark.parametrize("freq", ["D", "h"])
+    def test_sort_values_with_freq_timedeltaindex(self, freq):
+        # GH#10295
+        idx = timedelta_range(start=f"1{freq}", periods=3, freq=freq).rename("idx")
+
+        self.check_sort_values_with_freq(idx)
+
+    @pytest.mark.parametrize(
+        "idx",
+        [
+            DatetimeIndex(
+                ["2011-01-01", "2011-01-02", "2011-01-03"], freq="D", name="idx"
+            ),
+            DatetimeIndex(
+                ["2011-01-01 09:00", "2011-01-01 10:00", "2011-01-01 11:00"],
+                freq="h",
+                name="tzidx",
+                tz="Asia/Tokyo",
+            ),
+        ],
+    )
+    def test_sort_values_with_freq_datetimeindex(self, idx):
+        self.check_sort_values_with_freq(idx)
+
+    @pytest.mark.parametrize("freq", ["D", "2D", "4D"])
+    def test_sort_values_with_freq_periodindex(self, freq):
+        # here with_freq refers to being period_range-like
+        idx = PeriodIndex(
+            ["2011-01-01", "2011-01-02", "2011-01-03"], freq=freq, name="idx"
+        )
+        self.check_sort_values_with_freq(idx)
+
+    @pytest.mark.parametrize(
+        "idx",
+        [
+            PeriodIndex(["2011", "2012", "2013"], name="pidx", freq="Y"),
+            Index([2011, 2012, 2013], name="idx"),  # for compatibility check
+        ],
+    )
+    def test_sort_values_with_freq_periodindex2(self, idx):
+        # here with_freq indicates this is period_range-like
+        self.check_sort_values_with_freq(idx)
+
+    def check_sort_values_without_freq(self, idx, expected):
+        ordered = idx.sort_values(na_position="first")
+        tm.assert_index_equal(ordered, expected)
+        check_freq_nonmonotonic(ordered, idx)
+
+        if not idx.isna().any():
+            ordered = idx.sort_values()
+            tm.assert_index_equal(ordered, expected)
+            check_freq_nonmonotonic(ordered, idx)
+
+        ordered = idx.sort_values(ascending=False)
+        tm.assert_index_equal(ordered, expected[::-1])
+        check_freq_nonmonotonic(ordered, idx)
+
+        ordered, indexer = idx.sort_values(return_indexer=True, na_position="first")
+        tm.assert_index_equal(ordered, expected)
+
+        exp = np.array([0, 4, 3, 1, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(indexer, exp)
+        check_freq_nonmonotonic(ordered, idx)
+
+        if not idx.isna().any():
+            ordered, indexer = idx.sort_values(return_indexer=True)
+            tm.assert_index_equal(ordered, expected)
+
+            exp = np.array([0, 4, 3, 1, 2], dtype=np.intp)
+            tm.assert_numpy_array_equal(indexer, exp)
+            check_freq_nonmonotonic(ordered, idx)
+
+        ordered, indexer = idx.sort_values(return_indexer=True, ascending=False)
+        tm.assert_index_equal(ordered, expected[::-1])
+
+        exp = np.array([2, 1, 3, 0, 4], dtype=np.intp)
+        tm.assert_numpy_array_equal(indexer, exp)
+        check_freq_nonmonotonic(ordered, idx)
+
+    def test_sort_values_without_freq_timedeltaindex(self):
+        # GH#10295
+
+        idx = TimedeltaIndex(
+            ["1 hour", "3 hour", "5 hour", "2 hour ", "1 hour"], name="idx1"
+        )
+        expected = TimedeltaIndex(
+            ["1 hour", "1 hour", "2 hour", "3 hour", "5 hour"], name="idx1"
+        )
+        self.check_sort_values_without_freq(idx, expected)
+
+    @pytest.mark.parametrize(
+        "index_dates,expected_dates",
+        [
+            (
+                ["2011-01-01", "2011-01-03", "2011-01-05", "2011-01-02", "2011-01-01"],
+                ["2011-01-01", "2011-01-01", "2011-01-02", "2011-01-03", "2011-01-05"],
+            ),
+            (
+                ["2011-01-01", "2011-01-03", "2011-01-05", "2011-01-02", "2011-01-01"],
+                ["2011-01-01", "2011-01-01", "2011-01-02", "2011-01-03", "2011-01-05"],
+            ),
+            (
+                [NaT, "2011-01-03", "2011-01-05", "2011-01-02", NaT],
+                [NaT, NaT, "2011-01-02", "2011-01-03", "2011-01-05"],
+            ),
+        ],
+    )
+    def test_sort_values_without_freq_datetimeindex(
+        self, index_dates, expected_dates, tz_naive_fixture
+    ):
+        tz = tz_naive_fixture
+
+        # without freq
+        idx = DatetimeIndex(index_dates, tz=tz, name="idx")
+        expected = DatetimeIndex(expected_dates, tz=tz, name="idx")
+
+        self.check_sort_values_without_freq(idx, expected)
+
+    @pytest.mark.parametrize(
+        "idx,expected",
+        [
+            (
+                PeriodIndex(
+                    [
+                        "2011-01-01",
+                        "2011-01-03",
+                        "2011-01-05",
+                        "2011-01-02",
+                        "2011-01-01",
+                    ],
+                    freq="D",
+                    name="idx1",
+                ),
+                PeriodIndex(
+                    [
+                        "2011-01-01",
+                        "2011-01-01",
+                        "2011-01-02",
+                        "2011-01-03",
+                        "2011-01-05",
+                    ],
+                    freq="D",
+                    name="idx1",
+                ),
+            ),
+            (
+                PeriodIndex(
+                    [
+                        "2011-01-01",
+                        "2011-01-03",
+                        "2011-01-05",
+                        "2011-01-02",
+                        "2011-01-01",
+                    ],
+                    freq="D",
+                    name="idx2",
+                ),
+                PeriodIndex(
+                    [
+                        "2011-01-01",
+                        "2011-01-01",
+                        "2011-01-02",
+                        "2011-01-03",
+                        "2011-01-05",
+                    ],
+                    freq="D",
+                    name="idx2",
+                ),
+            ),
+            (
+                PeriodIndex(
+                    [NaT, "2011-01-03", "2011-01-05", "2011-01-02", NaT],
+                    freq="D",
+                    name="idx3",
+                ),
+                PeriodIndex(
+                    [NaT, NaT, "2011-01-02", "2011-01-03", "2011-01-05"],
+                    freq="D",
+                    name="idx3",
+                ),
+            ),
+            (
+                PeriodIndex(
+                    ["2011", "2013", "2015", "2012", "2011"], name="pidx", freq="Y"
+                ),
+                PeriodIndex(
+                    ["2011", "2011", "2012", "2013", "2015"], name="pidx", freq="Y"
+                ),
+            ),
+            (
+                # For compatibility check
+                Index([2011, 2013, 2015, 2012, 2011], name="idx"),
+                Index([2011, 2011, 2012, 2013, 2015], name="idx"),
+            ),
+        ],
+    )
+    def test_sort_values_without_freq_periodindex(self, idx, expected):
+        # here without_freq means not generateable by period_range
+        self.check_sort_values_without_freq(idx, expected)
+
+    def test_sort_values_without_freq_periodindex_nat(self):
+        # doesn't quite fit into check_sort_values_without_freq
+        idx = PeriodIndex(["2011", "2013", "NaT", "2011"], name="pidx", freq="D")
+        expected = PeriodIndex(["NaT", "2011", "2011", "2013"], name="pidx", freq="D")
+
+        ordered = idx.sort_values(na_position="first")
+        tm.assert_index_equal(ordered, expected)
+        check_freq_nonmonotonic(ordered, idx)
+
+        ordered = idx.sort_values(ascending=False)
+        tm.assert_index_equal(ordered, expected[::-1])
+        check_freq_nonmonotonic(ordered, idx)
+
+
+def test_order_stability_compat():
+    # GH#35922. sort_values is stable both for normal and datetime-like Index
+    pidx = PeriodIndex(["2011", "2013", "2015", "2012", "2011"], name="pidx", freq="Y")
+    iidx = Index([2011, 2013, 2015, 2012, 2011], name="idx")
+    ordered1, indexer1 = pidx.sort_values(return_indexer=True, ascending=False)
+    ordered2, indexer2 = iidx.sort_values(return_indexer=True, ascending=False)
+    tm.assert_numpy_array_equal(indexer1, indexer2)

llmeval-env/lib/python3.10/site-packages/pandas/tests/indexes/datetimelike_/test_value_counts.py

@@ -0,0 +1,103 @@
+import numpy as np
+
+from pandas import (
+    DatetimeIndex,
+    NaT,
+    PeriodIndex,
+    Series,
+    TimedeltaIndex,
+    date_range,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+
+
+class TestValueCounts:
+    # GH#7735
+
+    def test_value_counts_unique_datetimeindex(self, tz_naive_fixture):
+        tz = tz_naive_fixture
+        orig = date_range("2011-01-01 09:00", freq="h", periods=10, tz=tz)
+        self._check_value_counts_with_repeats(orig)
+
+    def test_value_counts_unique_timedeltaindex(self):
+        orig = timedelta_range("1 days 09:00:00", freq="h", periods=10)
+        self._check_value_counts_with_repeats(orig)
+
+    def test_value_counts_unique_periodindex(self):
+        orig = period_range("2011-01-01 09:00", freq="h", periods=10)
+        self._check_value_counts_with_repeats(orig)
+
+    def _check_value_counts_with_repeats(self, orig):
+        # create repeated values, 'n'th element is repeated by n+1 times
+        idx = type(orig)(
+            np.repeat(orig._values, range(1, len(orig) + 1)), dtype=orig.dtype
+        )
+
+        exp_idx = orig[::-1]
+        if not isinstance(exp_idx, PeriodIndex):
+            exp_idx = exp_idx._with_freq(None)
+        expected = Series(range(10, 0, -1), index=exp_idx, dtype="int64", name="count")
+
+        for obj in [idx, Series(idx)]:
+            tm.assert_series_equal(obj.value_counts(), expected)
+
+        tm.assert_index_equal(idx.unique(), orig)
+
+    def test_value_counts_unique_datetimeindex2(self, tz_naive_fixture):
+        tz = tz_naive_fixture
+        idx = DatetimeIndex(
+            [
+                "2013-01-01 09:00",
+                "2013-01-01 09:00",
+                "2013-01-01 09:00",
+                "2013-01-01 08:00",
+                "2013-01-01 08:00",
+                NaT,
+            ],
+            tz=tz,
+        )
+        self._check_value_counts_dropna(idx)
+
+    def test_value_counts_unique_timedeltaindex2(self):
+        idx = TimedeltaIndex(
+            [
+                "1 days 09:00:00",
+                "1 days 09:00:00",
+                "1 days 09:00:00",
+                "1 days 08:00:00",
+                "1 days 08:00:00",
+                NaT,
+            ]
+        )
+        self._check_value_counts_dropna(idx)
+
+    def test_value_counts_unique_periodindex2(self):
+        idx = PeriodIndex(
+            [
+                "2013-01-01 09:00",
+                "2013-01-01 09:00",
+                "2013-01-01 09:00",
+                "2013-01-01 08:00",
+                "2013-01-01 08:00",
+                NaT,
+            ],
+            freq="h",
+        )
+        self._check_value_counts_dropna(idx)
+
+    def _check_value_counts_dropna(self, idx):
+        exp_idx = idx[[2, 3]]
+        expected = Series([3, 2], index=exp_idx, name="count")
+
+        for obj in [idx, Series(idx)]:
+            tm.assert_series_equal(obj.value_counts(), expected)
+
+        exp_idx = idx[[2, 3, -1]]
+        expected = Series([3, 2, 1], index=exp_idx, name="count")
+
+        for obj in [idx, Series(idx)]:
+            tm.assert_series_equal(obj.value_counts(dropna=False), expected)
+
+        tm.assert_index_equal(idx.unique(), exp_idx)