Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/pandas/tests/apply/common.py

@@ -0,0 +1,7 @@
+from pandas.core.groupby.base import transformation_kernels
+
+# There is no Series.cumcount or DataFrame.cumcount
+series_transform_kernels = [
+    x for x in sorted(transformation_kernels) if x != "cumcount"
+]
+frame_transform_kernels = [x for x in sorted(transformation_kernels) if x != "cumcount"]

env-llmeval/lib/python3.10/site-packages/pandas/tests/apply/test_frame_apply.py

@@ -0,0 +1,1733 @@
+from datetime import datetime
+import warnings
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.dtypes import CategoricalDtype
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    Series,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+from pandas.tests.frame.common import zip_frames
+
+
+@pytest.fixture
+def int_frame_const_col():
+    """
+    Fixture for DataFrame of ints which are constant per column
+
+    Columns are ['A', 'B', 'C'], with values (per column): [1, 2, 3]
+    """
+    df = DataFrame(
+        np.tile(np.arange(3, dtype="int64"), 6).reshape(6, -1) + 1,
+        columns=["A", "B", "C"],
+    )
+    return df
+
+
+@pytest.fixture(params=["python", pytest.param("numba", marks=pytest.mark.single_cpu)])
+def engine(request):
+    if request.param == "numba":
+        pytest.importorskip("numba")
+    return request.param
+
+
+def test_apply(float_frame, engine, request):
+    if engine == "numba":
+        mark = pytest.mark.xfail(reason="numba engine not supporting numpy ufunc yet")
+        request.node.add_marker(mark)
+    with np.errstate(all="ignore"):
+        # ufunc
+        result = np.sqrt(float_frame["A"])
+        expected = float_frame.apply(np.sqrt, engine=engine)["A"]
+        tm.assert_series_equal(result, expected)
+
+        # aggregator
+        result = float_frame.apply(np.mean, engine=engine)["A"]
+        expected = np.mean(float_frame["A"])
+        assert result == expected
+
+        d = float_frame.index[0]
+        result = float_frame.apply(np.mean, axis=1, engine=engine)
+        expected = np.mean(float_frame.xs(d))
+        assert result[d] == expected
+        assert result.index is float_frame.index
+
+
+@pytest.mark.parametrize("axis", [0, 1])
+@pytest.mark.parametrize("raw", [True, False])
+def test_apply_args(float_frame, axis, raw, engine, request):
+    if engine == "numba":
+        mark = pytest.mark.xfail(reason="numba engine doesn't support args")
+        request.node.add_marker(mark)
+    result = float_frame.apply(
+        lambda x, y: x + y, axis, args=(1,), raw=raw, engine=engine
+    )
+    expected = float_frame + 1
+    tm.assert_frame_equal(result, expected)
+
+
+def test_apply_categorical_func():
+    # GH 9573
+    df = DataFrame({"c0": ["A", "A", "B", "B"], "c1": ["C", "C", "D", "D"]})
+    result = df.apply(lambda ts: ts.astype("category"))
+
+    assert result.shape == (4, 2)
+    assert isinstance(result["c0"].dtype, CategoricalDtype)
+    assert isinstance(result["c1"].dtype, CategoricalDtype)
+
+
+def test_apply_axis1_with_ea():
+    # GH#36785
+    expected = DataFrame({"A": [Timestamp("2013-01-01", tz="UTC")]})
+    result = expected.apply(lambda x: x, axis=1)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "data, dtype",
+    [(1, None), (1, CategoricalDtype([1])), (Timestamp("2013-01-01", tz="UTC"), None)],
+)
+def test_agg_axis1_duplicate_index(data, dtype):
+    # GH 42380
+    expected = DataFrame([[data], [data]], index=["a", "a"], dtype=dtype)
+    result = expected.agg(lambda x: x, axis=1)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_apply_mixed_datetimelike():
+    # mixed datetimelike
+    # GH 7778
+    expected = DataFrame(
+        {
+            "A": date_range("20130101", periods=3),
+            "B": pd.to_timedelta(np.arange(3), unit="s"),
+        }
+    )
+    result = expected.apply(lambda x: x, axis=1)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("func", [np.sqrt, np.mean])
+def test_apply_empty(func, engine):
+    # empty
+    empty_frame = DataFrame()
+
+    result = empty_frame.apply(func, engine=engine)
+    assert result.empty
+
+
+def test_apply_float_frame(float_frame, engine):
+    no_rows = float_frame[:0]
+    result = no_rows.apply(lambda x: x.mean(), engine=engine)
+    expected = Series(np.nan, index=float_frame.columns)
+    tm.assert_series_equal(result, expected)
+
+    no_cols = float_frame.loc[:, []]
+    result = no_cols.apply(lambda x: x.mean(), axis=1, engine=engine)
+    expected = Series(np.nan, index=float_frame.index)
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_empty_except_index(engine):
+    # GH 2476
+    expected = DataFrame(index=["a"])
+    result = expected.apply(lambda x: x["a"], axis=1, engine=engine)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_apply_with_reduce_empty():
+    # reduce with an empty DataFrame
+    empty_frame = DataFrame()
+
+    x = []
+    result = empty_frame.apply(x.append, axis=1, result_type="expand")
+    tm.assert_frame_equal(result, empty_frame)
+    result = empty_frame.apply(x.append, axis=1, result_type="reduce")
+    expected = Series([], dtype=np.float64)
+    tm.assert_series_equal(result, expected)
+
+    empty_with_cols = DataFrame(columns=["a", "b", "c"])
+    result = empty_with_cols.apply(x.append, axis=1, result_type="expand")
+    tm.assert_frame_equal(result, empty_with_cols)
+    result = empty_with_cols.apply(x.append, axis=1, result_type="reduce")
+    expected = Series([], dtype=np.float64)
+    tm.assert_series_equal(result, expected)
+
+    # Ensure that x.append hasn't been called
+    assert x == []
+
+
+@pytest.mark.parametrize("func", ["sum", "prod", "any", "all"])
+def test_apply_funcs_over_empty(func):
+    # GH 28213
+    df = DataFrame(columns=["a", "b", "c"])
+
+    result = df.apply(getattr(np, func))
+    expected = getattr(df, func)()
+    if func in ("sum", "prod"):
+        expected = expected.astype(float)
+    tm.assert_series_equal(result, expected)
+
+
+def test_nunique_empty():
+    # GH 28213
+    df = DataFrame(columns=["a", "b", "c"])
+
+    result = df.nunique()
+    expected = Series(0, index=df.columns)
+    tm.assert_series_equal(result, expected)
+
+    result = df.T.nunique()
+    expected = Series([], dtype=np.float64)
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_standard_nonunique():
+    df = DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]], index=["a", "a", "c"])
+
+    result = df.apply(lambda s: s[0], axis=1)
+    expected = Series([1, 4, 7], ["a", "a", "c"])
+    tm.assert_series_equal(result, expected)
+
+    result = df.T.apply(lambda s: s[0], axis=0)
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_broadcast_scalars(float_frame):
+    # scalars
+    result = float_frame.apply(np.mean, result_type="broadcast")
+    expected = DataFrame([float_frame.mean()], index=float_frame.index)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_apply_broadcast_scalars_axis1(float_frame):
+    result = float_frame.apply(np.mean, axis=1, result_type="broadcast")
+    m = float_frame.mean(axis=1)
+    expected = DataFrame({c: m for c in float_frame.columns})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_apply_broadcast_lists_columns(float_frame):
+    # lists
+    result = float_frame.apply(
+        lambda x: list(range(len(float_frame.columns))),
+        axis=1,
+        result_type="broadcast",
+    )
+    m = list(range(len(float_frame.columns)))
+    expected = DataFrame(
+        [m] * len(float_frame.index),
+        dtype="float64",
+        index=float_frame.index,
+        columns=float_frame.columns,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_apply_broadcast_lists_index(float_frame):
+    result = float_frame.apply(
+        lambda x: list(range(len(float_frame.index))), result_type="broadcast"
+    )
+    m = list(range(len(float_frame.index)))
+    expected = DataFrame(
+        {c: m for c in float_frame.columns},
+        dtype="float64",
+        index=float_frame.index,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_apply_broadcast_list_lambda_func(int_frame_const_col):
+    # preserve columns
+    df = int_frame_const_col
+    result = df.apply(lambda x: [1, 2, 3], axis=1, result_type="broadcast")
+    tm.assert_frame_equal(result, df)
+
+
+def test_apply_broadcast_series_lambda_func(int_frame_const_col):
+    df = int_frame_const_col
+    result = df.apply(
+        lambda x: Series([1, 2, 3], index=list("abc")),
+        axis=1,
+        result_type="broadcast",
+    )
+    expected = df.copy()
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("axis", [0, 1])
+def test_apply_raw_float_frame(float_frame, axis, engine):
+    if engine == "numba":
+        pytest.skip("numba can't handle when UDF returns None.")
+
+    def _assert_raw(x):
+        assert isinstance(x, np.ndarray)
+        assert x.ndim == 1
+
+    float_frame.apply(_assert_raw, axis=axis, engine=engine, raw=True)
+
+
+@pytest.mark.parametrize("axis", [0, 1])
+def test_apply_raw_float_frame_lambda(float_frame, axis, engine):
+    result = float_frame.apply(np.mean, axis=axis, engine=engine, raw=True)
+    expected = float_frame.apply(lambda x: x.values.mean(), axis=axis)
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_raw_float_frame_no_reduction(float_frame, engine):
+    # no reduction
+    result = float_frame.apply(lambda x: x * 2, engine=engine, raw=True)
+    expected = float_frame * 2
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("axis", [0, 1])
+def test_apply_raw_mixed_type_frame(axis, engine):
+    if engine == "numba":
+        pytest.skip("isinstance check doesn't work with numba")
+
+    def _assert_raw(x):
+        assert isinstance(x, np.ndarray)
+        assert x.ndim == 1
+
+    # Mixed dtype (GH-32423)
+    df = DataFrame(
+        {
+            "a": 1.0,
+            "b": 2,
+            "c": "foo",
+            "float32": np.array([1.0] * 10, dtype="float32"),
+            "int32": np.array([1] * 10, dtype="int32"),
+        },
+        index=np.arange(10),
+    )
+    df.apply(_assert_raw, axis=axis, engine=engine, raw=True)
+
+
+def test_apply_axis1(float_frame):
+    d = float_frame.index[0]
+    result = float_frame.apply(np.mean, axis=1)[d]
+    expected = np.mean(float_frame.xs(d))
+    assert result == expected
+
+
+def test_apply_mixed_dtype_corner():
+    df = DataFrame({"A": ["foo"], "B": [1.0]})
+    result = df[:0].apply(np.mean, axis=1)
+    # the result here is actually kind of ambiguous, should it be a Series
+    # or a DataFrame?
+    expected = Series(np.nan, index=pd.Index([], dtype="int64"))
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_mixed_dtype_corner_indexing():
+    df = DataFrame({"A": ["foo"], "B": [1.0]})
+    result = df.apply(lambda x: x["A"], axis=1)
+    expected = Series(["foo"], index=[0])
+    tm.assert_series_equal(result, expected)
+
+    result = df.apply(lambda x: x["B"], axis=1)
+    expected = Series([1.0], index=[0])
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.filterwarnings("ignore::RuntimeWarning")
+@pytest.mark.parametrize("ax", ["index", "columns"])
+@pytest.mark.parametrize(
+    "func", [lambda x: x, lambda x: x.mean()], ids=["identity", "mean"]
+)
+@pytest.mark.parametrize("raw", [True, False])
+@pytest.mark.parametrize("axis", [0, 1])
+def test_apply_empty_infer_type(ax, func, raw, axis, engine, request):
+    df = DataFrame(**{ax: ["a", "b", "c"]})
+
+    with np.errstate(all="ignore"):
+        test_res = func(np.array([], dtype="f8"))
+        is_reduction = not isinstance(test_res, np.ndarray)
+
+        result = df.apply(func, axis=axis, engine=engine, raw=raw)
+        if is_reduction:
+            agg_axis = df._get_agg_axis(axis)
+            assert isinstance(result, Series)
+            assert result.index is agg_axis
+        else:
+            assert isinstance(result, DataFrame)
+
+
+def test_apply_empty_infer_type_broadcast():
+    no_cols = DataFrame(index=["a", "b", "c"])
+    result = no_cols.apply(lambda x: x.mean(), result_type="broadcast")
+    assert isinstance(result, DataFrame)
+
+
+def test_apply_with_args_kwds_add_some(float_frame):
+    def add_some(x, howmuch=0):
+        return x + howmuch
+
+    result = float_frame.apply(add_some, howmuch=2)
+    expected = float_frame.apply(lambda x: x + 2)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_apply_with_args_kwds_agg_and_add(float_frame):
+    def agg_and_add(x, howmuch=0):
+        return x.mean() + howmuch
+
+    result = float_frame.apply(agg_and_add, howmuch=2)
+    expected = float_frame.apply(lambda x: x.mean() + 2)
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_with_args_kwds_subtract_and_divide(float_frame):
+    def subtract_and_divide(x, sub, divide=1):
+        return (x - sub) / divide
+
+    result = float_frame.apply(subtract_and_divide, args=(2,), divide=2)
+    expected = float_frame.apply(lambda x: (x - 2.0) / 2.0)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_apply_yield_list(float_frame):
+    result = float_frame.apply(list)
+    tm.assert_frame_equal(result, float_frame)
+
+
+def test_apply_reduce_Series(float_frame):
+    float_frame.iloc[::2, float_frame.columns.get_loc("A")] = np.nan
+    expected = float_frame.mean(1)
+    result = float_frame.apply(np.mean, axis=1)
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_reduce_to_dict():
+    # GH 25196 37544
+    data = DataFrame([[1, 2], [3, 4]], columns=["c0", "c1"], index=["i0", "i1"])
+
+    result = data.apply(dict, axis=0)
+    expected = Series([{"i0": 1, "i1": 3}, {"i0": 2, "i1": 4}], index=data.columns)
+    tm.assert_series_equal(result, expected)
+
+    result = data.apply(dict, axis=1)
+    expected = Series([{"c0": 1, "c1": 2}, {"c0": 3, "c1": 4}], index=data.index)
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_differently_indexed():
+    df = DataFrame(np.random.default_rng(2).standard_normal((20, 10)))
+
+    result = df.apply(Series.describe, axis=0)
+    expected = DataFrame({i: v.describe() for i, v in df.items()}, columns=df.columns)
+    tm.assert_frame_equal(result, expected)
+
+    result = df.apply(Series.describe, axis=1)
+    expected = DataFrame({i: v.describe() for i, v in df.T.items()}, columns=df.index).T
+    tm.assert_frame_equal(result, expected)
+
+
+def test_apply_bug():
+    # GH 6125
+    positions = DataFrame(
+        [
+            [1, "ABC0", 50],
+            [1, "YUM0", 20],
+            [1, "DEF0", 20],
+            [2, "ABC1", 50],
+            [2, "YUM1", 20],
+            [2, "DEF1", 20],
+        ],
+        columns=["a", "market", "position"],
+    )
+
+    def f(r):
+        return r["market"]
+
+    expected = positions.apply(f, axis=1)
+
+    positions = DataFrame(
+        [
+            [datetime(2013, 1, 1), "ABC0", 50],
+            [datetime(2013, 1, 2), "YUM0", 20],
+            [datetime(2013, 1, 3), "DEF0", 20],
+            [datetime(2013, 1, 4), "ABC1", 50],
+            [datetime(2013, 1, 5), "YUM1", 20],
+            [datetime(2013, 1, 6), "DEF1", 20],
+        ],
+        columns=["a", "market", "position"],
+    )
+    result = positions.apply(f, axis=1)
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_convert_objects():
+    expected = DataFrame(
+        {
+            "A": [
+                "foo",
+                "foo",
+                "foo",
+                "foo",
+                "bar",
+                "bar",
+                "bar",
+                "bar",
+                "foo",
+                "foo",
+                "foo",
+            ],
+            "B": [
+                "one",
+                "one",
+                "one",
+                "two",
+                "one",
+                "one",
+                "one",
+                "two",
+                "two",
+                "two",
+                "one",
+            ],
+            "C": [
+                "dull",
+                "dull",
+                "shiny",
+                "dull",
+                "dull",
+                "shiny",
+                "shiny",
+                "dull",
+                "shiny",
+                "shiny",
+                "shiny",
+            ],
+            "D": np.random.default_rng(2).standard_normal(11),
+            "E": np.random.default_rng(2).standard_normal(11),
+            "F": np.random.default_rng(2).standard_normal(11),
+        }
+    )
+
+    result = expected.apply(lambda x: x, axis=1)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_apply_attach_name(float_frame):
+    result = float_frame.apply(lambda x: x.name)
+    expected = Series(float_frame.columns, index=float_frame.columns)
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_attach_name_axis1(float_frame):
+    result = float_frame.apply(lambda x: x.name, axis=1)
+    expected = Series(float_frame.index, index=float_frame.index)
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_attach_name_non_reduction(float_frame):
+    # non-reductions
+    result = float_frame.apply(lambda x: np.repeat(x.name, len(x)))
+    expected = DataFrame(
+        np.tile(float_frame.columns, (len(float_frame.index), 1)),
+        index=float_frame.index,
+        columns=float_frame.columns,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_apply_attach_name_non_reduction_axis1(float_frame):
+    result = float_frame.apply(lambda x: np.repeat(x.name, len(x)), axis=1)
+    expected = Series(
+        np.repeat(t[0], len(float_frame.columns)) for t in float_frame.itertuples()
+    )
+    expected.index = float_frame.index
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_multi_index():
+    index = MultiIndex.from_arrays([["a", "a", "b"], ["c", "d", "d"]])
+    s = DataFrame([[1, 2], [3, 4], [5, 6]], index=index, columns=["col1", "col2"])
+    result = s.apply(lambda x: Series({"min": min(x), "max": max(x)}), 1)
+    expected = DataFrame([[1, 2], [3, 4], [5, 6]], index=index, columns=["min", "max"])
+    tm.assert_frame_equal(result, expected, check_like=True)
+
+
+@pytest.mark.parametrize(
+    "df, dicts",
+    [
+        [
+            DataFrame([["foo", "bar"], ["spam", "eggs"]]),
+            Series([{0: "foo", 1: "spam"}, {0: "bar", 1: "eggs"}]),
+        ],
+        [DataFrame([[0, 1], [2, 3]]), Series([{0: 0, 1: 2}, {0: 1, 1: 3}])],
+    ],
+)
+def test_apply_dict(df, dicts):
+    # GH 8735
+    fn = lambda x: x.to_dict()
+    reduce_true = df.apply(fn, result_type="reduce")
+    reduce_false = df.apply(fn, result_type="expand")
+    reduce_none = df.apply(fn)
+
+    tm.assert_series_equal(reduce_true, dicts)
+    tm.assert_frame_equal(reduce_false, df)
+    tm.assert_series_equal(reduce_none, dicts)
+
+
+def test_apply_non_numpy_dtype():
+    # GH 12244
+    df = DataFrame({"dt": date_range("2015-01-01", periods=3, tz="Europe/Brussels")})
+    result = df.apply(lambda x: x)
+    tm.assert_frame_equal(result, df)
+
+    result = df.apply(lambda x: x + pd.Timedelta("1day"))
+    expected = DataFrame(
+        {"dt": date_range("2015-01-02", periods=3, tz="Europe/Brussels")}
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_apply_non_numpy_dtype_category():
+    df = DataFrame({"dt": ["a", "b", "c", "a"]}, dtype="category")
+    result = df.apply(lambda x: x)
+    tm.assert_frame_equal(result, df)
+
+
+def test_apply_dup_names_multi_agg():
+    # GH 21063
+    df = DataFrame([[0, 1], [2, 3]], columns=["a", "a"])
+    expected = DataFrame([[0, 1]], columns=["a", "a"], index=["min"])
+    result = df.agg(["min"])
+
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("op", ["apply", "agg"])
+def test_apply_nested_result_axis_1(op):
+    # GH 13820
+    def apply_list(row):
+        return [2 * row["A"], 2 * row["C"], 2 * row["B"]]
+
+    df = DataFrame(np.zeros((4, 4)), columns=list("ABCD"))
+    result = getattr(df, op)(apply_list, axis=1)
+    expected = Series(
+        [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_noreduction_tzaware_object():
+    # https://github.com/pandas-dev/pandas/issues/31505
+    expected = DataFrame(
+        {"foo": [Timestamp("2020", tz="UTC")]}, dtype="datetime64[ns, UTC]"
+    )
+    result = expected.apply(lambda x: x)
+    tm.assert_frame_equal(result, expected)
+    result = expected.apply(lambda x: x.copy())
+    tm.assert_frame_equal(result, expected)
+
+
+def test_apply_function_runs_once():
+    # https://github.com/pandas-dev/pandas/issues/30815
+
+    df = DataFrame({"a": [1, 2, 3]})
+    names = []  # Save row names function is applied to
+
+    def reducing_function(row):
+        names.append(row.name)
+
+    def non_reducing_function(row):
+        names.append(row.name)
+        return row
+
+    for func in [reducing_function, non_reducing_function]:
+        del names[:]
+
+        df.apply(func, axis=1)
+        assert names == list(df.index)
+
+
+def test_apply_raw_function_runs_once(engine):
+    # https://github.com/pandas-dev/pandas/issues/34506
+    if engine == "numba":
+        pytest.skip("appending to list outside of numba func is not supported")
+
+    df = DataFrame({"a": [1, 2, 3]})
+    values = []  # Save row values function is applied to
+
+    def reducing_function(row):
+        values.extend(row)
+
+    def non_reducing_function(row):
+        values.extend(row)
+        return row
+
+    for func in [reducing_function, non_reducing_function]:
+        del values[:]
+
+        df.apply(func, engine=engine, raw=True, axis=1)
+        assert values == list(df.a.to_list())
+
+
+def test_apply_with_byte_string():
+    # GH 34529
+    df = DataFrame(np.array([b"abcd", b"efgh"]), columns=["col"])
+    expected = DataFrame(np.array([b"abcd", b"efgh"]), columns=["col"], dtype=object)
+    # After we make the apply we expect a dataframe just
+    # like the original but with the object datatype
+    result = df.apply(lambda x: x.astype("object"))
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("val", ["asd", 12, None, np.nan])
+def test_apply_category_equalness(val):
+    # Check if categorical comparisons on apply, GH 21239
+    df_values = ["asd", None, 12, "asd", "cde", np.nan]
+    df = DataFrame({"a": df_values}, dtype="category")
+
+    result = df.a.apply(lambda x: x == val)
+    expected = Series(
+        [np.nan if pd.isnull(x) else x == val for x in df_values], name="a"
+    )
+    tm.assert_series_equal(result, expected)
+
+
+# the user has supplied an opaque UDF where
+# they are transforming the input that requires
+# us to infer the output
+
+
+def test_infer_row_shape():
+    # GH 17437
+    # if row shape is changing, infer it
+    df = DataFrame(np.random.default_rng(2).random((10, 2)))
+    result = df.apply(np.fft.fft, axis=0).shape
+    assert result == (10, 2)
+
+    result = df.apply(np.fft.rfft, axis=0).shape
+    assert result == (6, 2)
+
+
+@pytest.mark.parametrize(
+    "ops, by_row, expected",
+    [
+        ({"a": lambda x: x + 1}, "compat", DataFrame({"a": [2, 3]})),
+        ({"a": lambda x: x + 1}, False, DataFrame({"a": [2, 3]})),
+        ({"a": lambda x: x.sum()}, "compat", Series({"a": 3})),
+        ({"a": lambda x: x.sum()}, False, Series({"a": 3})),
+        (
+            {"a": ["sum", np.sum, lambda x: x.sum()]},
+            "compat",
+            DataFrame({"a": [3, 3, 3]}, index=["sum", "sum", "<lambda>"]),
+        ),
+        (
+            {"a": ["sum", np.sum, lambda x: x.sum()]},
+            False,
+            DataFrame({"a": [3, 3, 3]}, index=["sum", "sum", "<lambda>"]),
+        ),
+        ({"a": lambda x: 1}, "compat", DataFrame({"a": [1, 1]})),
+        ({"a": lambda x: 1}, False, Series({"a": 1})),
+    ],
+)
+def test_dictlike_lambda(ops, by_row, expected):
+    # GH53601
+    df = DataFrame({"a": [1, 2]})
+    result = df.apply(ops, by_row=by_row)
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ops",
+    [
+        {"a": lambda x: x + 1},
+        {"a": lambda x: x.sum()},
+        {"a": ["sum", np.sum, lambda x: x.sum()]},
+        {"a": lambda x: 1},
+    ],
+)
+def test_dictlike_lambda_raises(ops):
+    # GH53601
+    df = DataFrame({"a": [1, 2]})
+    with pytest.raises(ValueError, match="by_row=True not allowed"):
+        df.apply(ops, by_row=True)
+
+
+def test_with_dictlike_columns():
+    # GH 17602
+    df = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
+    result = df.apply(lambda x: {"s": x["a"] + x["b"]}, axis=1)
+    expected = Series([{"s": 3} for t in df.itertuples()])
+    tm.assert_series_equal(result, expected)
+
+    df["tm"] = [
+        Timestamp("2017-05-01 00:00:00"),
+        Timestamp("2017-05-02 00:00:00"),
+    ]
+    result = df.apply(lambda x: {"s": x["a"] + x["b"]}, axis=1)
+    tm.assert_series_equal(result, expected)
+
+    # compose a series
+    result = (df["a"] + df["b"]).apply(lambda x: {"s": x})
+    expected = Series([{"s": 3}, {"s": 3}])
+    tm.assert_series_equal(result, expected)
+
+
+def test_with_dictlike_columns_with_datetime():
+    # GH 18775
+    df = DataFrame()
+    df["author"] = ["X", "Y", "Z"]
+    df["publisher"] = ["BBC", "NBC", "N24"]
+    df["date"] = pd.to_datetime(
+        ["17-10-2010 07:15:30", "13-05-2011 08:20:35", "15-01-2013 09:09:09"],
+        dayfirst=True,
+    )
+    result = df.apply(lambda x: {}, axis=1)
+    expected = Series([{}, {}, {}])
+    tm.assert_series_equal(result, expected)
+
+
+def test_with_dictlike_columns_with_infer():
+    # GH 17602
+    df = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
+    result = df.apply(lambda x: {"s": x["a"] + x["b"]}, axis=1, result_type="expand")
+    expected = DataFrame({"s": [3, 3]})
+    tm.assert_frame_equal(result, expected)
+
+    df["tm"] = [
+        Timestamp("2017-05-01 00:00:00"),
+        Timestamp("2017-05-02 00:00:00"),
+    ]
+    result = df.apply(lambda x: {"s": x["a"] + x["b"]}, axis=1, result_type="expand")
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ops, by_row, expected",
+    [
+        ([lambda x: x + 1], "compat", DataFrame({("a", "<lambda>"): [2, 3]})),
+        ([lambda x: x + 1], False, DataFrame({("a", "<lambda>"): [2, 3]})),
+        ([lambda x: x.sum()], "compat", DataFrame({"a": [3]}, index=["<lambda>"])),
+        ([lambda x: x.sum()], False, DataFrame({"a": [3]}, index=["<lambda>"])),
+        (
+            ["sum", np.sum, lambda x: x.sum()],
+            "compat",
+            DataFrame({"a": [3, 3, 3]}, index=["sum", "sum", "<lambda>"]),
+        ),
+        (
+            ["sum", np.sum, lambda x: x.sum()],
+            False,
+            DataFrame({"a": [3, 3, 3]}, index=["sum", "sum", "<lambda>"]),
+        ),
+        (
+            [lambda x: x + 1, lambda x: 3],
+            "compat",
+            DataFrame([[2, 3], [3, 3]], columns=[["a", "a"], ["<lambda>", "<lambda>"]]),
+        ),
+        (
+            [lambda x: 2, lambda x: 3],
+            False,
+            DataFrame({"a": [2, 3]}, ["<lambda>", "<lambda>"]),
+        ),
+    ],
+)
+def test_listlike_lambda(ops, by_row, expected):
+    # GH53601
+    df = DataFrame({"a": [1, 2]})
+    result = df.apply(ops, by_row=by_row)
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ops",
+    [
+        [lambda x: x + 1],
+        [lambda x: x.sum()],
+        ["sum", np.sum, lambda x: x.sum()],
+        [lambda x: x + 1, lambda x: 3],
+    ],
+)
+def test_listlike_lambda_raises(ops):
+    # GH53601
+    df = DataFrame({"a": [1, 2]})
+    with pytest.raises(ValueError, match="by_row=True not allowed"):
+        df.apply(ops, by_row=True)
+
+
+def test_with_listlike_columns():
+    # GH 17348
+    df = DataFrame(
+        {
+            "a": Series(np.random.default_rng(2).standard_normal(4)),
+            "b": ["a", "list", "of", "words"],
+            "ts": date_range("2016-10-01", periods=4, freq="h"),
+        }
+    )
+
+    result = df[["a", "b"]].apply(tuple, axis=1)
+    expected = Series([t[1:] for t in df[["a", "b"]].itertuples()])
+    tm.assert_series_equal(result, expected)
+
+    result = df[["a", "ts"]].apply(tuple, axis=1)
+    expected = Series([t[1:] for t in df[["a", "ts"]].itertuples()])
+    tm.assert_series_equal(result, expected)
+
+
+def test_with_listlike_columns_returning_list():
+    # GH 18919
+    df = DataFrame({"x": Series([["a", "b"], ["q"]]), "y": Series([["z"], ["q", "t"]])})
+    df.index = MultiIndex.from_tuples([("i0", "j0"), ("i1", "j1")])
+
+    result = df.apply(lambda row: [el for el in row["x"] if el in row["y"]], axis=1)
+    expected = Series([[], ["q"]], index=df.index)
+    tm.assert_series_equal(result, expected)
+
+
+def test_infer_output_shape_columns():
+    # GH 18573
+
+    df = DataFrame(
+        {
+            "number": [1.0, 2.0],
+            "string": ["foo", "bar"],
+            "datetime": [
+                Timestamp("2017-11-29 03:30:00"),
+                Timestamp("2017-11-29 03:45:00"),
+            ],
+        }
+    )
+    result = df.apply(lambda row: (row.number, row.string), axis=1)
+    expected = Series([(t.number, t.string) for t in df.itertuples()])
+    tm.assert_series_equal(result, expected)
+
+
+def test_infer_output_shape_listlike_columns():
+    # GH 16353
+
+    df = DataFrame(
+        np.random.default_rng(2).standard_normal((6, 3)), columns=["A", "B", "C"]
+    )
+
+    result = df.apply(lambda x: [1, 2, 3], axis=1)
+    expected = Series([[1, 2, 3] for t in df.itertuples()])
+    tm.assert_series_equal(result, expected)
+
+    result = df.apply(lambda x: [1, 2], axis=1)
+    expected = Series([[1, 2] for t in df.itertuples()])
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("val", [1, 2])
+def test_infer_output_shape_listlike_columns_np_func(val):
+    # GH 17970
+    df = DataFrame({"a": [1, 2, 3]}, index=list("abc"))
+
+    result = df.apply(lambda row: np.ones(val), axis=1)
+    expected = Series([np.ones(val) for t in df.itertuples()], index=df.index)
+    tm.assert_series_equal(result, expected)
+
+
+def test_infer_output_shape_listlike_columns_with_timestamp():
+    # GH 17892
+    df = DataFrame(
+        {
+            "a": [
+                Timestamp("2010-02-01"),
+                Timestamp("2010-02-04"),
+                Timestamp("2010-02-05"),
+                Timestamp("2010-02-06"),
+            ],
+            "b": [9, 5, 4, 3],
+            "c": [5, 3, 4, 2],
+            "d": [1, 2, 3, 4],
+        }
+    )
+
+    def fun(x):
+        return (1, 2)
+
+    result = df.apply(fun, axis=1)
+    expected = Series([(1, 2) for t in df.itertuples()])
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("lst", [[1, 2, 3], [1, 2]])
+def test_consistent_coerce_for_shapes(lst):
+    # we want column names to NOT be propagated
+    # just because the shape matches the input shape
+    df = DataFrame(
+        np.random.default_rng(2).standard_normal((4, 3)), columns=["A", "B", "C"]
+    )
+
+    result = df.apply(lambda x: lst, axis=1)
+    expected = Series([lst for t in df.itertuples()])
+    tm.assert_series_equal(result, expected)
+
+
+def test_consistent_names(int_frame_const_col):
+    # if a Series is returned, we should use the resulting index names
+    df = int_frame_const_col
+
+    result = df.apply(
+        lambda x: Series([1, 2, 3], index=["test", "other", "cols"]), axis=1
+    )
+    expected = int_frame_const_col.rename(
+        columns={"A": "test", "B": "other", "C": "cols"}
+    )
+    tm.assert_frame_equal(result, expected)
+
+    result = df.apply(lambda x: Series([1, 2], index=["test", "other"]), axis=1)
+    expected = expected[["test", "other"]]
+    tm.assert_frame_equal(result, expected)
+
+
+def test_result_type(int_frame_const_col):
+    # result_type should be consistent no matter which
+    # path we take in the code
+    df = int_frame_const_col
+
+    result = df.apply(lambda x: [1, 2, 3], axis=1, result_type="expand")
+    expected = df.copy()
+    expected.columns = [0, 1, 2]
+    tm.assert_frame_equal(result, expected)
+
+
+def test_result_type_shorter_list(int_frame_const_col):
+    # result_type should be consistent no matter which
+    # path we take in the code
+    df = int_frame_const_col
+    result = df.apply(lambda x: [1, 2], axis=1, result_type="expand")
+    expected = df[["A", "B"]].copy()
+    expected.columns = [0, 1]
+    tm.assert_frame_equal(result, expected)
+
+
+def test_result_type_broadcast(int_frame_const_col, request, engine):
+    # result_type should be consistent no matter which
+    # path we take in the code
+    if engine == "numba":
+        mark = pytest.mark.xfail(reason="numba engine doesn't support list return")
+        request.node.add_marker(mark)
+    df = int_frame_const_col
+    # broadcast result
+    result = df.apply(
+        lambda x: [1, 2, 3], axis=1, result_type="broadcast", engine=engine
+    )
+    expected = df.copy()
+    tm.assert_frame_equal(result, expected)
+
+
+def test_result_type_broadcast_series_func(int_frame_const_col, engine, request):
+    # result_type should be consistent no matter which
+    # path we take in the code
+    if engine == "numba":
+        mark = pytest.mark.xfail(
+            reason="numba Series constructor only support ndarrays not list data"
+        )
+        request.node.add_marker(mark)
+    df = int_frame_const_col
+    columns = ["other", "col", "names"]
+    result = df.apply(
+        lambda x: Series([1, 2, 3], index=columns),
+        axis=1,
+        result_type="broadcast",
+        engine=engine,
+    )
+    expected = df.copy()
+    tm.assert_frame_equal(result, expected)
+
+
+def test_result_type_series_result(int_frame_const_col, engine, request):
+    # result_type should be consistent no matter which
+    # path we take in the code
+    if engine == "numba":
+        mark = pytest.mark.xfail(
+            reason="numba Series constructor only support ndarrays not list data"
+        )
+        request.node.add_marker(mark)
+    df = int_frame_const_col
+    # series result
+    result = df.apply(lambda x: Series([1, 2, 3], index=x.index), axis=1, engine=engine)
+    expected = df.copy()
+    tm.assert_frame_equal(result, expected)
+
+
+def test_result_type_series_result_other_index(int_frame_const_col, engine, request):
+    # result_type should be consistent no matter which
+    # path we take in the code
+
+    if engine == "numba":
+        mark = pytest.mark.xfail(
+            reason="no support in numba Series constructor for list of columns"
+        )
+        request.node.add_marker(mark)
+    df = int_frame_const_col
+    # series result with other index
+    columns = ["other", "col", "names"]
+    result = df.apply(lambda x: Series([1, 2, 3], index=columns), axis=1, engine=engine)
+    expected = df.copy()
+    expected.columns = columns
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "box",
+    [lambda x: list(x), lambda x: tuple(x), lambda x: np.array(x, dtype="int64")],
+    ids=["list", "tuple", "array"],
+)
+def test_consistency_for_boxed(box, int_frame_const_col):
+    # passing an array or list should not affect the output shape
+    df = int_frame_const_col
+
+    result = df.apply(lambda x: box([1, 2]), axis=1)
+    expected = Series([box([1, 2]) for t in df.itertuples()])
+    tm.assert_series_equal(result, expected)
+
+    result = df.apply(lambda x: box([1, 2]), axis=1, result_type="expand")
+    expected = int_frame_const_col[["A", "B"]].rename(columns={"A": 0, "B": 1})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_agg_transform(axis, float_frame):
+    other_axis = 1 if axis in {0, "index"} else 0
+
+    with np.errstate(all="ignore"):
+        f_abs = np.abs(float_frame)
+        f_sqrt = np.sqrt(float_frame)
+
+        # ufunc
+        expected = f_sqrt.copy()
+        result = float_frame.apply(np.sqrt, axis=axis)
+        tm.assert_frame_equal(result, expected)
+
+        # list-like
+        result = float_frame.apply([np.sqrt], axis=axis)
+        expected = f_sqrt.copy()
+        if axis in {0, "index"}:
+            expected.columns = MultiIndex.from_product([float_frame.columns, ["sqrt"]])
+        else:
+            expected.index = MultiIndex.from_product([float_frame.index, ["sqrt"]])
+        tm.assert_frame_equal(result, expected)
+
+        # multiple items in list
+        # these are in the order as if we are applying both
+        # functions per series and then concatting
+        result = float_frame.apply([np.abs, np.sqrt], axis=axis)
+        expected = zip_frames([f_abs, f_sqrt], axis=other_axis)
+        if axis in {0, "index"}:
+            expected.columns = MultiIndex.from_product(
+                [float_frame.columns, ["absolute", "sqrt"]]
+            )
+        else:
+            expected.index = MultiIndex.from_product(
+                [float_frame.index, ["absolute", "sqrt"]]
+            )
+        tm.assert_frame_equal(result, expected)
+
+
+def test_demo():
+    # demonstration tests
+    df = DataFrame({"A": range(5), "B": 5})
+
+    result = df.agg(["min", "max"])
+    expected = DataFrame(
+        {"A": [0, 4], "B": [5, 5]}, columns=["A", "B"], index=["min", "max"]
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_demo_dict_agg():
+    # demonstration tests
+    df = DataFrame({"A": range(5), "B": 5})
+    result = df.agg({"A": ["min", "max"], "B": ["sum", "max"]})
+    expected = DataFrame(
+        {"A": [4.0, 0.0, np.nan], "B": [5.0, np.nan, 25.0]},
+        columns=["A", "B"],
+        index=["max", "min", "sum"],
+    )
+    tm.assert_frame_equal(result.reindex_like(expected), expected)
+
+
+def test_agg_with_name_as_column_name():
+    # GH 36212 - Column name is "name"
+    data = {"name": ["foo", "bar"]}
+    df = DataFrame(data)
+
+    # result's name should be None
+    result = df.agg({"name": "count"})
+    expected = Series({"name": 2})
+    tm.assert_series_equal(result, expected)
+
+    # Check if name is still preserved when aggregating series instead
+    result = df["name"].agg({"name": "count"})
+    expected = Series({"name": 2}, name="name")
+    tm.assert_series_equal(result, expected)
+
+
+def test_agg_multiple_mixed():
+    # GH 20909
+    mdf = DataFrame(
+        {
+            "A": [1, 2, 3],
+            "B": [1.0, 2.0, 3.0],
+            "C": ["foo", "bar", "baz"],
+        }
+    )
+    expected = DataFrame(
+        {
+            "A": [1, 6],
+            "B": [1.0, 6.0],
+            "C": ["bar", "foobarbaz"],
+        },
+        index=["min", "sum"],
+    )
+    # sorted index
+    result = mdf.agg(["min", "sum"])
+    tm.assert_frame_equal(result, expected)
+
+    result = mdf[["C", "B", "A"]].agg(["sum", "min"])
+    # GH40420: the result of .agg should have an index that is sorted
+    # according to the arguments provided to agg.
+    expected = expected[["C", "B", "A"]].reindex(["sum", "min"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_agg_multiple_mixed_raises():
+    # GH 20909
+    mdf = DataFrame(
+        {
+            "A": [1, 2, 3],
+            "B": [1.0, 2.0, 3.0],
+            "C": ["foo", "bar", "baz"],
+            "D": date_range("20130101", periods=3),
+        }
+    )
+
+    # sorted index
+    msg = "does not support reduction"
+    with pytest.raises(TypeError, match=msg):
+        mdf.agg(["min", "sum"])
+
+    with pytest.raises(TypeError, match=msg):
+        mdf[["D", "C", "B", "A"]].agg(["sum", "min"])
+
+
+def test_agg_reduce(axis, float_frame):
+    other_axis = 1 if axis in {0, "index"} else 0
+    name1, name2 = float_frame.axes[other_axis].unique()[:2].sort_values()
+
+    # all reducers
+    expected = pd.concat(
+        [
+            float_frame.mean(axis=axis),
+            float_frame.max(axis=axis),
+            float_frame.sum(axis=axis),
+        ],
+        axis=1,
+    )
+    expected.columns = ["mean", "max", "sum"]
+    expected = expected.T if axis in {0, "index"} else expected
+
+    result = float_frame.agg(["mean", "max", "sum"], axis=axis)
+    tm.assert_frame_equal(result, expected)
+
+    # dict input with scalars
+    func = {name1: "mean", name2: "sum"}
+    result = float_frame.agg(func, axis=axis)
+    expected = Series(
+        [
+            float_frame.loc(other_axis)[name1].mean(),
+            float_frame.loc(other_axis)[name2].sum(),
+        ],
+        index=[name1, name2],
+    )
+    tm.assert_series_equal(result, expected)
+
+    # dict input with lists
+    func = {name1: ["mean"], name2: ["sum"]}
+    result = float_frame.agg(func, axis=axis)
+    expected = DataFrame(
+        {
+            name1: Series([float_frame.loc(other_axis)[name1].mean()], index=["mean"]),
+            name2: Series([float_frame.loc(other_axis)[name2].sum()], index=["sum"]),
+        }
+    )
+    expected = expected.T if axis in {1, "columns"} else expected
+    tm.assert_frame_equal(result, expected)
+
+    # dict input with lists with multiple
+    func = {name1: ["mean", "sum"], name2: ["sum", "max"]}
+    result = float_frame.agg(func, axis=axis)
+    expected = pd.concat(
+        {
+            name1: Series(
+                [
+                    float_frame.loc(other_axis)[name1].mean(),
+                    float_frame.loc(other_axis)[name1].sum(),
+                ],
+                index=["mean", "sum"],
+            ),
+            name2: Series(
+                [
+                    float_frame.loc(other_axis)[name2].sum(),
+                    float_frame.loc(other_axis)[name2].max(),
+                ],
+                index=["sum", "max"],
+            ),
+        },
+        axis=1,
+    )
+    expected = expected.T if axis in {1, "columns"} else expected
+    tm.assert_frame_equal(result, expected)
+
+
+def test_nuiscance_columns():
+    # GH 15015
+    df = DataFrame(
+        {
+            "A": [1, 2, 3],
+            "B": [1.0, 2.0, 3.0],
+            "C": ["foo", "bar", "baz"],
+            "D": date_range("20130101", periods=3),
+        }
+    )
+
+    result = df.agg("min")
+    expected = Series([1, 1.0, "bar", Timestamp("20130101")], index=df.columns)
+    tm.assert_series_equal(result, expected)
+
+    result = df.agg(["min"])
+    expected = DataFrame(
+        [[1, 1.0, "bar", Timestamp("20130101").as_unit("ns")]],
+        index=["min"],
+        columns=df.columns,
+    )
+    tm.assert_frame_equal(result, expected)
+
+    msg = "does not support reduction"
+    with pytest.raises(TypeError, match=msg):
+        df.agg("sum")
+
+    result = df[["A", "B", "C"]].agg("sum")
+    expected = Series([6, 6.0, "foobarbaz"], index=["A", "B", "C"])
+    tm.assert_series_equal(result, expected)
+
+    msg = "does not support reduction"
+    with pytest.raises(TypeError, match=msg):
+        df.agg(["sum"])
+
+
+@pytest.mark.parametrize("how", ["agg", "apply"])
+def test_non_callable_aggregates(how):
+    # GH 16405
+    # 'size' is a property of frame/series
+    # validate that this is working
+    # GH 39116 - expand to apply
+    df = DataFrame(
+        {"A": [None, 2, 3], "B": [1.0, np.nan, 3.0], "C": ["foo", None, "bar"]}
+    )
+
+    # Function aggregate
+    result = getattr(df, how)({"A": "count"})
+    expected = Series({"A": 2})
+
+    tm.assert_series_equal(result, expected)
+
+    # Non-function aggregate
+    result = getattr(df, how)({"A": "size"})
+    expected = Series({"A": 3})
+
+    tm.assert_series_equal(result, expected)
+
+    # Mix function and non-function aggs
+    result1 = getattr(df, how)(["count", "size"])
+    result2 = getattr(df, how)(
+        {"A": ["count", "size"], "B": ["count", "size"], "C": ["count", "size"]}
+    )
+    expected = DataFrame(
+        {
+            "A": {"count": 2, "size": 3},
+            "B": {"count": 2, "size": 3},
+            "C": {"count": 2, "size": 3},
+        }
+    )
+
+    tm.assert_frame_equal(result1, result2, check_like=True)
+    tm.assert_frame_equal(result2, expected, check_like=True)
+
+    # Just functional string arg is same as calling df.arg()
+    result = getattr(df, how)("count")
+    expected = df.count()
+
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("how", ["agg", "apply"])
+def test_size_as_str(how, axis):
+    # GH 39934
+    df = DataFrame(
+        {"A": [None, 2, 3], "B": [1.0, np.nan, 3.0], "C": ["foo", None, "bar"]}
+    )
+    # Just a string attribute arg same as calling df.arg
+    # on the columns
+    result = getattr(df, how)("size", axis=axis)
+    if axis in (0, "index"):
+        expected = Series(df.shape[0], index=df.columns)
+    else:
+        expected = Series(df.shape[1], index=df.index)
+    tm.assert_series_equal(result, expected)
+
+
+def test_agg_listlike_result():
+    # GH-29587 user defined function returning list-likes
+    df = DataFrame({"A": [2, 2, 3], "B": [1.5, np.nan, 1.5], "C": ["foo", None, "bar"]})
+
+    def func(group_col):
+        return list(group_col.dropna().unique())
+
+    result = df.agg(func)
+    expected = Series([[2, 3], [1.5], ["foo", "bar"]], index=["A", "B", "C"])
+    tm.assert_series_equal(result, expected)
+
+    result = df.agg([func])
+    expected = expected.to_frame("func").T
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("axis", [0, 1])
+@pytest.mark.parametrize(
+    "args, kwargs",
+    [
+        ((1, 2, 3), {}),
+        ((8, 7, 15), {}),
+        ((1, 2), {}),
+        ((1,), {"b": 2}),
+        ((), {"a": 1, "b": 2}),
+        ((), {"a": 2, "b": 1}),
+        ((), {"a": 1, "b": 2, "c": 3}),
+    ],
+)
+def test_agg_args_kwargs(axis, args, kwargs):
+    def f(x, a, b, c=3):
+        return x.sum() + (a + b) / c
+
+    df = DataFrame([[1, 2], [3, 4]])
+
+    if axis == 0:
+        expected = Series([5.0, 7.0])
+    else:
+        expected = Series([4.0, 8.0])
+
+    result = df.agg(f, axis, *args, **kwargs)
+
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("num_cols", [2, 3, 5])
+def test_frequency_is_original(num_cols, engine, request):
+    # GH 22150
+    if engine == "numba":
+        mark = pytest.mark.xfail(reason="numba engine only supports numeric indices")
+        request.node.add_marker(mark)
+    index = pd.DatetimeIndex(["1950-06-30", "1952-10-24", "1953-05-29"])
+    original = index.copy()
+    df = DataFrame(1, index=index, columns=range(num_cols))
+    df.apply(lambda x: x, engine=engine)
+    assert index.freq == original.freq
+
+
+def test_apply_datetime_tz_issue(engine, request):
+    # GH 29052
+
+    if engine == "numba":
+        mark = pytest.mark.xfail(
+            reason="numba engine doesn't support non-numeric indexes"
+        )
+        request.node.add_marker(mark)
+
+    timestamps = [
+        Timestamp("2019-03-15 12:34:31.909000+0000", tz="UTC"),
+        Timestamp("2019-03-15 12:34:34.359000+0000", tz="UTC"),
+        Timestamp("2019-03-15 12:34:34.660000+0000", tz="UTC"),
+    ]
+    df = DataFrame(data=[0, 1, 2], index=timestamps)
+    result = df.apply(lambda x: x.name, axis=1, engine=engine)
+    expected = Series(index=timestamps, data=timestamps)
+
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("df", [DataFrame({"A": ["a", None], "B": ["c", "d"]})])
+@pytest.mark.parametrize("method", ["min", "max", "sum"])
+def test_mixed_column_raises(df, method, using_infer_string):
+    # GH 16832
+    if method == "sum":
+        msg = r'can only concatenate str \(not "int"\) to str|does not support'
+    else:
+        msg = "not supported between instances of 'str' and 'float'"
+    if not using_infer_string:
+        with pytest.raises(TypeError, match=msg):
+            getattr(df, method)()
+    else:
+        getattr(df, method)()
+
+
+@pytest.mark.parametrize("col", [1, 1.0, True, "a", np.nan])
+def test_apply_dtype(col):
+    # GH 31466
+    df = DataFrame([[1.0, col]], columns=["a", "b"])
+    result = df.apply(lambda x: x.dtype)
+    expected = df.dtypes
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_mutating(using_array_manager, using_copy_on_write, warn_copy_on_write):
+    # GH#35462 case where applied func pins a new BlockManager to a row
+    df = DataFrame({"a": range(100), "b": range(100, 200)})
+    df_orig = df.copy()
+
+    def func(row):
+        mgr = row._mgr
+        row.loc["a"] += 1
+        assert row._mgr is not mgr
+        return row
+
+    expected = df.copy()
+    expected["a"] += 1
+
+    with tm.assert_cow_warning(warn_copy_on_write):
+        result = df.apply(func, axis=1)
+
+    tm.assert_frame_equal(result, expected)
+    if using_copy_on_write or using_array_manager:
+        # INFO(CoW) With copy on write, mutating a viewing row doesn't mutate the parent
+        # INFO(ArrayManager) With BlockManager, the row is a view and mutated in place,
+        # with ArrayManager the row is not a view, and thus not mutated in place
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        tm.assert_frame_equal(df, result)
+
+
+def test_apply_empty_list_reduce():
+    # GH#35683 get columns correct
+    df = DataFrame([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]], columns=["a", "b"])
+
+    result = df.apply(lambda x: [], result_type="reduce")
+    expected = Series({"a": [], "b": []}, dtype=object)
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_no_suffix_index(engine, request):
+    # GH36189
+    if engine == "numba":
+        mark = pytest.mark.xfail(
+            reason="numba engine doesn't support list-likes/dict-like callables"
+        )
+        request.node.add_marker(mark)
+    pdf = DataFrame([[4, 9]] * 3, columns=["A", "B"])
+    result = pdf.apply(["sum", lambda x: x.sum(), lambda x: x.sum()], engine=engine)
+    expected = DataFrame(
+        {"A": [12, 12, 12], "B": [27, 27, 27]}, index=["sum", "<lambda>", "<lambda>"]
+    )
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_apply_raw_returns_string(engine):
+    # https://github.com/pandas-dev/pandas/issues/35940
+    if engine == "numba":
+        pytest.skip("No object dtype support in numba")
+    df = DataFrame({"A": ["aa", "bbb"]})
+    result = df.apply(lambda x: x[0], engine=engine, axis=1, raw=True)
+    expected = Series(["aa", "bbb"])
+    tm.assert_series_equal(result, expected)
+
+
+def test_aggregation_func_column_order():
+    # GH40420: the result of .agg should have an index that is sorted
+    # according to the arguments provided to agg.
+    df = DataFrame(
+        [
+            (1, 0, 0),
+            (2, 0, 0),
+            (3, 0, 0),
+            (4, 5, 4),
+            (5, 6, 6),
+            (6, 7, 7),
+        ],
+        columns=("att1", "att2", "att3"),
+    )
+
+    def sum_div2(s):
+        return s.sum() / 2
+
+    aggs = ["sum", sum_div2, "count", "min"]
+    result = df.agg(aggs)
+    expected = DataFrame(
+        {
+            "att1": [21.0, 10.5, 6.0, 1.0],
+            "att2": [18.0, 9.0, 6.0, 0.0],
+            "att3": [17.0, 8.5, 6.0, 0.0],
+        },
+        index=["sum", "sum_div2", "count", "min"],
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_apply_getitem_axis_1(engine, request):
+    # GH 13427
+    if engine == "numba":
+        mark = pytest.mark.xfail(
+            reason="numba engine not supporting duplicate index values"
+        )
+        request.node.add_marker(mark)
+    df = DataFrame({"a": [0, 1, 2], "b": [1, 2, 3]})
+    result = df[["a", "a"]].apply(
+        lambda x: x.iloc[0] + x.iloc[1], axis=1, engine=engine
+    )
+    expected = Series([0, 2, 4])
+    tm.assert_series_equal(result, expected)
+
+
+def test_nuisance_depr_passes_through_warnings():
+    # GH 43740
+    # DataFrame.agg with list-likes may emit warnings for both individual
+    # args and for entire columns, but we only want to emit once. We
+    # catch and suppress the warnings for individual args, but need to make
+    # sure if some other warnings were raised, they get passed through to
+    # the user.
+
+    def expected_warning(x):
+        warnings.warn("Hello, World!")
+        return x.sum()
+
+    df = DataFrame({"a": [1, 2, 3]})
+    with tm.assert_produces_warning(UserWarning, match="Hello, World!"):
+        df.agg([expected_warning])
+
+
+def test_apply_type():
+    # GH 46719
+    df = DataFrame(
+        {"col1": [3, "string", float], "col2": [0.25, datetime(2020, 1, 1), np.nan]},
+        index=["a", "b", "c"],
+    )
+
+    # axis=0
+    result = df.apply(type, axis=0)
+    expected = Series({"col1": Series, "col2": Series})
+    tm.assert_series_equal(result, expected)
+
+    # axis=1
+    result = df.apply(type, axis=1)
+    expected = Series({"a": Series, "b": Series, "c": Series})
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_on_empty_dataframe(engine):
+    # GH 39111
+    df = DataFrame({"a": [1, 2], "b": [3, 0]})
+    result = df.head(0).apply(lambda x: max(x["a"], x["b"]), axis=1, engine=engine)
+    expected = Series([], dtype=np.float64)
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_return_list():
+    df = DataFrame({"a": [1, 2], "b": [2, 3]})
+    result = df.apply(lambda x: [x.values])
+    expected = DataFrame({"a": [[1, 2]], "b": [[2, 3]]})
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "test, constant",
+    [
+        ({"a": [1, 2, 3], "b": [1, 1, 1]}, {"a": [1, 2, 3], "b": [1]}),
+        ({"a": [2, 2, 2], "b": [1, 1, 1]}, {"a": [2], "b": [1]}),
+    ],
+)
+def test_unique_agg_type_is_series(test, constant):
+    # GH#22558
+    df1 = DataFrame(test)
+    expected = Series(data=constant, index=["a", "b"], dtype="object")
+    aggregation = {"a": "unique", "b": "unique"}
+
+    result = df1.agg(aggregation)
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_any_apply_keyword_non_zero_axis_regression():
+    # https://github.com/pandas-dev/pandas/issues/48656
+    df = DataFrame({"A": [1, 2, 0], "B": [0, 2, 0], "C": [0, 0, 0]})
+    expected = Series([True, True, False])
+    tm.assert_series_equal(df.any(axis=1), expected)
+
+    result = df.apply("any", axis=1)
+    tm.assert_series_equal(result, expected)
+
+    result = df.apply("any", 1)
+    tm.assert_series_equal(result, expected)
+
+
+def test_agg_mapping_func_deprecated():
+    # GH 53325
+    df = DataFrame({"x": [1, 2, 3]})
+
+    def foo1(x, a=1, c=0):
+        return x + a + c
+
+    def foo2(x, b=2, c=0):
+        return x + b + c
+
+    # single func already takes the vectorized path
+    result = df.agg(foo1, 0, 3, c=4)
+    expected = df + 7
+    tm.assert_frame_equal(result, expected)
+
+    msg = "using .+ in Series.agg cannot aggregate and"
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.agg([foo1, foo2], 0, 3, c=4)
+    expected = DataFrame(
+        [[8, 8], [9, 9], [10, 10]], columns=[["x", "x"], ["foo1", "foo2"]]
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # TODO: the result below is wrong, should be fixed (GH53325)
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.agg({"x": foo1}, 0, 3, c=4)
+    expected = DataFrame([2, 3, 4], columns=["x"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_agg_std():
+    df = DataFrame(np.arange(6).reshape(3, 2), columns=["A", "B"])
+
+    with tm.assert_produces_warning(FutureWarning, match="using DataFrame.std"):
+        result = df.agg(np.std)
+    expected = Series({"A": 2.0, "B": 2.0}, dtype=float)
+    tm.assert_series_equal(result, expected)
+
+    with tm.assert_produces_warning(FutureWarning, match="using Series.std"):
+        result = df.agg([np.std])
+    expected = DataFrame({"A": 2.0, "B": 2.0}, index=["std"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_agg_dist_like_and_nonunique_columns():
+    # GH#51099
+    df = DataFrame(
+        {"A": [None, 2, 3], "B": [1.0, np.nan, 3.0], "C": ["foo", None, "bar"]}
+    )
+    df.columns = ["A", "A", "C"]
+
+    result = df.agg({"A": "count"})
+    expected = df["A"].count()
+    tm.assert_series_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/apply/test_frame_apply_relabeling.py

@@ -0,0 +1,113 @@
+import numpy as np
+import pytest
+
+from pandas.compat.numpy import np_version_gte1p25
+
+import pandas as pd
+import pandas._testing as tm
+
+
+def test_agg_relabel():
+    # GH 26513
+    df = pd.DataFrame({"A": [1, 2, 1, 2], "B": [1, 2, 3, 4], "C": [3, 4, 5, 6]})
+
+    # simplest case with one column, one func
+    result = df.agg(foo=("B", "sum"))
+    expected = pd.DataFrame({"B": [10]}, index=pd.Index(["foo"]))
+    tm.assert_frame_equal(result, expected)
+
+    # test on same column with different methods
+    result = df.agg(foo=("B", "sum"), bar=("B", "min"))
+    expected = pd.DataFrame({"B": [10, 1]}, index=pd.Index(["foo", "bar"]))
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_agg_relabel_multi_columns_multi_methods():
+    # GH 26513, test on multiple columns with multiple methods
+    df = pd.DataFrame({"A": [1, 2, 1, 2], "B": [1, 2, 3, 4], "C": [3, 4, 5, 6]})
+    result = df.agg(
+        foo=("A", "sum"),
+        bar=("B", "mean"),
+        cat=("A", "min"),
+        dat=("B", "max"),
+        f=("A", "max"),
+        g=("C", "min"),
+    )
+    expected = pd.DataFrame(
+        {
+            "A": [6.0, np.nan, 1.0, np.nan, 2.0, np.nan],
+            "B": [np.nan, 2.5, np.nan, 4.0, np.nan, np.nan],
+            "C": [np.nan, np.nan, np.nan, np.nan, np.nan, 3.0],
+        },
+        index=pd.Index(["foo", "bar", "cat", "dat", "f", "g"]),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.xfail(np_version_gte1p25, reason="name of min now equals name of np.min")
+def test_agg_relabel_partial_functions():
+    # GH 26513, test on partial, functools or more complex cases
+    df = pd.DataFrame({"A": [1, 2, 1, 2], "B": [1, 2, 3, 4], "C": [3, 4, 5, 6]})
+    msg = "using Series.[mean|min]"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.agg(foo=("A", np.mean), bar=("A", "mean"), cat=("A", min))
+    expected = pd.DataFrame(
+        {"A": [1.5, 1.5, 1.0]}, index=pd.Index(["foo", "bar", "cat"])
+    )
+    tm.assert_frame_equal(result, expected)
+
+    msg = "using Series.[mean|min|max|sum]"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.agg(
+            foo=("A", min),
+            bar=("A", np.min),
+            cat=("B", max),
+            dat=("C", "min"),
+            f=("B", np.sum),
+            kk=("B", lambda x: min(x)),
+        )
+    expected = pd.DataFrame(
+        {
+            "A": [1.0, 1.0, np.nan, np.nan, np.nan, np.nan],
+            "B": [np.nan, np.nan, 4.0, np.nan, 10.0, 1.0],
+            "C": [np.nan, np.nan, np.nan, 3.0, np.nan, np.nan],
+        },
+        index=pd.Index(["foo", "bar", "cat", "dat", "f", "kk"]),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_agg_namedtuple():
+    # GH 26513
+    df = pd.DataFrame({"A": [0, 1], "B": [1, 2]})
+    result = df.agg(
+        foo=pd.NamedAgg("B", "sum"),
+        bar=pd.NamedAgg("B", "min"),
+        cat=pd.NamedAgg(column="B", aggfunc="count"),
+        fft=pd.NamedAgg("B", aggfunc="max"),
+    )
+
+    expected = pd.DataFrame(
+        {"B": [3, 1, 2, 2]}, index=pd.Index(["foo", "bar", "cat", "fft"])
+    )
+    tm.assert_frame_equal(result, expected)
+
+    result = df.agg(
+        foo=pd.NamedAgg("A", "min"),
+        bar=pd.NamedAgg(column="B", aggfunc="max"),
+        cat=pd.NamedAgg(column="A", aggfunc="max"),
+    )
+    expected = pd.DataFrame(
+        {"A": [0.0, np.nan, 1.0], "B": [np.nan, 2.0, np.nan]},
+        index=pd.Index(["foo", "bar", "cat"]),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_reconstruct_func():
+    # GH 28472, test to ensure reconstruct_func isn't moved;
+    # This method is used by other libraries (e.g. dask)
+    result = pd.core.apply.reconstruct_func("min")
+    expected = (False, "min", None, None)
+    tm.assert_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/apply/test_frame_transform.py

@@ -0,0 +1,264 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+from pandas.tests.apply.common import frame_transform_kernels
+from pandas.tests.frame.common import zip_frames
+
+
+def unpack_obj(obj, klass, axis):
+    """
+    Helper to ensure we have the right type of object for a test parametrized
+    over frame_or_series.
+    """
+    if klass is not DataFrame:
+        obj = obj["A"]
+        if axis != 0:
+            pytest.skip(f"Test is only for DataFrame with axis={axis}")
+    return obj
+
+
+def test_transform_ufunc(axis, float_frame, frame_or_series):
+    # GH 35964
+    obj = unpack_obj(float_frame, frame_or_series, axis)
+
+    with np.errstate(all="ignore"):
+        f_sqrt = np.sqrt(obj)
+
+    # ufunc
+    result = obj.transform(np.sqrt, axis=axis)
+    expected = f_sqrt
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ops, names",
+    [
+        ([np.sqrt], ["sqrt"]),
+        ([np.abs, np.sqrt], ["absolute", "sqrt"]),
+        (np.array([np.sqrt]), ["sqrt"]),
+        (np.array([np.abs, np.sqrt]), ["absolute", "sqrt"]),
+    ],
+)
+def test_transform_listlike(axis, float_frame, ops, names):
+    # GH 35964
+    other_axis = 1 if axis in {0, "index"} else 0
+    with np.errstate(all="ignore"):
+        expected = zip_frames([op(float_frame) for op in ops], axis=other_axis)
+    if axis in {0, "index"}:
+        expected.columns = MultiIndex.from_product([float_frame.columns, names])
+    else:
+        expected.index = MultiIndex.from_product([float_frame.index, names])
+    result = float_frame.transform(ops, axis=axis)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("ops", [[], np.array([])])
+def test_transform_empty_listlike(float_frame, ops, frame_or_series):
+    obj = unpack_obj(float_frame, frame_or_series, 0)
+
+    with pytest.raises(ValueError, match="No transform functions were provided"):
+        obj.transform(ops)
+
+
+def test_transform_listlike_func_with_args():
+    # GH 50624
+    df = DataFrame({"x": [1, 2, 3]})
+
+    def foo1(x, a=1, c=0):
+        return x + a + c
+
+    def foo2(x, b=2, c=0):
+        return x + b + c
+
+    msg = r"foo1\(\) got an unexpected keyword argument 'b'"
+    with pytest.raises(TypeError, match=msg):
+        df.transform([foo1, foo2], 0, 3, b=3, c=4)
+
+    result = df.transform([foo1, foo2], 0, 3, c=4)
+    expected = DataFrame(
+        [[8, 8], [9, 9], [10, 10]],
+        columns=MultiIndex.from_tuples([("x", "foo1"), ("x", "foo2")]),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("box", [dict, Series])
+def test_transform_dictlike(axis, float_frame, box):
+    # GH 35964
+    if axis in (0, "index"):
+        e = float_frame.columns[0]
+        expected = float_frame[[e]].transform(np.abs)
+    else:
+        e = float_frame.index[0]
+        expected = float_frame.iloc[[0]].transform(np.abs)
+    result = float_frame.transform(box({e: np.abs}), axis=axis)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_transform_dictlike_mixed():
+    # GH 40018 - mix of lists and non-lists in values of a dictionary
+    df = DataFrame({"a": [1, 2], "b": [1, 4], "c": [1, 4]})
+    result = df.transform({"b": ["sqrt", "abs"], "c": "sqrt"})
+    expected = DataFrame(
+        [[1.0, 1, 1.0], [2.0, 4, 2.0]],
+        columns=MultiIndex([("b", "c"), ("sqrt", "abs")], [(0, 0, 1), (0, 1, 0)]),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ops",
+    [
+        {},
+        {"A": []},
+        {"A": [], "B": "cumsum"},
+        {"A": "cumsum", "B": []},
+        {"A": [], "B": ["cumsum"]},
+        {"A": ["cumsum"], "B": []},
+    ],
+)
+def test_transform_empty_dictlike(float_frame, ops, frame_or_series):
+    obj = unpack_obj(float_frame, frame_or_series, 0)
+
+    with pytest.raises(ValueError, match="No transform functions were provided"):
+        obj.transform(ops)
+
+
+@pytest.mark.parametrize("use_apply", [True, False])
+def test_transform_udf(axis, float_frame, use_apply, frame_or_series):
+    # GH 35964
+    obj = unpack_obj(float_frame, frame_or_series, axis)
+
+    # transform uses UDF either via apply or passing the entire DataFrame
+    def func(x):
+        # transform is using apply iff x is not a DataFrame
+        if use_apply == isinstance(x, frame_or_series):
+            # Force transform to fallback
+            raise ValueError
+        return x + 1
+
+    result = obj.transform(func, axis=axis)
+    expected = obj + 1
+    tm.assert_equal(result, expected)
+
+
+wont_fail = ["ffill", "bfill", "fillna", "pad", "backfill", "shift"]
+frame_kernels_raise = [x for x in frame_transform_kernels if x not in wont_fail]
+
+
+@pytest.mark.parametrize("op", [*frame_kernels_raise, lambda x: x + 1])
+def test_transform_bad_dtype(op, frame_or_series, request):
+    # GH 35964
+    if op == "ngroup":
+        request.applymarker(
+            pytest.mark.xfail(raises=ValueError, reason="ngroup not valid for NDFrame")
+        )
+
+    obj = DataFrame({"A": 3 * [object]})  # DataFrame that will fail on most transforms
+    obj = tm.get_obj(obj, frame_or_series)
+    error = TypeError
+    msg = "|".join(
+        [
+            "not supported between instances of 'type' and 'type'",
+            "unsupported operand type",
+        ]
+    )
+
+    with pytest.raises(error, match=msg):
+        obj.transform(op)
+    with pytest.raises(error, match=msg):
+        obj.transform([op])
+    with pytest.raises(error, match=msg):
+        obj.transform({"A": op})
+    with pytest.raises(error, match=msg):
+        obj.transform({"A": [op]})
+
+
+@pytest.mark.parametrize("op", frame_kernels_raise)
+def test_transform_failure_typeerror(request, op):
+    # GH 35964
+
+    if op == "ngroup":
+        request.applymarker(
+            pytest.mark.xfail(raises=ValueError, reason="ngroup not valid for NDFrame")
+        )
+
+    # Using object makes most transform kernels fail
+    df = DataFrame({"A": 3 * [object], "B": [1, 2, 3]})
+    error = TypeError
+    msg = "|".join(
+        [
+            "not supported between instances of 'type' and 'type'",
+            "unsupported operand type",
+        ]
+    )
+
+    with pytest.raises(error, match=msg):
+        df.transform([op])
+
+    with pytest.raises(error, match=msg):
+        df.transform({"A": op, "B": op})
+
+    with pytest.raises(error, match=msg):
+        df.transform({"A": [op], "B": [op]})
+
+    with pytest.raises(error, match=msg):
+        df.transform({"A": [op, "shift"], "B": [op]})
+
+
+def test_transform_failure_valueerror():
+    # GH 40211
+    def op(x):
+        if np.sum(np.sum(x)) < 10:
+            raise ValueError
+        return x
+
+    df = DataFrame({"A": [1, 2, 3], "B": [400, 500, 600]})
+    msg = "Transform function failed"
+
+    with pytest.raises(ValueError, match=msg):
+        df.transform([op])
+
+    with pytest.raises(ValueError, match=msg):
+        df.transform({"A": op, "B": op})
+
+    with pytest.raises(ValueError, match=msg):
+        df.transform({"A": [op], "B": [op]})
+
+    with pytest.raises(ValueError, match=msg):
+        df.transform({"A": [op, "shift"], "B": [op]})
+
+
+@pytest.mark.parametrize("use_apply", [True, False])
+def test_transform_passes_args(use_apply, frame_or_series):
+    # GH 35964
+    # transform uses UDF either via apply or passing the entire DataFrame
+    expected_args = [1, 2]
+    expected_kwargs = {"c": 3}
+
+    def f(x, a, b, c):
+        # transform is using apply iff x is not a DataFrame
+        if use_apply == isinstance(x, frame_or_series):
+            # Force transform to fallback
+            raise ValueError
+        assert [a, b] == expected_args
+        assert c == expected_kwargs["c"]
+        return x
+
+    frame_or_series([1]).transform(f, 0, *expected_args, **expected_kwargs)
+
+
+def test_transform_empty_dataframe():
+    # https://github.com/pandas-dev/pandas/issues/39636
+    df = DataFrame([], columns=["col1", "col2"])
+    result = df.transform(lambda x: x + 10)
+    tm.assert_frame_equal(result, df)
+
+    result = df["col1"].transform(lambda x: x + 10)
+    tm.assert_series_equal(result, df["col1"])

env-llmeval/lib/python3.10/site-packages/pandas/tests/apply/test_invalid_arg.py

@@ -0,0 +1,361 @@
+# Tests specifically aimed at detecting bad arguments.
+# This file is organized by reason for exception.
+#     1. always invalid argument values
+#     2. missing column(s)
+#     3. incompatible ops/dtype/args/kwargs
+#     4. invalid result shape/type
+# If your test does not fit into one of these categories, add to this list.
+
+from itertools import chain
+import re
+
+import numpy as np
+import pytest
+
+from pandas.errors import SpecificationError
+
+from pandas import (
+    DataFrame,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize("result_type", ["foo", 1])
+def test_result_type_error(result_type):
+    # allowed result_type
+    df = DataFrame(
+        np.tile(np.arange(3, dtype="int64"), 6).reshape(6, -1) + 1,
+        columns=["A", "B", "C"],
+    )
+
+    msg = (
+        "invalid value for result_type, must be one of "
+        "{None, 'reduce', 'broadcast', 'expand'}"
+    )
+    with pytest.raises(ValueError, match=msg):
+        df.apply(lambda x: [1, 2, 3], axis=1, result_type=result_type)
+
+
+def test_apply_invalid_axis_value():
+    df = DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]], index=["a", "a", "c"])
+    msg = "No axis named 2 for object type DataFrame"
+    with pytest.raises(ValueError, match=msg):
+        df.apply(lambda x: x, 2)
+
+
+def test_agg_raises():
+    # GH 26513
+    df = DataFrame({"A": [0, 1], "B": [1, 2]})
+    msg = "Must provide"
+
+    with pytest.raises(TypeError, match=msg):
+        df.agg()
+
+
+def test_map_with_invalid_na_action_raises():
+    # https://github.com/pandas-dev/pandas/issues/32815
+    s = Series([1, 2, 3])
+    msg = "na_action must either be 'ignore' or None"
+    with pytest.raises(ValueError, match=msg):
+        s.map(lambda x: x, na_action="____")
+
+
+@pytest.mark.parametrize("input_na_action", ["____", True])
+def test_map_arg_is_dict_with_invalid_na_action_raises(input_na_action):
+    # https://github.com/pandas-dev/pandas/issues/46588
+    s = Series([1, 2, 3])
+    msg = f"na_action must either be 'ignore' or None, {input_na_action} was passed"
+    with pytest.raises(ValueError, match=msg):
+        s.map({1: 2}, na_action=input_na_action)
+
+
+@pytest.mark.parametrize("method", ["apply", "agg", "transform"])
+@pytest.mark.parametrize("func", [{"A": {"B": "sum"}}, {"A": {"B": ["sum"]}}])
+def test_nested_renamer(frame_or_series, method, func):
+    # GH 35964
+    obj = frame_or_series({"A": [1]})
+    match = "nested renamer is not supported"
+    with pytest.raises(SpecificationError, match=match):
+        getattr(obj, method)(func)
+
+
+@pytest.mark.parametrize(
+    "renamer",
+    [{"foo": ["min", "max"]}, {"foo": ["min", "max"], "bar": ["sum", "mean"]}],
+)
+def test_series_nested_renamer(renamer):
+    s = Series(range(6), dtype="int64", name="series")
+    msg = "nested renamer is not supported"
+    with pytest.raises(SpecificationError, match=msg):
+        s.agg(renamer)
+
+
+def test_apply_dict_depr():
+    tsdf = DataFrame(
+        np.random.default_rng(2).standard_normal((10, 3)),
+        columns=["A", "B", "C"],
+        index=date_range("1/1/2000", periods=10),
+    )
+    msg = "nested renamer is not supported"
+    with pytest.raises(SpecificationError, match=msg):
+        tsdf.A.agg({"foo": ["sum", "mean"]})
+
+
+@pytest.mark.parametrize("method", ["agg", "transform"])
+def test_dict_nested_renaming_depr(method):
+    df = DataFrame({"A": range(5), "B": 5})
+
+    # nested renaming
+    msg = r"nested renamer is not supported"
+    with pytest.raises(SpecificationError, match=msg):
+        getattr(df, method)({"A": {"foo": "min"}, "B": {"bar": "max"}})
+
+
+@pytest.mark.parametrize("method", ["apply", "agg", "transform"])
+@pytest.mark.parametrize("func", [{"B": "sum"}, {"B": ["sum"]}])
+def test_missing_column(method, func):
+    # GH 40004
+    obj = DataFrame({"A": [1]})
+    match = re.escape("Column(s) ['B'] do not exist")
+    with pytest.raises(KeyError, match=match):
+        getattr(obj, method)(func)
+
+
+def test_transform_mixed_column_name_dtypes():
+    # GH39025
+    df = DataFrame({"a": ["1"]})
+    msg = r"Column\(s\) \[1, 'b'\] do not exist"
+    with pytest.raises(KeyError, match=msg):
+        df.transform({"a": int, 1: str, "b": int})
+
+
+@pytest.mark.parametrize(
+    "how, args", [("pct_change", ()), ("nsmallest", (1, ["a", "b"])), ("tail", 1)]
+)
+def test_apply_str_axis_1_raises(how, args):
+    # GH 39211 - some ops don't support axis=1
+    df = DataFrame({"a": [1, 2], "b": [3, 4]})
+    msg = f"Operation {how} does not support axis=1"
+    with pytest.raises(ValueError, match=msg):
+        df.apply(how, axis=1, args=args)
+
+
+def test_transform_axis_1_raises():
+    # GH 35964
+    msg = "No axis named 1 for object type Series"
+    with pytest.raises(ValueError, match=msg):
+        Series([1]).transform("sum", axis=1)
+
+
+def test_apply_modify_traceback():
+    data = DataFrame(
+        {
+            "A": [
+                "foo",
+                "foo",
+                "foo",
+                "foo",
+                "bar",
+                "bar",
+                "bar",
+                "bar",
+                "foo",
+                "foo",
+                "foo",
+            ],
+            "B": [
+                "one",
+                "one",
+                "one",
+                "two",
+                "one",
+                "one",
+                "one",
+                "two",
+                "two",
+                "two",
+                "one",
+            ],
+            "C": [
+                "dull",
+                "dull",
+                "shiny",
+                "dull",
+                "dull",
+                "shiny",
+                "shiny",
+                "dull",
+                "shiny",
+                "shiny",
+                "shiny",
+            ],
+            "D": np.random.default_rng(2).standard_normal(11),
+            "E": np.random.default_rng(2).standard_normal(11),
+            "F": np.random.default_rng(2).standard_normal(11),
+        }
+    )
+
+    data.loc[4, "C"] = np.nan
+
+    def transform(row):
+        if row["C"].startswith("shin") and row["A"] == "foo":
+            row["D"] = 7
+        return row
+
+    msg = "'float' object has no attribute 'startswith'"
+    with pytest.raises(AttributeError, match=msg):
+        data.apply(transform, axis=1)
+
+
+@pytest.mark.parametrize(
+    "df, func, expected",
+    tm.get_cython_table_params(
+        DataFrame([["a", "b"], ["b", "a"]]), [["cumprod", TypeError]]
+    ),
+)
+def test_agg_cython_table_raises_frame(df, func, expected, axis, using_infer_string):
+    # GH 21224
+    if using_infer_string:
+        import pyarrow as pa
+
+        expected = (expected, pa.lib.ArrowNotImplementedError)
+
+    msg = "can't multiply sequence by non-int of type 'str'|has no kernel"
+    warn = None if isinstance(func, str) else FutureWarning
+    with pytest.raises(expected, match=msg):
+        with tm.assert_produces_warning(warn, match="using DataFrame.cumprod"):
+            df.agg(func, axis=axis)
+
+
+@pytest.mark.parametrize(
+    "series, func, expected",
+    chain(
+        tm.get_cython_table_params(
+            Series("a b c".split()),
+            [
+                ("mean", TypeError),  # mean raises TypeError
+                ("prod", TypeError),
+                ("std", TypeError),
+                ("var", TypeError),
+                ("median", TypeError),
+                ("cumprod", TypeError),
+            ],
+        )
+    ),
+)
+def test_agg_cython_table_raises_series(series, func, expected, using_infer_string):
+    # GH21224
+    msg = r"[Cc]ould not convert|can't multiply sequence by non-int of type"
+    if func == "median" or func is np.nanmedian or func is np.median:
+        msg = r"Cannot convert \['a' 'b' 'c'\] to numeric"
+
+    if using_infer_string:
+        import pyarrow as pa
+
+        expected = (expected, pa.lib.ArrowNotImplementedError)
+
+    msg = msg + "|does not support|has no kernel"
+    warn = None if isinstance(func, str) else FutureWarning
+
+    with pytest.raises(expected, match=msg):
+        # e.g. Series('a b'.split()).cumprod() will raise
+        with tm.assert_produces_warning(warn, match="is currently using Series.*"):
+            series.agg(func)
+
+
+def test_agg_none_to_type():
+    # GH 40543
+    df = DataFrame({"a": [None]})
+    msg = re.escape("int() argument must be a string")
+    with pytest.raises(TypeError, match=msg):
+        df.agg({"a": lambda x: int(x.iloc[0])})
+
+
+def test_transform_none_to_type():
+    # GH#34377
+    df = DataFrame({"a": [None]})
+    msg = "argument must be a"
+    with pytest.raises(TypeError, match=msg):
+        df.transform({"a": lambda x: int(x.iloc[0])})
+
+
+@pytest.mark.parametrize(
+    "func",
+    [
+        lambda x: np.array([1, 2]).reshape(-1, 2),
+        lambda x: [1, 2],
+        lambda x: Series([1, 2]),
+    ],
+)
+def test_apply_broadcast_error(func):
+    df = DataFrame(
+        np.tile(np.arange(3, dtype="int64"), 6).reshape(6, -1) + 1,
+        columns=["A", "B", "C"],
+    )
+
+    # > 1 ndim
+    msg = "too many dims to broadcast|cannot broadcast result"
+    with pytest.raises(ValueError, match=msg):
+        df.apply(func, axis=1, result_type="broadcast")
+
+
+def test_transform_and_agg_err_agg(axis, float_frame):
+    # cannot both transform and agg
+    msg = "cannot combine transform and aggregation operations"
+    with pytest.raises(ValueError, match=msg):
+        with np.errstate(all="ignore"):
+            float_frame.agg(["max", "sqrt"], axis=axis)
+
+
+@pytest.mark.filterwarnings("ignore::FutureWarning")  # GH53325
+@pytest.mark.parametrize(
+    "func, msg",
+    [
+        (["sqrt", "max"], "cannot combine transform and aggregation"),
+        (
+            {"foo": np.sqrt, "bar": "sum"},
+            "cannot perform both aggregation and transformation",
+        ),
+    ],
+)
+def test_transform_and_agg_err_series(string_series, func, msg):
+    # we are trying to transform with an aggregator
+    with pytest.raises(ValueError, match=msg):
+        with np.errstate(all="ignore"):
+            string_series.agg(func)
+
+
+@pytest.mark.parametrize("func", [["max", "min"], ["max", "sqrt"]])
+def test_transform_wont_agg_frame(axis, float_frame, func):
+    # GH 35964
+    # cannot both transform and agg
+    msg = "Function did not transform"
+    with pytest.raises(ValueError, match=msg):
+        float_frame.transform(func, axis=axis)
+
+
+@pytest.mark.parametrize("func", [["min", "max"], ["sqrt", "max"]])
+def test_transform_wont_agg_series(string_series, func):
+    # GH 35964
+    # we are trying to transform with an aggregator
+    msg = "Function did not transform"
+
+    with pytest.raises(ValueError, match=msg):
+        string_series.transform(func)
+
+
+@pytest.mark.parametrize(
+    "op_wrapper", [lambda x: x, lambda x: [x], lambda x: {"A": x}, lambda x: {"A": [x]}]
+)
+def test_transform_reducer_raises(all_reductions, frame_or_series, op_wrapper):
+    # GH 35964
+    op = op_wrapper(all_reductions)
+
+    obj = DataFrame({"A": [1, 2, 3]})
+    obj = tm.get_obj(obj, frame_or_series)
+
+    msg = "Function did not transform"
+    with pytest.raises(ValueError, match=msg):
+        obj.transform(op)

env-llmeval/lib/python3.10/site-packages/pandas/tests/apply/test_numba.py

@@ -0,0 +1,118 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import (
+    DataFrame,
+    Index,
+)
+import pandas._testing as tm
+
+pytestmark = [td.skip_if_no("numba"), pytest.mark.single_cpu]
+
+
+@pytest.fixture(params=[0, 1])
+def apply_axis(request):
+    return request.param
+
+
+def test_numba_vs_python_noop(float_frame, apply_axis):
+    func = lambda x: x
+    result = float_frame.apply(func, engine="numba", axis=apply_axis)
+    expected = float_frame.apply(func, engine="python", axis=apply_axis)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_numba_vs_python_string_index():
+    # GH#56189
+    pytest.importorskip("pyarrow")
+    df = DataFrame(
+        1,
+        index=Index(["a", "b"], dtype="string[pyarrow_numpy]"),
+        columns=Index(["x", "y"], dtype="string[pyarrow_numpy]"),
+    )
+    func = lambda x: x
+    result = df.apply(func, engine="numba", axis=0)
+    expected = df.apply(func, engine="python", axis=0)
+    tm.assert_frame_equal(
+        result, expected, check_column_type=False, check_index_type=False
+    )
+
+
+def test_numba_vs_python_indexing():
+    frame = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": [7.0, 8.0, 9.0]},
+        index=Index(["A", "B", "C"]),
+    )
+    row_func = lambda x: x["c"]
+    result = frame.apply(row_func, engine="numba", axis=1)
+    expected = frame.apply(row_func, engine="python", axis=1)
+    tm.assert_series_equal(result, expected)
+
+    col_func = lambda x: x["A"]
+    result = frame.apply(col_func, engine="numba", axis=0)
+    expected = frame.apply(col_func, engine="python", axis=0)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "reduction",
+    [lambda x: x.mean(), lambda x: x.min(), lambda x: x.max(), lambda x: x.sum()],
+)
+def test_numba_vs_python_reductions(reduction, apply_axis):
+    df = DataFrame(np.ones((4, 4), dtype=np.float64))
+    result = df.apply(reduction, engine="numba", axis=apply_axis)
+    expected = df.apply(reduction, engine="python", axis=apply_axis)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("colnames", [[1, 2, 3], [1.0, 2.0, 3.0]])
+def test_numba_numeric_colnames(colnames):
+    # Check that numeric column names lower properly and can be indxed on
+    df = DataFrame(
+        np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.int64), columns=colnames
+    )
+    first_col = colnames[0]
+    f = lambda x: x[first_col]  # Get the first column
+    result = df.apply(f, engine="numba", axis=1)
+    expected = df.apply(f, engine="python", axis=1)
+    tm.assert_series_equal(result, expected)
+
+
+def test_numba_parallel_unsupported(float_frame):
+    f = lambda x: x
+    with pytest.raises(
+        NotImplementedError,
+        match="Parallel apply is not supported when raw=False and engine='numba'",
+    ):
+        float_frame.apply(f, engine="numba", engine_kwargs={"parallel": True})
+
+
+def test_numba_nonunique_unsupported(apply_axis):
+    f = lambda x: x
+    df = DataFrame({"a": [1, 2]}, index=Index(["a", "a"]))
+    with pytest.raises(
+        NotImplementedError,
+        match="The index/columns must be unique when raw=False and engine='numba'",
+    ):
+        df.apply(f, engine="numba", axis=apply_axis)
+
+
+def test_numba_unsupported_dtypes(apply_axis):
+    f = lambda x: x
+    df = DataFrame({"a": [1, 2], "b": ["a", "b"], "c": [4, 5]})
+    df["c"] = df["c"].astype("double[pyarrow]")
+
+    with pytest.raises(
+        ValueError,
+        match="Column b must have a numeric dtype. Found 'object|string' instead",
+    ):
+        df.apply(f, engine="numba", axis=apply_axis)
+
+    with pytest.raises(
+        ValueError,
+        match="Column c is backed by an extension array, "
+        "which is not supported by the numba engine.",
+    ):
+        df["c"].to_frame().apply(f, engine="numba", axis=apply_axis)

env-llmeval/lib/python3.10/site-packages/pandas/tests/apply/test_series_apply.py

@@ -0,0 +1,701 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    Series,
+    concat,
+    date_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+from pandas.tests.apply.common import series_transform_kernels
+
+
+@pytest.fixture(params=[False, "compat"])
+def by_row(request):
+    return request.param
+
+
+def test_series_map_box_timedelta(by_row):
+    # GH#11349
+    ser = Series(timedelta_range("1 day 1 s", periods=3, freq="h"))
+
+    def f(x):
+        return x.total_seconds() if by_row else x.dt.total_seconds()
+
+    result = ser.apply(f, by_row=by_row)
+
+    expected = ser.map(lambda x: x.total_seconds())
+    tm.assert_series_equal(result, expected)
+
+    expected = Series([86401.0, 90001.0, 93601.0])
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply(datetime_series, by_row):
+    result = datetime_series.apply(np.sqrt, by_row=by_row)
+    with np.errstate(all="ignore"):
+        expected = np.sqrt(datetime_series)
+    tm.assert_series_equal(result, expected)
+
+    # element-wise apply (ufunc)
+    result = datetime_series.apply(np.exp, by_row=by_row)
+    expected = np.exp(datetime_series)
+    tm.assert_series_equal(result, expected)
+
+    # empty series
+    s = Series(dtype=object, name="foo", index=Index([], name="bar"))
+    rs = s.apply(lambda x: x, by_row=by_row)
+    tm.assert_series_equal(s, rs)
+
+    # check all metadata (GH 9322)
+    assert s is not rs
+    assert s.index is rs.index
+    assert s.dtype == rs.dtype
+    assert s.name == rs.name
+
+    # index but no data
+    s = Series(index=[1, 2, 3], dtype=np.float64)
+    rs = s.apply(lambda x: x, by_row=by_row)
+    tm.assert_series_equal(s, rs)
+
+
+def test_apply_map_same_length_inference_bug():
+    s = Series([1, 2])
+
+    def f(x):
+        return (x, x + 1)
+
+    result = s.apply(f, by_row="compat")
+    expected = s.map(f)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("convert_dtype", [True, False])
+def test_apply_convert_dtype_deprecated(convert_dtype):
+    ser = Series(np.random.default_rng(2).standard_normal(10))
+
+    def func(x):
+        return x if x > 0 else np.nan
+
+    with tm.assert_produces_warning(FutureWarning):
+        ser.apply(func, convert_dtype=convert_dtype, by_row="compat")
+
+
+def test_apply_args():
+    s = Series(["foo,bar"])
+
+    result = s.apply(str.split, args=(",",))
+    assert result[0] == ["foo", "bar"]
+    assert isinstance(result[0], list)
+
+
+@pytest.mark.parametrize(
+    "args, kwargs, increment",
+    [((), {}, 0), ((), {"a": 1}, 1), ((2, 3), {}, 32), ((1,), {"c": 2}, 201)],
+)
+def test_agg_args(args, kwargs, increment):
+    # GH 43357
+    def f(x, a=0, b=0, c=0):
+        return x + a + 10 * b + 100 * c
+
+    s = Series([1, 2])
+    msg = (
+        "in Series.agg cannot aggregate and has been deprecated. "
+        "Use Series.transform to keep behavior unchanged."
+    )
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = s.agg(f, 0, *args, **kwargs)
+    expected = s + increment
+    tm.assert_series_equal(result, expected)
+
+
+def test_agg_mapping_func_deprecated():
+    # GH 53325
+    s = Series([1, 2, 3])
+
+    def foo1(x, a=1, c=0):
+        return x + a + c
+
+    def foo2(x, b=2, c=0):
+        return x + b + c
+
+    msg = "using .+ in Series.agg cannot aggregate and"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        s.agg(foo1, 0, 3, c=4)
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        s.agg([foo1, foo2], 0, 3, c=4)
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        s.agg({"a": foo1, "b": foo2}, 0, 3, c=4)
+
+
+def test_series_apply_map_box_timestamps(by_row):
+    # GH#2689, GH#2627
+    ser = Series(date_range("1/1/2000", periods=10))
+
+    def func(x):
+        return (x.hour, x.day, x.month)
+
+    if not by_row:
+        msg = "Series' object has no attribute 'hour'"
+        with pytest.raises(AttributeError, match=msg):
+            ser.apply(func, by_row=by_row)
+        return
+
+    result = ser.apply(func, by_row=by_row)
+    expected = ser.map(func)
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_box_dt64():
+    # ufunc will not be boxed. Same test cases as the test_map_box
+    vals = [pd.Timestamp("2011-01-01"), pd.Timestamp("2011-01-02")]
+    ser = Series(vals, dtype="M8[ns]")
+    assert ser.dtype == "datetime64[ns]"
+    # boxed value must be Timestamp instance
+    res = ser.apply(lambda x: f"{type(x).__name__}_{x.day}_{x.tz}", by_row="compat")
+    exp = Series(["Timestamp_1_None", "Timestamp_2_None"])
+    tm.assert_series_equal(res, exp)
+
+
+def test_apply_box_dt64tz():
+    vals = [
+        pd.Timestamp("2011-01-01", tz="US/Eastern"),
+        pd.Timestamp("2011-01-02", tz="US/Eastern"),
+    ]
+    ser = Series(vals, dtype="M8[ns, US/Eastern]")
+    assert ser.dtype == "datetime64[ns, US/Eastern]"
+    res = ser.apply(lambda x: f"{type(x).__name__}_{x.day}_{x.tz}", by_row="compat")
+    exp = Series(["Timestamp_1_US/Eastern", "Timestamp_2_US/Eastern"])
+    tm.assert_series_equal(res, exp)
+
+
+def test_apply_box_td64():
+    # timedelta
+    vals = [pd.Timedelta("1 days"), pd.Timedelta("2 days")]
+    ser = Series(vals)
+    assert ser.dtype == "timedelta64[ns]"
+    res = ser.apply(lambda x: f"{type(x).__name__}_{x.days}", by_row="compat")
+    exp = Series(["Timedelta_1", "Timedelta_2"])
+    tm.assert_series_equal(res, exp)
+
+
+def test_apply_box_period():
+    # period
+    vals = [pd.Period("2011-01-01", freq="M"), pd.Period("2011-01-02", freq="M")]
+    ser = Series(vals)
+    assert ser.dtype == "Period[M]"
+    res = ser.apply(lambda x: f"{type(x).__name__}_{x.freqstr}", by_row="compat")
+    exp = Series(["Period_M", "Period_M"])
+    tm.assert_series_equal(res, exp)
+
+
+def test_apply_datetimetz(by_row):
+    values = date_range("2011-01-01", "2011-01-02", freq="h").tz_localize("Asia/Tokyo")
+    s = Series(values, name="XX")
+
+    result = s.apply(lambda x: x + pd.offsets.Day(), by_row=by_row)
+    exp_values = date_range("2011-01-02", "2011-01-03", freq="h").tz_localize(
+        "Asia/Tokyo"
+    )
+    exp = Series(exp_values, name="XX")
+    tm.assert_series_equal(result, exp)
+
+    result = s.apply(lambda x: x.hour if by_row else x.dt.hour, by_row=by_row)
+    exp = Series(list(range(24)) + [0], name="XX", dtype="int64" if by_row else "int32")
+    tm.assert_series_equal(result, exp)
+
+    # not vectorized
+    def f(x):
+        return str(x.tz) if by_row else str(x.dt.tz)
+
+    result = s.apply(f, by_row=by_row)
+    if by_row:
+        exp = Series(["Asia/Tokyo"] * 25, name="XX")
+        tm.assert_series_equal(result, exp)
+    else:
+        assert result == "Asia/Tokyo"
+
+
+def test_apply_categorical(by_row, using_infer_string):
+    values = pd.Categorical(list("ABBABCD"), categories=list("DCBA"), ordered=True)
+    ser = Series(values, name="XX", index=list("abcdefg"))
+
+    if not by_row:
+        msg = "Series' object has no attribute 'lower"
+        with pytest.raises(AttributeError, match=msg):
+            ser.apply(lambda x: x.lower(), by_row=by_row)
+        assert ser.apply(lambda x: "A", by_row=by_row) == "A"
+        return
+
+    result = ser.apply(lambda x: x.lower(), by_row=by_row)
+
+    # should be categorical dtype when the number of categories are
+    # the same
+    values = pd.Categorical(list("abbabcd"), categories=list("dcba"), ordered=True)
+    exp = Series(values, name="XX", index=list("abcdefg"))
+    tm.assert_series_equal(result, exp)
+    tm.assert_categorical_equal(result.values, exp.values)
+
+    result = ser.apply(lambda x: "A")
+    exp = Series(["A"] * 7, name="XX", index=list("abcdefg"))
+    tm.assert_series_equal(result, exp)
+    assert result.dtype == object if not using_infer_string else "string[pyarrow_numpy]"
+
+
+@pytest.mark.parametrize("series", [["1-1", "1-1", np.nan], ["1-1", "1-2", np.nan]])
+def test_apply_categorical_with_nan_values(series, by_row):
+    # GH 20714 bug fixed in: GH 24275
+    s = Series(series, dtype="category")
+    if not by_row:
+        msg = "'Series' object has no attribute 'split'"
+        with pytest.raises(AttributeError, match=msg):
+            s.apply(lambda x: x.split("-")[0], by_row=by_row)
+        return
+
+    result = s.apply(lambda x: x.split("-")[0], by_row=by_row)
+    result = result.astype(object)
+    expected = Series(["1", "1", np.nan], dtype="category")
+    expected = expected.astype(object)
+    tm.assert_series_equal(result, expected)
+
+
+def test_apply_empty_integer_series_with_datetime_index(by_row):
+    # GH 21245
+    s = Series([], index=date_range(start="2018-01-01", periods=0), dtype=int)
+    result = s.apply(lambda x: x, by_row=by_row)
+    tm.assert_series_equal(result, s)
+
+
+def test_apply_dataframe_iloc():
+    uintDF = DataFrame(np.uint64([1, 2, 3, 4, 5]), columns=["Numbers"])
+    indexDF = DataFrame([2, 3, 2, 1, 2], columns=["Indices"])
+
+    def retrieve(targetRow, targetDF):
+        val = targetDF["Numbers"].iloc[targetRow]
+        return val
+
+    result = indexDF["Indices"].apply(retrieve, args=(uintDF,))
+    expected = Series([3, 4, 3, 2, 3], name="Indices", dtype="uint64")
+    tm.assert_series_equal(result, expected)
+
+
+def test_transform(string_series, by_row):
+    # transforming functions
+
+    with np.errstate(all="ignore"):
+        f_sqrt = np.sqrt(string_series)
+        f_abs = np.abs(string_series)
+
+        # ufunc
+        result = string_series.apply(np.sqrt, by_row=by_row)
+        expected = f_sqrt.copy()
+        tm.assert_series_equal(result, expected)
+
+        # list-like
+        result = string_series.apply([np.sqrt], by_row=by_row)
+        expected = f_sqrt.to_frame().copy()
+        expected.columns = ["sqrt"]
+        tm.assert_frame_equal(result, expected)
+
+        result = string_series.apply(["sqrt"], by_row=by_row)
+        tm.assert_frame_equal(result, expected)
+
+        # multiple items in list
+        # these are in the order as if we are applying both functions per
+        # series and then concatting
+        expected = concat([f_sqrt, f_abs], axis=1)
+        expected.columns = ["sqrt", "absolute"]
+        result = string_series.apply([np.sqrt, np.abs], by_row=by_row)
+        tm.assert_frame_equal(result, expected)
+
+        # dict, provide renaming
+        expected = concat([f_sqrt, f_abs], axis=1)
+        expected.columns = ["foo", "bar"]
+        expected = expected.unstack().rename("series")
+
+        result = string_series.apply({"foo": np.sqrt, "bar": np.abs}, by_row=by_row)
+        tm.assert_series_equal(result.reindex_like(expected), expected)
+
+
+@pytest.mark.parametrize("op", series_transform_kernels)
+def test_transform_partial_failure(op, request):
+    # GH 35964
+    if op in ("ffill", "bfill", "pad", "backfill", "shift"):
+        request.applymarker(
+            pytest.mark.xfail(reason=f"{op} is successful on any dtype")
+        )
+
+    # Using object makes most transform kernels fail
+    ser = Series(3 * [object])
+
+    if op in ("fillna", "ngroup"):
+        error = ValueError
+        msg = "Transform function failed"
+    else:
+        error = TypeError
+        msg = "|".join(
+            [
+                "not supported between instances of 'type' and 'type'",
+                "unsupported operand type",
+            ]
+        )
+
+    with pytest.raises(error, match=msg):
+        ser.transform([op, "shift"])
+
+    with pytest.raises(error, match=msg):
+        ser.transform({"A": op, "B": "shift"})
+
+    with pytest.raises(error, match=msg):
+        ser.transform({"A": [op], "B": ["shift"]})
+
+    with pytest.raises(error, match=msg):
+        ser.transform({"A": [op, "shift"], "B": [op]})
+
+
+def test_transform_partial_failure_valueerror():
+    # GH 40211
+    def noop(x):
+        return x
+
+    def raising_op(_):
+        raise ValueError
+
+    ser = Series(3 * [object])
+    msg = "Transform function failed"
+
+    with pytest.raises(ValueError, match=msg):
+        ser.transform([noop, raising_op])
+
+    with pytest.raises(ValueError, match=msg):
+        ser.transform({"A": raising_op, "B": noop})
+
+    with pytest.raises(ValueError, match=msg):
+        ser.transform({"A": [raising_op], "B": [noop]})
+
+    with pytest.raises(ValueError, match=msg):
+        ser.transform({"A": [noop, raising_op], "B": [noop]})
+
+
+def test_demo():
+    # demonstration tests
+    s = Series(range(6), dtype="int64", name="series")
+
+    result = s.agg(["min", "max"])
+    expected = Series([0, 5], index=["min", "max"], name="series")
+    tm.assert_series_equal(result, expected)
+
+    result = s.agg({"foo": "min"})
+    expected = Series([0], index=["foo"], name="series")
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("func", [str, lambda x: str(x)])
+def test_apply_map_evaluate_lambdas_the_same(string_series, func, by_row):
+    # test that we are evaluating row-by-row first if by_row="compat"
+    # else vectorized evaluation
+    result = string_series.apply(func, by_row=by_row)
+
+    if by_row:
+        expected = string_series.map(func)
+        tm.assert_series_equal(result, expected)
+    else:
+        assert result == str(string_series)
+
+
+def test_agg_evaluate_lambdas(string_series):
+    # GH53325
+    # in the future, the result will be a Series class.
+
+    with tm.assert_produces_warning(FutureWarning):
+        result = string_series.agg(lambda x: type(x))
+    assert isinstance(result, Series) and len(result) == len(string_series)
+
+    with tm.assert_produces_warning(FutureWarning):
+        result = string_series.agg(type)
+    assert isinstance(result, Series) and len(result) == len(string_series)
+
+
+@pytest.mark.parametrize("op_name", ["agg", "apply"])
+def test_with_nested_series(datetime_series, op_name):
+    # GH 2316
+    # .agg with a reducer and a transform, what to do
+    msg = "cannot aggregate"
+    warning = FutureWarning if op_name == "agg" else None
+    with tm.assert_produces_warning(warning, match=msg):
+        # GH52123
+        result = getattr(datetime_series, op_name)(
+            lambda x: Series([x, x**2], index=["x", "x^2"])
+        )
+    expected = DataFrame({"x": datetime_series, "x^2": datetime_series**2})
+    tm.assert_frame_equal(result, expected)
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = datetime_series.agg(lambda x: Series([x, x**2], index=["x", "x^2"]))
+    tm.assert_frame_equal(result, expected)
+
+
+def test_replicate_describe(string_series):
+    # this also tests a result set that is all scalars
+    expected = string_series.describe()
+    result = string_series.apply(
+        {
+            "count": "count",
+            "mean": "mean",
+            "std": "std",
+            "min": "min",
+            "25%": lambda x: x.quantile(0.25),
+            "50%": "median",
+            "75%": lambda x: x.quantile(0.75),
+            "max": "max",
+        },
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_reduce(string_series):
+    # reductions with named functions
+    result = string_series.agg(["sum", "mean"])
+    expected = Series(
+        [string_series.sum(), string_series.mean()],
+        ["sum", "mean"],
+        name=string_series.name,
+    )
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "how, kwds",
+    [("agg", {}), ("apply", {"by_row": "compat"}), ("apply", {"by_row": False})],
+)
+def test_non_callable_aggregates(how, kwds):
+    # test agg using non-callable series attributes
+    # GH 39116 - expand to apply
+    s = Series([1, 2, None])
+
+    # Calling agg w/ just a string arg same as calling s.arg
+    result = getattr(s, how)("size", **kwds)
+    expected = s.size
+    assert result == expected
+
+    # test when mixed w/ callable reducers
+    result = getattr(s, how)(["size", "count", "mean"], **kwds)
+    expected = Series({"size": 3.0, "count": 2.0, "mean": 1.5})
+    tm.assert_series_equal(result, expected)
+
+    result = getattr(s, how)({"size": "size", "count": "count", "mean": "mean"}, **kwds)
+    tm.assert_series_equal(result, expected)
+
+
+def test_series_apply_no_suffix_index(by_row):
+    # GH36189
+    s = Series([4] * 3)
+    result = s.apply(["sum", lambda x: x.sum(), lambda x: x.sum()], by_row=by_row)
+    expected = Series([12, 12, 12], index=["sum", "<lambda>", "<lambda>"])
+
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "dti,exp",
+    [
+        (
+            Series([1, 2], index=pd.DatetimeIndex([0, 31536000000])),
+            DataFrame(np.repeat([[1, 2]], 2, axis=0), dtype="int64"),
+        ),
+        (
+            Series(
+                np.arange(10, dtype=np.float64),
+                index=date_range("2020-01-01", periods=10),
+                name="ts",
+            ),
+            DataFrame(np.repeat([[1, 2]], 10, axis=0), dtype="int64"),
+        ),
+    ],
+)
+@pytest.mark.parametrize("aware", [True, False])
+def test_apply_series_on_date_time_index_aware_series(dti, exp, aware):
+    # GH 25959
+    # Calling apply on a localized time series should not cause an error
+    if aware:
+        index = dti.tz_localize("UTC").index
+    else:
+        index = dti.index
+    result = Series(index).apply(lambda x: Series([1, 2]))
+    tm.assert_frame_equal(result, exp)
+
+
+@pytest.mark.parametrize(
+    "by_row, expected", [("compat", Series(np.ones(10), dtype="int64")), (False, 1)]
+)
+def test_apply_scalar_on_date_time_index_aware_series(by_row, expected):
+    # GH 25959
+    # Calling apply on a localized time series should not cause an error
+    series = Series(
+        np.arange(10, dtype=np.float64),
+        index=date_range("2020-01-01", periods=10, tz="UTC"),
+    )
+    result = Series(series.index).apply(lambda x: 1, by_row=by_row)
+    tm.assert_equal(result, expected)
+
+
+def test_apply_to_timedelta(by_row):
+    list_of_valid_strings = ["00:00:01", "00:00:02"]
+    a = pd.to_timedelta(list_of_valid_strings)
+    b = Series(list_of_valid_strings).apply(pd.to_timedelta, by_row=by_row)
+    tm.assert_series_equal(Series(a), b)
+
+    list_of_strings = ["00:00:01", np.nan, pd.NaT, pd.NaT]
+
+    a = pd.to_timedelta(list_of_strings)
+    ser = Series(list_of_strings)
+    b = ser.apply(pd.to_timedelta, by_row=by_row)
+    tm.assert_series_equal(Series(a), b)
+
+
+@pytest.mark.parametrize(
+    "ops, names",
+    [
+        ([np.sum], ["sum"]),
+        ([np.sum, np.mean], ["sum", "mean"]),
+        (np.array([np.sum]), ["sum"]),
+        (np.array([np.sum, np.mean]), ["sum", "mean"]),
+    ],
+)
+@pytest.mark.parametrize(
+    "how, kwargs",
+    [["agg", {}], ["apply", {"by_row": "compat"}], ["apply", {"by_row": False}]],
+)
+def test_apply_listlike_reducer(string_series, ops, names, how, kwargs):
+    # GH 39140
+    expected = Series({name: op(string_series) for name, op in zip(names, ops)})
+    expected.name = "series"
+    warn = FutureWarning if how == "agg" else None
+    msg = f"using Series.[{'|'.join(names)}]"
+    with tm.assert_produces_warning(warn, match=msg):
+        result = getattr(string_series, how)(ops, **kwargs)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ops",
+    [
+        {"A": np.sum},
+        {"A": np.sum, "B": np.mean},
+        Series({"A": np.sum}),
+        Series({"A": np.sum, "B": np.mean}),
+    ],
+)
+@pytest.mark.parametrize(
+    "how, kwargs",
+    [["agg", {}], ["apply", {"by_row": "compat"}], ["apply", {"by_row": False}]],
+)
+def test_apply_dictlike_reducer(string_series, ops, how, kwargs, by_row):
+    # GH 39140
+    expected = Series({name: op(string_series) for name, op in ops.items()})
+    expected.name = string_series.name
+    warn = FutureWarning if how == "agg" else None
+    msg = "using Series.[sum|mean]"
+    with tm.assert_produces_warning(warn, match=msg):
+        result = getattr(string_series, how)(ops, **kwargs)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ops, names",
+    [
+        ([np.sqrt], ["sqrt"]),
+        ([np.abs, np.sqrt], ["absolute", "sqrt"]),
+        (np.array([np.sqrt]), ["sqrt"]),
+        (np.array([np.abs, np.sqrt]), ["absolute", "sqrt"]),
+    ],
+)
+def test_apply_listlike_transformer(string_series, ops, names, by_row):
+    # GH 39140
+    with np.errstate(all="ignore"):
+        expected = concat([op(string_series) for op in ops], axis=1)
+        expected.columns = names
+        result = string_series.apply(ops, by_row=by_row)
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ops, expected",
+    [
+        ([lambda x: x], DataFrame({"<lambda>": [1, 2, 3]})),
+        ([lambda x: x.sum()], Series([6], index=["<lambda>"])),
+    ],
+)
+def test_apply_listlike_lambda(ops, expected, by_row):
+    # GH53400
+    ser = Series([1, 2, 3])
+    result = ser.apply(ops, by_row=by_row)
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ops",
+    [
+        {"A": np.sqrt},
+        {"A": np.sqrt, "B": np.exp},
+        Series({"A": np.sqrt}),
+        Series({"A": np.sqrt, "B": np.exp}),
+    ],
+)
+def test_apply_dictlike_transformer(string_series, ops, by_row):
+    # GH 39140
+    with np.errstate(all="ignore"):
+        expected = concat({name: op(string_series) for name, op in ops.items()})
+        expected.name = string_series.name
+        result = string_series.apply(ops, by_row=by_row)
+        tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ops, expected",
+    [
+        (
+            {"a": lambda x: x},
+            Series([1, 2, 3], index=MultiIndex.from_arrays([["a"] * 3, range(3)])),
+        ),
+        ({"a": lambda x: x.sum()}, Series([6], index=["a"])),
+    ],
+)
+def test_apply_dictlike_lambda(ops, by_row, expected):
+    # GH53400
+    ser = Series([1, 2, 3])
+    result = ser.apply(ops, by_row=by_row)
+    tm.assert_equal(result, expected)
+
+
+def test_apply_retains_column_name(by_row):
+    # GH 16380
+    df = DataFrame({"x": range(3)}, Index(range(3), name="x"))
+    result = df.x.apply(lambda x: Series(range(x + 1), Index(range(x + 1), name="y")))
+    expected = DataFrame(
+        [[0.0, np.nan, np.nan], [0.0, 1.0, np.nan], [0.0, 1.0, 2.0]],
+        columns=Index(range(3), name="y"),
+        index=Index(range(3), name="x"),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_apply_type():
+    # GH 46719
+    s = Series([3, "string", float], index=["a", "b", "c"])
+    result = s.apply(type)
+    expected = Series([int, str, type], index=["a", "b", "c"])
+    tm.assert_series_equal(result, expected)
+
+
+def test_series_apply_unpack_nested_data():
+    # GH#55189
+    ser = Series([[1, 2, 3], [4, 5, 6, 7]])
+    result = ser.apply(lambda x: Series(x))
+    expected = DataFrame({0: [1.0, 4.0], 1: [2.0, 5.0], 2: [3.0, 6.0], 3: [np.nan, 7]})
+    tm.assert_frame_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/apply/test_series_apply_relabeling.py

@@ -0,0 +1,39 @@
+import pandas as pd
+import pandas._testing as tm
+
+
+def test_relabel_no_duplicated_method():
+    # this is to test there is no duplicated method used in agg
+    df = pd.DataFrame({"A": [1, 2, 1, 2], "B": [1, 2, 3, 4]})
+
+    result = df["A"].agg(foo="sum")
+    expected = df["A"].agg({"foo": "sum"})
+    tm.assert_series_equal(result, expected)
+
+    result = df["B"].agg(foo="min", bar="max")
+    expected = df["B"].agg({"foo": "min", "bar": "max"})
+    tm.assert_series_equal(result, expected)
+
+    msg = "using Series.[sum|min|max]"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df["B"].agg(foo=sum, bar=min, cat="max")
+    msg = "using Series.[sum|min|max]"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        expected = df["B"].agg({"foo": sum, "bar": min, "cat": "max"})
+    tm.assert_series_equal(result, expected)
+
+
+def test_relabel_duplicated_method():
+    # this is to test with nested renaming, duplicated method can be used
+    # if they are assigned with different new names
+    df = pd.DataFrame({"A": [1, 2, 1, 2], "B": [1, 2, 3, 4]})
+
+    result = df["A"].agg(foo="sum", bar="sum")
+    expected = pd.Series([6, 6], index=["foo", "bar"], name="A")
+    tm.assert_series_equal(result, expected)
+
+    msg = "using Series.min"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df["B"].agg(foo=min, bar="min")
+    expected = pd.Series([1, 1], index=["foo", "bar"], name="B")
+    tm.assert_series_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/apply/test_series_transform.py

@@ -0,0 +1,84 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    Series,
+    concat,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "args, kwargs, increment",
+    [((), {}, 0), ((), {"a": 1}, 1), ((2, 3), {}, 32), ((1,), {"c": 2}, 201)],
+)
+def test_agg_args(args, kwargs, increment):
+    # GH 43357
+    def f(x, a=0, b=0, c=0):
+        return x + a + 10 * b + 100 * c
+
+    s = Series([1, 2])
+    result = s.transform(f, 0, *args, **kwargs)
+    expected = s + increment
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ops, names",
+    [
+        ([np.sqrt], ["sqrt"]),
+        ([np.abs, np.sqrt], ["absolute", "sqrt"]),
+        (np.array([np.sqrt]), ["sqrt"]),
+        (np.array([np.abs, np.sqrt]), ["absolute", "sqrt"]),
+    ],
+)
+def test_transform_listlike(string_series, ops, names):
+    # GH 35964
+    with np.errstate(all="ignore"):
+        expected = concat([op(string_series) for op in ops], axis=1)
+        expected.columns = names
+        result = string_series.transform(ops)
+        tm.assert_frame_equal(result, expected)
+
+
+def test_transform_listlike_func_with_args():
+    # GH 50624
+
+    s = Series([1, 2, 3])
+
+    def foo1(x, a=1, c=0):
+        return x + a + c
+
+    def foo2(x, b=2, c=0):
+        return x + b + c
+
+    msg = r"foo1\(\) got an unexpected keyword argument 'b'"
+    with pytest.raises(TypeError, match=msg):
+        s.transform([foo1, foo2], 0, 3, b=3, c=4)
+
+    result = s.transform([foo1, foo2], 0, 3, c=4)
+    expected = DataFrame({"foo1": [8, 9, 10], "foo2": [8, 9, 10]})
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("box", [dict, Series])
+def test_transform_dictlike(string_series, box):
+    # GH 35964
+    with np.errstate(all="ignore"):
+        expected = concat([np.sqrt(string_series), np.abs(string_series)], axis=1)
+    expected.columns = ["foo", "bar"]
+    result = string_series.transform(box({"foo": np.sqrt, "bar": np.abs}))
+    tm.assert_frame_equal(result, expected)
+
+
+def test_transform_dictlike_mixed():
+    # GH 40018 - mix of lists and non-lists in values of a dictionary
+    df = Series([1, 4])
+    result = df.transform({"b": ["sqrt", "abs"], "c": "sqrt"})
+    expected = DataFrame(
+        [[1.0, 1, 1.0], [2.0, 4, 2.0]],
+        columns=MultiIndex([("b", "c"), ("sqrt", "abs")], [(0, 0, 1), (0, 1, 0)]),
+    )
+    tm.assert_frame_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/apply/test_str.py

@@ -0,0 +1,326 @@
+from itertools import chain
+import operator
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import is_number
+
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+from pandas.tests.apply.common import (
+    frame_transform_kernels,
+    series_transform_kernels,
+)
+
+
+@pytest.mark.parametrize("func", ["sum", "mean", "min", "max", "std"])
+@pytest.mark.parametrize(
+    "args,kwds",
+    [
+        pytest.param([], {}, id="no_args_or_kwds"),
+        pytest.param([1], {}, id="axis_from_args"),
+        pytest.param([], {"axis": 1}, id="axis_from_kwds"),
+        pytest.param([], {"numeric_only": True}, id="optional_kwds"),
+        pytest.param([1, True], {"numeric_only": True}, id="args_and_kwds"),
+    ],
+)
+@pytest.mark.parametrize("how", ["agg", "apply"])
+def test_apply_with_string_funcs(request, float_frame, func, args, kwds, how):
+    if len(args) > 1 and how == "agg":
+        request.applymarker(
+            pytest.mark.xfail(
+                raises=TypeError,
+                reason="agg/apply signature mismatch - agg passes 2nd "
+                "argument to func",
+            )
+        )
+    result = getattr(float_frame, how)(func, *args, **kwds)
+    expected = getattr(float_frame, func)(*args, **kwds)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("arg", ["sum", "mean", "min", "max", "std"])
+def test_with_string_args(datetime_series, arg):
+    result = datetime_series.apply(arg)
+    expected = getattr(datetime_series, arg)()
+    assert result == expected
+
+
+@pytest.mark.parametrize("op", ["mean", "median", "std", "var"])
+@pytest.mark.parametrize("how", ["agg", "apply"])
+def test_apply_np_reducer(op, how):
+    # GH 39116
+    float_frame = DataFrame({"a": [1, 2], "b": [3, 4]})
+    result = getattr(float_frame, how)(op)
+    # pandas ddof defaults to 1, numpy to 0
+    kwargs = {"ddof": 1} if op in ("std", "var") else {}
+    expected = Series(
+        getattr(np, op)(float_frame, axis=0, **kwargs), index=float_frame.columns
+    )
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "op", ["abs", "ceil", "cos", "cumsum", "exp", "log", "sqrt", "square"]
+)
+@pytest.mark.parametrize("how", ["transform", "apply"])
+def test_apply_np_transformer(float_frame, op, how):
+    # GH 39116
+
+    # float_frame will _usually_ have negative values, which will
+    #  trigger the warning here, but let's put one in just to be sure
+    float_frame.iloc[0, 0] = -1.0
+    warn = None
+    if op in ["log", "sqrt"]:
+        warn = RuntimeWarning
+
+    with tm.assert_produces_warning(warn, check_stacklevel=False):
+        # float_frame fixture is defined in conftest.py, so we don't check the
+        # stacklevel as otherwise the test would fail.
+        result = getattr(float_frame, how)(op)
+        expected = getattr(np, op)(float_frame)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "series, func, expected",
+    chain(
+        tm.get_cython_table_params(
+            Series(dtype=np.float64),
+            [
+                ("sum", 0),
+                ("max", np.nan),
+                ("min", np.nan),
+                ("all", True),
+                ("any", False),
+                ("mean", np.nan),
+                ("prod", 1),
+                ("std", np.nan),
+                ("var", np.nan),
+                ("median", np.nan),
+            ],
+        ),
+        tm.get_cython_table_params(
+            Series([np.nan, 1, 2, 3]),
+            [
+                ("sum", 6),
+                ("max", 3),
+                ("min", 1),
+                ("all", True),
+                ("any", True),
+                ("mean", 2),
+                ("prod", 6),
+                ("std", 1),
+                ("var", 1),
+                ("median", 2),
+            ],
+        ),
+        tm.get_cython_table_params(
+            Series("a b c".split()),
+            [
+                ("sum", "abc"),
+                ("max", "c"),
+                ("min", "a"),
+                ("all", True),
+                ("any", True),
+            ],
+        ),
+    ),
+)
+def test_agg_cython_table_series(series, func, expected):
+    # GH21224
+    # test reducing functions in
+    # pandas.core.base.SelectionMixin._cython_table
+    warn = None if isinstance(func, str) else FutureWarning
+    with tm.assert_produces_warning(warn, match="is currently using Series.*"):
+        result = series.agg(func)
+    if is_number(expected):
+        assert np.isclose(result, expected, equal_nan=True)
+    else:
+        assert result == expected
+
+
+@pytest.mark.parametrize(
+    "series, func, expected",
+    chain(
+        tm.get_cython_table_params(
+            Series(dtype=np.float64),
+            [
+                ("cumprod", Series([], dtype=np.float64)),
+                ("cumsum", Series([], dtype=np.float64)),
+            ],
+        ),
+        tm.get_cython_table_params(
+            Series([np.nan, 1, 2, 3]),
+            [
+                ("cumprod", Series([np.nan, 1, 2, 6])),
+                ("cumsum", Series([np.nan, 1, 3, 6])),
+            ],
+        ),
+        tm.get_cython_table_params(
+            Series("a b c".split()), [("cumsum", Series(["a", "ab", "abc"]))]
+        ),
+    ),
+)
+def test_agg_cython_table_transform_series(series, func, expected):
+    # GH21224
+    # test transforming functions in
+    # pandas.core.base.SelectionMixin._cython_table (cumprod, cumsum)
+    warn = None if isinstance(func, str) else FutureWarning
+    with tm.assert_produces_warning(warn, match="is currently using Series.*"):
+        result = series.agg(func)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "df, func, expected",
+    chain(
+        tm.get_cython_table_params(
+            DataFrame(),
+            [
+                ("sum", Series(dtype="float64")),
+                ("max", Series(dtype="float64")),
+                ("min", Series(dtype="float64")),
+                ("all", Series(dtype=bool)),
+                ("any", Series(dtype=bool)),
+                ("mean", Series(dtype="float64")),
+                ("prod", Series(dtype="float64")),
+                ("std", Series(dtype="float64")),
+                ("var", Series(dtype="float64")),
+                ("median", Series(dtype="float64")),
+            ],
+        ),
+        tm.get_cython_table_params(
+            DataFrame([[np.nan, 1], [1, 2]]),
+            [
+                ("sum", Series([1.0, 3])),
+                ("max", Series([1.0, 2])),
+                ("min", Series([1.0, 1])),
+                ("all", Series([True, True])),
+                ("any", Series([True, True])),
+                ("mean", Series([1, 1.5])),
+                ("prod", Series([1.0, 2])),
+                ("std", Series([np.nan, 0.707107])),
+                ("var", Series([np.nan, 0.5])),
+                ("median", Series([1, 1.5])),
+            ],
+        ),
+    ),
+)
+def test_agg_cython_table_frame(df, func, expected, axis):
+    # GH 21224
+    # test reducing functions in
+    # pandas.core.base.SelectionMixin._cython_table
+    warn = None if isinstance(func, str) else FutureWarning
+    with tm.assert_produces_warning(warn, match="is currently using DataFrame.*"):
+        # GH#53425
+        result = df.agg(func, axis=axis)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "df, func, expected",
+    chain(
+        tm.get_cython_table_params(
+            DataFrame(), [("cumprod", DataFrame()), ("cumsum", DataFrame())]
+        ),
+        tm.get_cython_table_params(
+            DataFrame([[np.nan, 1], [1, 2]]),
+            [
+                ("cumprod", DataFrame([[np.nan, 1], [1, 2]])),
+                ("cumsum", DataFrame([[np.nan, 1], [1, 3]])),
+            ],
+        ),
+    ),
+)
+def test_agg_cython_table_transform_frame(df, func, expected, axis):
+    # GH 21224
+    # test transforming functions in
+    # pandas.core.base.SelectionMixin._cython_table (cumprod, cumsum)
+    if axis in ("columns", 1):
+        # operating blockwise doesn't let us preserve dtypes
+        expected = expected.astype("float64")
+
+    warn = None if isinstance(func, str) else FutureWarning
+    with tm.assert_produces_warning(warn, match="is currently using DataFrame.*"):
+        # GH#53425
+        result = df.agg(func, axis=axis)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("op", series_transform_kernels)
+def test_transform_groupby_kernel_series(request, string_series, op):
+    # GH 35964
+    if op == "ngroup":
+        request.applymarker(
+            pytest.mark.xfail(raises=ValueError, reason="ngroup not valid for NDFrame")
+        )
+    args = [0.0] if op == "fillna" else []
+    ones = np.ones(string_series.shape[0])
+
+    warn = FutureWarning if op == "fillna" else None
+    msg = "SeriesGroupBy.fillna is deprecated"
+    with tm.assert_produces_warning(warn, match=msg):
+        expected = string_series.groupby(ones).transform(op, *args)
+    result = string_series.transform(op, 0, *args)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("op", frame_transform_kernels)
+def test_transform_groupby_kernel_frame(request, axis, float_frame, op):
+    if op == "ngroup":
+        request.applymarker(
+            pytest.mark.xfail(raises=ValueError, reason="ngroup not valid for NDFrame")
+        )
+
+    # GH 35964
+
+    args = [0.0] if op == "fillna" else []
+    if axis in (0, "index"):
+        ones = np.ones(float_frame.shape[0])
+        msg = "The 'axis' keyword in DataFrame.groupby is deprecated"
+    else:
+        ones = np.ones(float_frame.shape[1])
+        msg = "DataFrame.groupby with axis=1 is deprecated"
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        gb = float_frame.groupby(ones, axis=axis)
+
+    warn = FutureWarning if op == "fillna" else None
+    op_msg = "DataFrameGroupBy.fillna is deprecated"
+    with tm.assert_produces_warning(warn, match=op_msg):
+        expected = gb.transform(op, *args)
+
+    result = float_frame.transform(op, axis, *args)
+    tm.assert_frame_equal(result, expected)
+
+    # same thing, but ensuring we have multiple blocks
+    assert "E" not in float_frame.columns
+    float_frame["E"] = float_frame["A"].copy()
+    assert len(float_frame._mgr.arrays) > 1
+
+    if axis in (0, "index"):
+        ones = np.ones(float_frame.shape[0])
+    else:
+        ones = np.ones(float_frame.shape[1])
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        gb2 = float_frame.groupby(ones, axis=axis)
+    warn = FutureWarning if op == "fillna" else None
+    op_msg = "DataFrameGroupBy.fillna is deprecated"
+    with tm.assert_produces_warning(warn, match=op_msg):
+        expected2 = gb2.transform(op, *args)
+    result2 = float_frame.transform(op, axis, *args)
+    tm.assert_frame_equal(result2, expected2)
+
+
+@pytest.mark.parametrize("method", ["abs", "shift", "pct_change", "cumsum", "rank"])
+def test_transform_method_name(method):
+    # GH 19760
+    df = DataFrame({"A": [-1, 2]})
+    result = df.transform(method)
+    expected = operator.methodcaller(method)(df)
+    tm.assert_frame_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/extension/array_with_attr/__init__.py

@@ -0,0 +1,6 @@
+from pandas.tests.extension.array_with_attr.array import (
+    FloatAttrArray,
+    FloatAttrDtype,
+)
+
+__all__ = ["FloatAttrArray", "FloatAttrDtype"]

env-llmeval/lib/python3.10/site-packages/pandas/tests/extension/array_with_attr/array.py

@@ -0,0 +1,89 @@
+"""
+Test extension array that has custom attribute information (not stored on the dtype).
+
+"""
+from __future__ import annotations
+
+import numbers
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from pandas.core.dtypes.base import ExtensionDtype
+
+import pandas as pd
+from pandas.core.arrays import ExtensionArray
+
+if TYPE_CHECKING:
+    from pandas._typing import type_t
+
+
+class FloatAttrDtype(ExtensionDtype):
+    type = float
+    name = "float_attr"
+    na_value = np.nan
+
+    @classmethod
+    def construct_array_type(cls) -> type_t[FloatAttrArray]:
+        """
+        Return the array type associated with this dtype.
+
+        Returns
+        -------
+        type
+        """
+        return FloatAttrArray
+
+
+class FloatAttrArray(ExtensionArray):
+    dtype = FloatAttrDtype()
+    __array_priority__ = 1000
+
+    def __init__(self, values, attr=None) -> None:
+        if not isinstance(values, np.ndarray):
+            raise TypeError("Need to pass a numpy array of float64 dtype as values")
+        if not values.dtype == "float64":
+            raise TypeError("Need to pass a numpy array of float64 dtype as values")
+        self.data = values
+        self.attr = attr
+
+    @classmethod
+    def _from_sequence(cls, scalars, *, dtype=None, copy=False):
+        if not copy:
+            data = np.asarray(scalars, dtype="float64")
+        else:
+            data = np.array(scalars, dtype="float64", copy=copy)
+        return cls(data)
+
+    def __getitem__(self, item):
+        if isinstance(item, numbers.Integral):
+            return self.data[item]
+        else:
+            # slice, list-like, mask
+            item = pd.api.indexers.check_array_indexer(self, item)
+            return type(self)(self.data[item], self.attr)
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def isna(self):
+        return np.isnan(self.data)
+
+    def take(self, indexer, allow_fill=False, fill_value=None):
+        from pandas.api.extensions import take
+
+        data = self.data
+        if allow_fill and fill_value is None:
+            fill_value = self.dtype.na_value
+
+        result = take(data, indexer, fill_value=fill_value, allow_fill=allow_fill)
+        return type(self)(result, self.attr)
+
+    def copy(self):
+        return type(self)(self.data.copy(), self.attr)
+
+    @classmethod
+    def _concat_same_type(cls, to_concat):
+        data = np.concatenate([x.data for x in to_concat])
+        attr = to_concat[0].attr if len(to_concat) else None
+        return cls(data, attr)

env-llmeval/lib/python3.10/site-packages/pandas/tests/extension/array_with_attr/test_array_with_attr.py

@@ -0,0 +1,33 @@
+import numpy as np
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.tests.extension.array_with_attr import FloatAttrArray
+
+
+def test_concat_with_all_na():
+    # https://github.com/pandas-dev/pandas/pull/47762
+    # ensure that attribute of the column array is preserved (when it gets
+    # preserved in reindexing the array) during merge/concat
+    arr = FloatAttrArray(np.array([np.nan, np.nan], dtype="float64"), attr="test")
+
+    df1 = pd.DataFrame({"col": arr, "key": [0, 1]})
+    df2 = pd.DataFrame({"key": [0, 1], "col2": [1, 2]})
+    result = pd.merge(df1, df2, on="key")
+    expected = pd.DataFrame({"col": arr, "key": [0, 1], "col2": [1, 2]})
+    tm.assert_frame_equal(result, expected)
+    assert result["col"].array.attr == "test"
+
+    df1 = pd.DataFrame({"col": arr, "key": [0, 1]})
+    df2 = pd.DataFrame({"key": [0, 2], "col2": [1, 2]})
+    result = pd.merge(df1, df2, on="key")
+    expected = pd.DataFrame({"col": arr.take([0]), "key": [0], "col2": [1]})
+    tm.assert_frame_equal(result, expected)
+    assert result["col"].array.attr == "test"
+
+    result = pd.concat([df1.set_index("key"), df2.set_index("key")], axis=1)
+    expected = pd.DataFrame(
+        {"col": arr.take([0, 1, -1]), "col2": [1, np.nan, 2], "key": [0, 1, 2]}
+    ).set_index("key")
+    tm.assert_frame_equal(result, expected)
+    assert result["col"].array.attr == "test"

env-llmeval/lib/python3.10/site-packages/pandas/tests/extension/base/__init__.py

@@ -0,0 +1,131 @@
+"""
+Base test suite for extension arrays.
+
+These tests are intended for third-party libraries to subclass to validate
+that their extension arrays and dtypes satisfy the interface. Moving or
+renaming the tests should not be done lightly.
+
+Libraries are expected to implement a few pytest fixtures to provide data
+for the tests. The fixtures may be located in either
+
+* The same module as your test class.
+* A ``conftest.py`` in the same directory as your test class.
+
+The full list of fixtures may be found in the ``conftest.py`` next to this
+file.
+
+.. code-block:: python
+
+   import pytest
+   from pandas.tests.extension.base import BaseDtypeTests
+
+
+   @pytest.fixture
+   def dtype():
+       return MyDtype()
+
+
+   class TestMyDtype(BaseDtypeTests):
+       pass
+
+
+Your class ``TestDtype`` will inherit all the tests defined on
+``BaseDtypeTests``. pytest's fixture discover will supply your ``dtype``
+wherever the test requires it. You're free to implement additional tests.
+
+"""
+from pandas.tests.extension.base.accumulate import BaseAccumulateTests
+from pandas.tests.extension.base.casting import BaseCastingTests
+from pandas.tests.extension.base.constructors import BaseConstructorsTests
+from pandas.tests.extension.base.dim2 import (  # noqa: F401
+    Dim2CompatTests,
+    NDArrayBacked2DTests,
+)
+from pandas.tests.extension.base.dtype import BaseDtypeTests
+from pandas.tests.extension.base.getitem import BaseGetitemTests
+from pandas.tests.extension.base.groupby import BaseGroupbyTests
+from pandas.tests.extension.base.index import BaseIndexTests
+from pandas.tests.extension.base.interface import BaseInterfaceTests
+from pandas.tests.extension.base.io import BaseParsingTests
+from pandas.tests.extension.base.methods import BaseMethodsTests
+from pandas.tests.extension.base.missing import BaseMissingTests
+from pandas.tests.extension.base.ops import (  # noqa: F401
+    BaseArithmeticOpsTests,
+    BaseComparisonOpsTests,
+    BaseOpsUtil,
+    BaseUnaryOpsTests,
+)
+from pandas.tests.extension.base.printing import BasePrintingTests
+from pandas.tests.extension.base.reduce import BaseReduceTests
+from pandas.tests.extension.base.reshaping import BaseReshapingTests
+from pandas.tests.extension.base.setitem import BaseSetitemTests
+
+
+# One test class that you can inherit as an alternative to inheriting all the
+# test classes above.
+# Note 1) this excludes Dim2CompatTests and NDArrayBacked2DTests.
+# Note 2) this uses BaseReduceTests and and _not_ BaseBooleanReduceTests,
+#  BaseNoReduceTests, or BaseNumericReduceTests
+class ExtensionTests(
+    BaseAccumulateTests,
+    BaseCastingTests,
+    BaseConstructorsTests,
+    BaseDtypeTests,
+    BaseGetitemTests,
+    BaseGroupbyTests,
+    BaseIndexTests,
+    BaseInterfaceTests,
+    BaseParsingTests,
+    BaseMethodsTests,
+    BaseMissingTests,
+    BaseArithmeticOpsTests,
+    BaseComparisonOpsTests,
+    BaseUnaryOpsTests,
+    BasePrintingTests,
+    BaseReduceTests,
+    BaseReshapingTests,
+    BaseSetitemTests,
+    Dim2CompatTests,
+):
+    pass
+
+
+def __getattr__(name: str):
+    import warnings
+
+    if name == "BaseNoReduceTests":
+        warnings.warn(
+            "BaseNoReduceTests is deprecated and will be removed in a "
+            "future version. Use BaseReduceTests and override "
+            "`_supports_reduction` instead.",
+            FutureWarning,
+        )
+        from pandas.tests.extension.base.reduce import BaseNoReduceTests
+
+        return BaseNoReduceTests
+
+    elif name == "BaseNumericReduceTests":
+        warnings.warn(
+            "BaseNumericReduceTests is deprecated and will be removed in a "
+            "future version. Use BaseReduceTests and override "
+            "`_supports_reduction` instead.",
+            FutureWarning,
+        )
+        from pandas.tests.extension.base.reduce import BaseNumericReduceTests
+
+        return BaseNumericReduceTests
+
+    elif name == "BaseBooleanReduceTests":
+        warnings.warn(
+            "BaseBooleanReduceTests is deprecated and will be removed in a "
+            "future version. Use BaseReduceTests and override "
+            "`_supports_reduction` instead.",
+            FutureWarning,
+        )
+        from pandas.tests.extension.base.reduce import BaseBooleanReduceTests
+
+        return BaseBooleanReduceTests
+
+    raise AttributeError(
+        f"module 'pandas.tests.extension.base' has no attribute '{name}'"
+    )