Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/__init__.py

@@ -0,0 +1,7 @@
+"""
+Test files dedicated to individual (stand-alone) Series methods
+
+Ideally these files/tests should correspond 1-to-1 with tests.frame.methods
+
+These may also present opportunities for sharing/de-duplicating test code.
+"""

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_add_prefix_suffix.py

@@ -0,0 +1,41 @@
+import pytest
+
+from pandas import Index
+import pandas._testing as tm
+
+
+def test_add_prefix_suffix(string_series):
+    with_prefix = string_series.add_prefix("foo#")
+    expected = Index([f"foo#{c}" for c in string_series.index])
+    tm.assert_index_equal(with_prefix.index, expected)
+
+    with_suffix = string_series.add_suffix("#foo")
+    expected = Index([f"{c}#foo" for c in string_series.index])
+    tm.assert_index_equal(with_suffix.index, expected)
+
+    with_pct_prefix = string_series.add_prefix("%")
+    expected = Index([f"%{c}" for c in string_series.index])
+    tm.assert_index_equal(with_pct_prefix.index, expected)
+
+    with_pct_suffix = string_series.add_suffix("%")
+    expected = Index([f"{c}%" for c in string_series.index])
+    tm.assert_index_equal(with_pct_suffix.index, expected)
+
+
+def test_add_prefix_suffix_axis(string_series):
+    # GH 47819
+    with_prefix = string_series.add_prefix("foo#", axis=0)
+    expected = Index([f"foo#{c}" for c in string_series.index])
+    tm.assert_index_equal(with_prefix.index, expected)
+
+    with_pct_suffix = string_series.add_suffix("#foo", axis=0)
+    expected = Index([f"{c}#foo" for c in string_series.index])
+    tm.assert_index_equal(with_pct_suffix.index, expected)
+
+
+def test_add_prefix_suffix_invalid_axis(string_series):
+    with pytest.raises(ValueError, match="No axis named 1 for object type Series"):
+        string_series.add_prefix("foo#", axis=1)
+
+    with pytest.raises(ValueError, match="No axis named 1 for object type Series"):
+        string_series.add_suffix("foo#", axis=1)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_align.py

@@ -0,0 +1,249 @@
+from datetime import timezone
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Series,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "first_slice,second_slice",
+    [
+        [[2, None], [None, -5]],
+        [[None, 0], [None, -5]],
+        [[None, -5], [None, 0]],
+        [[None, 0], [None, 0]],
+    ],
+)
+@pytest.mark.parametrize("fill", [None, -1])
+def test_align(datetime_series, first_slice, second_slice, join_type, fill):
+    a = datetime_series[slice(*first_slice)]
+    b = datetime_series[slice(*second_slice)]
+
+    aa, ab = a.align(b, join=join_type, fill_value=fill)
+
+    join_index = a.index.join(b.index, how=join_type)
+    if fill is not None:
+        diff_a = aa.index.difference(join_index)
+        diff_b = ab.index.difference(join_index)
+        if len(diff_a) > 0:
+            assert (aa.reindex(diff_a) == fill).all()
+        if len(diff_b) > 0:
+            assert (ab.reindex(diff_b) == fill).all()
+
+    ea = a.reindex(join_index)
+    eb = b.reindex(join_index)
+
+    if fill is not None:
+        ea = ea.fillna(fill)
+        eb = eb.fillna(fill)
+
+    tm.assert_series_equal(aa, ea)
+    tm.assert_series_equal(ab, eb)
+    assert aa.name == "ts"
+    assert ea.name == "ts"
+    assert ab.name == "ts"
+    assert eb.name == "ts"
+
+
+@pytest.mark.parametrize(
+    "first_slice,second_slice",
+    [
+        [[2, None], [None, -5]],
+        [[None, 0], [None, -5]],
+        [[None, -5], [None, 0]],
+        [[None, 0], [None, 0]],
+    ],
+)
+@pytest.mark.parametrize("method", ["pad", "bfill"])
+@pytest.mark.parametrize("limit", [None, 1])
+def test_align_fill_method(
+    datetime_series, first_slice, second_slice, join_type, method, limit
+):
+    a = datetime_series[slice(*first_slice)]
+    b = datetime_series[slice(*second_slice)]
+
+    msg = (
+        "The 'method', 'limit', and 'fill_axis' keywords in Series.align "
+        "are deprecated"
+    )
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        aa, ab = a.align(b, join=join_type, method=method, limit=limit)
+
+    join_index = a.index.join(b.index, how=join_type)
+    ea = a.reindex(join_index)
+    eb = b.reindex(join_index)
+
+    msg2 = "Series.fillna with 'method' is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg2):
+        ea = ea.fillna(method=method, limit=limit)
+        eb = eb.fillna(method=method, limit=limit)
+
+    tm.assert_series_equal(aa, ea)
+    tm.assert_series_equal(ab, eb)
+
+
+def test_align_nocopy(datetime_series, using_copy_on_write):
+    b = datetime_series[:5].copy()
+
+    # do copy
+    a = datetime_series.copy()
+    ra, _ = a.align(b, join="left")
+    ra[:5] = 5
+    assert not (a[:5] == 5).any()
+
+    # do not copy
+    a = datetime_series.copy()
+    ra, _ = a.align(b, join="left", copy=False)
+    ra[:5] = 5
+    if using_copy_on_write:
+        assert not (a[:5] == 5).any()
+    else:
+        assert (a[:5] == 5).all()
+
+    # do copy
+    a = datetime_series.copy()
+    b = datetime_series[:5].copy()
+    _, rb = a.align(b, join="right")
+    rb[:3] = 5
+    assert not (b[:3] == 5).any()
+
+    # do not copy
+    a = datetime_series.copy()
+    b = datetime_series[:5].copy()
+    _, rb = a.align(b, join="right", copy=False)
+    rb[:2] = 5
+    if using_copy_on_write:
+        assert not (b[:2] == 5).any()
+    else:
+        assert (b[:2] == 5).all()
+
+
+def test_align_same_index(datetime_series, using_copy_on_write):
+    a, b = datetime_series.align(datetime_series, copy=False)
+    if not using_copy_on_write:
+        assert a.index is datetime_series.index
+        assert b.index is datetime_series.index
+    else:
+        assert a.index.is_(datetime_series.index)
+        assert b.index.is_(datetime_series.index)
+
+    a, b = datetime_series.align(datetime_series, copy=True)
+    assert a.index is not datetime_series.index
+    assert b.index is not datetime_series.index
+    assert a.index.is_(datetime_series.index)
+    assert b.index.is_(datetime_series.index)
+
+
+def test_align_multiindex():
+    # GH 10665
+
+    midx = pd.MultiIndex.from_product(
+        [range(2), range(3), range(2)], names=("a", "b", "c")
+    )
+    idx = pd.Index(range(2), name="b")
+    s1 = Series(np.arange(12, dtype="int64"), index=midx)
+    s2 = Series(np.arange(2, dtype="int64"), index=idx)
+
+    # these must be the same results (but flipped)
+    res1l, res1r = s1.align(s2, join="left")
+    res2l, res2r = s2.align(s1, join="right")
+
+    expl = s1
+    tm.assert_series_equal(expl, res1l)
+    tm.assert_series_equal(expl, res2r)
+    expr = Series([0, 0, 1, 1, np.nan, np.nan] * 2, index=midx)
+    tm.assert_series_equal(expr, res1r)
+    tm.assert_series_equal(expr, res2l)
+
+    res1l, res1r = s1.align(s2, join="right")
+    res2l, res2r = s2.align(s1, join="left")
+
+    exp_idx = pd.MultiIndex.from_product(
+        [range(2), range(2), range(2)], names=("a", "b", "c")
+    )
+    expl = Series([0, 1, 2, 3, 6, 7, 8, 9], index=exp_idx)
+    tm.assert_series_equal(expl, res1l)
+    tm.assert_series_equal(expl, res2r)
+    expr = Series([0, 0, 1, 1] * 2, index=exp_idx)
+    tm.assert_series_equal(expr, res1r)
+    tm.assert_series_equal(expr, res2l)
+
+
+@pytest.mark.parametrize("method", ["backfill", "bfill", "pad", "ffill", None])
+def test_align_with_dataframe_method(method):
+    # GH31788
+    ser = Series(range(3), index=range(3))
+    df = pd.DataFrame(0.0, index=range(3), columns=range(3))
+
+    msg = (
+        "The 'method', 'limit', and 'fill_axis' keywords in Series.align "
+        "are deprecated"
+    )
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result_ser, result_df = ser.align(df, method=method)
+    tm.assert_series_equal(result_ser, ser)
+    tm.assert_frame_equal(result_df, df)
+
+
+def test_align_dt64tzindex_mismatched_tzs():
+    idx1 = date_range("2001", periods=5, freq="h", tz="US/Eastern")
+    ser = Series(np.random.default_rng(2).standard_normal(len(idx1)), index=idx1)
+    ser_central = ser.tz_convert("US/Central")
+    # different timezones convert to UTC
+
+    new1, new2 = ser.align(ser_central)
+    assert new1.index.tz is timezone.utc
+    assert new2.index.tz is timezone.utc
+
+
+def test_align_periodindex(join_type):
+    rng = period_range("1/1/2000", "1/1/2010", freq="Y")
+    ts = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
+
+    # TODO: assert something?
+    ts.align(ts[::2], join=join_type)
+
+
+def test_align_left_fewer_levels():
+    # GH#45224
+    left = Series([2], index=pd.MultiIndex.from_tuples([(1, 3)], names=["a", "c"]))
+    right = Series(
+        [1], index=pd.MultiIndex.from_tuples([(1, 2, 3)], names=["a", "b", "c"])
+    )
+    result_left, result_right = left.align(right)
+
+    expected_right = Series(
+        [1], index=pd.MultiIndex.from_tuples([(1, 3, 2)], names=["a", "c", "b"])
+    )
+    expected_left = Series(
+        [2], index=pd.MultiIndex.from_tuples([(1, 3, 2)], names=["a", "c", "b"])
+    )
+    tm.assert_series_equal(result_left, expected_left)
+    tm.assert_series_equal(result_right, expected_right)
+
+
+def test_align_left_different_named_levels():
+    # GH#45224
+    left = Series(
+        [2], index=pd.MultiIndex.from_tuples([(1, 4, 3)], names=["a", "d", "c"])
+    )
+    right = Series(
+        [1], index=pd.MultiIndex.from_tuples([(1, 2, 3)], names=["a", "b", "c"])
+    )
+    result_left, result_right = left.align(right)
+
+    expected_left = Series(
+        [2], index=pd.MultiIndex.from_tuples([(1, 4, 3, 2)], names=["a", "d", "c", "b"])
+    )
+    expected_right = Series(
+        [1], index=pd.MultiIndex.from_tuples([(1, 4, 3, 2)], names=["a", "d", "c", "b"])
+    )
+    tm.assert_series_equal(result_left, expected_left)
+    tm.assert_series_equal(result_right, expected_right)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_argsort.py

@@ -0,0 +1,84 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Series,
+    Timestamp,
+    isna,
+)
+import pandas._testing as tm
+
+
+class TestSeriesArgsort:
+    def test_argsort_axis(self):
+        # GH#54257
+        ser = Series(range(3))
+
+        msg = "No axis named 2 for object type Series"
+        with pytest.raises(ValueError, match=msg):
+            ser.argsort(axis=2)
+
+    def test_argsort_numpy(self, datetime_series):
+        ser = datetime_series
+
+        res = np.argsort(ser).values
+        expected = np.argsort(np.array(ser))
+        tm.assert_numpy_array_equal(res, expected)
+
+        # with missing values
+        ts = ser.copy()
+        ts[::2] = np.nan
+
+        msg = "The behavior of Series.argsort in the presence of NA values"
+        with tm.assert_produces_warning(
+            FutureWarning, match=msg, check_stacklevel=False
+        ):
+            result = np.argsort(ts)[1::2]
+        expected = np.argsort(np.array(ts.dropna()))
+
+        tm.assert_numpy_array_equal(result.values, expected)
+
+    def test_argsort(self, datetime_series):
+        argsorted = datetime_series.argsort()
+        assert issubclass(argsorted.dtype.type, np.integer)
+
+    def test_argsort_dt64(self, unit):
+        # GH#2967 (introduced bug in 0.11-dev I think)
+        ser = Series(
+            [Timestamp(f"201301{i:02d}") for i in range(1, 6)], dtype=f"M8[{unit}]"
+        )
+        assert ser.dtype == f"datetime64[{unit}]"
+        shifted = ser.shift(-1)
+        assert shifted.dtype == f"datetime64[{unit}]"
+        assert isna(shifted[4])
+
+        result = ser.argsort()
+        expected = Series(range(5), dtype=np.intp)
+        tm.assert_series_equal(result, expected)
+
+        msg = "The behavior of Series.argsort in the presence of NA values"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = shifted.argsort()
+        expected = Series(list(range(4)) + [-1], dtype=np.intp)
+        tm.assert_series_equal(result, expected)
+
+    def test_argsort_stable(self):
+        ser = Series(np.random.default_rng(2).integers(0, 100, size=10000))
+        mindexer = ser.argsort(kind="mergesort")
+        qindexer = ser.argsort()
+
+        mexpected = np.argsort(ser.values, kind="mergesort")
+        qexpected = np.argsort(ser.values, kind="quicksort")
+
+        tm.assert_series_equal(mindexer.astype(np.intp), Series(mexpected))
+        tm.assert_series_equal(qindexer.astype(np.intp), Series(qexpected))
+        msg = (
+            r"ndarray Expected type <class 'numpy\.ndarray'>, "
+            r"found <class 'pandas\.core\.series\.Series'> instead"
+        )
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_numpy_array_equal(qindexer, mindexer)
+
+    def test_argsort_preserve_name(self, datetime_series):
+        result = datetime_series.argsort()
+        assert result.name == datetime_series.name

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_asof.py

@@ -0,0 +1,205 @@
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import IncompatibleFrequency
+
+from pandas import (
+    DatetimeIndex,
+    PeriodIndex,
+    Series,
+    Timestamp,
+    date_range,
+    isna,
+    notna,
+    offsets,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestSeriesAsof:
+    def test_asof_nanosecond_index_access(self):
+        ts = Timestamp("20130101").as_unit("ns")._value
+        dti = DatetimeIndex([ts + 50 + i for i in range(100)])
+        ser = Series(np.random.default_rng(2).standard_normal(100), index=dti)
+
+        first_value = ser.asof(ser.index[0])
+
+        # GH#46903 previously incorrectly was "day"
+        assert dti.resolution == "nanosecond"
+
+        # this used to not work bc parsing was done by dateutil that didn't
+        #  handle nanoseconds
+        assert first_value == ser["2013-01-01 00:00:00.000000050"]
+
+        expected_ts = np.datetime64("2013-01-01 00:00:00.000000050", "ns")
+        assert first_value == ser[Timestamp(expected_ts)]
+
+    def test_basic(self):
+        # array or list or dates
+        N = 50
+        rng = date_range("1/1/1990", periods=N, freq="53s")
+        ts = Series(np.random.default_rng(2).standard_normal(N), index=rng)
+        ts.iloc[15:30] = np.nan
+        dates = date_range("1/1/1990", periods=N * 3, freq="25s")
+
+        result = ts.asof(dates)
+        assert notna(result).all()
+        lb = ts.index[14]
+        ub = ts.index[30]
+
+        result = ts.asof(list(dates))
+        assert notna(result).all()
+        lb = ts.index[14]
+        ub = ts.index[30]
+
+        mask = (result.index >= lb) & (result.index < ub)
+        rs = result[mask]
+        assert (rs == ts[lb]).all()
+
+        val = result[result.index[result.index >= ub][0]]
+        assert ts[ub] == val
+
+    def test_scalar(self):
+        N = 30
+        rng = date_range("1/1/1990", periods=N, freq="53s")
+        # Explicit cast to float avoid implicit cast when setting nan
+        ts = Series(np.arange(N), index=rng, dtype="float")
+        ts.iloc[5:10] = np.nan
+        ts.iloc[15:20] = np.nan
+
+        val1 = ts.asof(ts.index[7])
+        val2 = ts.asof(ts.index[19])
+
+        assert val1 == ts.iloc[4]
+        assert val2 == ts.iloc[14]
+
+        # accepts strings
+        val1 = ts.asof(str(ts.index[7]))
+        assert val1 == ts.iloc[4]
+
+        # in there
+        result = ts.asof(ts.index[3])
+        assert result == ts.iloc[3]
+
+        # no as of value
+        d = ts.index[0] - offsets.BDay()
+        assert np.isnan(ts.asof(d))
+
+    def test_with_nan(self):
+        # basic asof test
+        rng = date_range("1/1/2000", "1/2/2000", freq="4h")
+        s = Series(np.arange(len(rng)), index=rng)
+        r = s.resample("2h").mean()
+
+        result = r.asof(r.index)
+        expected = Series(
+            [0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6.0],
+            index=date_range("1/1/2000", "1/2/2000", freq="2h"),
+        )
+        tm.assert_series_equal(result, expected)
+
+        r.iloc[3:5] = np.nan
+        result = r.asof(r.index)
+        expected = Series(
+            [0, 0, 1, 1, 1, 1, 3, 3, 4, 4, 5, 5, 6.0],
+            index=date_range("1/1/2000", "1/2/2000", freq="2h"),
+        )
+        tm.assert_series_equal(result, expected)
+
+        r.iloc[-3:] = np.nan
+        result = r.asof(r.index)
+        expected = Series(
+            [0, 0, 1, 1, 1, 1, 3, 3, 4, 4, 4, 4, 4.0],
+            index=date_range("1/1/2000", "1/2/2000", freq="2h"),
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_periodindex(self):
+        # array or list or dates
+        N = 50
+        rng = period_range("1/1/1990", periods=N, freq="h")
+        ts = Series(np.random.default_rng(2).standard_normal(N), index=rng)
+        ts.iloc[15:30] = np.nan
+        dates = date_range("1/1/1990", periods=N * 3, freq="37min")
+
+        result = ts.asof(dates)
+        assert notna(result).all()
+        lb = ts.index[14]
+        ub = ts.index[30]
+
+        result = ts.asof(list(dates))
+        assert notna(result).all()
+        lb = ts.index[14]
+        ub = ts.index[30]
+
+        pix = PeriodIndex(result.index.values, freq="h")
+        mask = (pix >= lb) & (pix < ub)
+        rs = result[mask]
+        assert (rs == ts[lb]).all()
+
+        ts.iloc[5:10] = np.nan
+        ts.iloc[15:20] = np.nan
+
+        val1 = ts.asof(ts.index[7])
+        val2 = ts.asof(ts.index[19])
+
+        assert val1 == ts.iloc[4]
+        assert val2 == ts.iloc[14]
+
+        # accepts strings
+        val1 = ts.asof(str(ts.index[7]))
+        assert val1 == ts.iloc[4]
+
+        # in there
+        assert ts.asof(ts.index[3]) == ts.iloc[3]
+
+        # no as of value
+        d = ts.index[0].to_timestamp() - offsets.BDay()
+        assert isna(ts.asof(d))
+
+        # Mismatched freq
+        msg = "Input has different freq"
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            ts.asof(rng.asfreq("D"))
+
+    def test_errors(self):
+        s = Series(
+            [1, 2, 3],
+            index=[Timestamp("20130101"), Timestamp("20130103"), Timestamp("20130102")],
+        )
+
+        # non-monotonic
+        assert not s.index.is_monotonic_increasing
+        with pytest.raises(ValueError, match="requires a sorted index"):
+            s.asof(s.index[0])
+
+        # subset with Series
+        N = 10
+        rng = date_range("1/1/1990", periods=N, freq="53s")
+        s = Series(np.random.default_rng(2).standard_normal(N), index=rng)
+        with pytest.raises(ValueError, match="not valid for Series"):
+            s.asof(s.index[0], subset="foo")
+
+    def test_all_nans(self):
+        # GH 15713
+        # series is all nans
+
+        # testing non-default indexes
+        N = 50
+        rng = date_range("1/1/1990", periods=N, freq="53s")
+
+        dates = date_range("1/1/1990", periods=N * 3, freq="25s")
+        result = Series(np.nan, index=rng).asof(dates)
+        expected = Series(np.nan, index=dates)
+        tm.assert_series_equal(result, expected)
+
+        # testing scalar input
+        date = date_range("1/1/1990", periods=N * 3, freq="25s")[0]
+        result = Series(np.nan, index=rng).asof(date)
+        assert isna(result)
+
+        # test name is propagated
+        result = Series(np.nan, index=[1, 2, 3, 4], name="test").asof([4, 5])
+        expected = Series(np.nan, index=[4, 5], name="test")
+        tm.assert_series_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_astype.py

@@ -0,0 +1,683 @@
+from datetime import (
+    datetime,
+    timedelta,
+)
+from importlib import reload
+import string
+import sys
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import iNaT
+import pandas.util._test_decorators as td
+
+from pandas import (
+    NA,
+    Categorical,
+    CategoricalDtype,
+    DatetimeTZDtype,
+    Index,
+    Interval,
+    NaT,
+    Series,
+    Timedelta,
+    Timestamp,
+    cut,
+    date_range,
+    to_datetime,
+)
+import pandas._testing as tm
+
+
+def rand_str(nchars: int) -> str:
+    """
+    Generate one random byte string.
+    """
+    RANDS_CHARS = np.array(
+        list(string.ascii_letters + string.digits), dtype=(np.str_, 1)
+    )
+    return "".join(np.random.default_rng(2).choice(RANDS_CHARS, nchars))
+
+
+class TestAstypeAPI:
+    def test_astype_unitless_dt64_raises(self):
+        # GH#47844
+        ser = Series(["1970-01-01", "1970-01-01", "1970-01-01"], dtype="datetime64[ns]")
+        df = ser.to_frame()
+
+        msg = "Casting to unit-less dtype 'datetime64' is not supported"
+        with pytest.raises(TypeError, match=msg):
+            ser.astype(np.datetime64)
+        with pytest.raises(TypeError, match=msg):
+            df.astype(np.datetime64)
+        with pytest.raises(TypeError, match=msg):
+            ser.astype("datetime64")
+        with pytest.raises(TypeError, match=msg):
+            df.astype("datetime64")
+
+    def test_arg_for_errors_in_astype(self):
+        # see GH#14878
+        ser = Series([1, 2, 3])
+
+        msg = (
+            r"Expected value of kwarg 'errors' to be one of \['raise', "
+            r"'ignore'\]\. Supplied value is 'False'"
+        )
+        with pytest.raises(ValueError, match=msg):
+            ser.astype(np.float64, errors=False)
+
+        ser.astype(np.int8, errors="raise")
+
+    @pytest.mark.parametrize("dtype_class", [dict, Series])
+    def test_astype_dict_like(self, dtype_class):
+        # see GH#7271
+        ser = Series(range(0, 10, 2), name="abc")
+
+        dt1 = dtype_class({"abc": str})
+        result = ser.astype(dt1)
+        expected = Series(["0", "2", "4", "6", "8"], name="abc", dtype=object)
+        tm.assert_series_equal(result, expected)
+
+        dt2 = dtype_class({"abc": "float64"})
+        result = ser.astype(dt2)
+        expected = Series([0.0, 2.0, 4.0, 6.0, 8.0], dtype="float64", name="abc")
+        tm.assert_series_equal(result, expected)
+
+        dt3 = dtype_class({"abc": str, "def": str})
+        msg = (
+            "Only the Series name can be used for the key in Series dtype "
+            r"mappings\."
+        )
+        with pytest.raises(KeyError, match=msg):
+            ser.astype(dt3)
+
+        dt4 = dtype_class({0: str})
+        with pytest.raises(KeyError, match=msg):
+            ser.astype(dt4)
+
+        # GH#16717
+        # if dtypes provided is empty, it should error
+        if dtype_class is Series:
+            dt5 = dtype_class({}, dtype=object)
+        else:
+            dt5 = dtype_class({})
+
+        with pytest.raises(KeyError, match=msg):
+            ser.astype(dt5)
+
+
+class TestAstype:
+    @pytest.mark.parametrize("tz", [None, "UTC", "US/Pacific"])
+    def test_astype_object_to_dt64_non_nano(self, tz):
+        # GH#55756, GH#54620
+        ts = Timestamp("2999-01-01")
+        dtype = "M8[us]"
+        if tz is not None:
+            dtype = f"M8[us, {tz}]"
+        vals = [ts, "2999-01-02 03:04:05.678910", 2500]
+        ser = Series(vals, dtype=object)
+        result = ser.astype(dtype)
+
+        # The 2500 is interpreted as microseconds, consistent with what
+        #  we would get if we created DatetimeIndexes from vals[:2] and vals[2:]
+        #  and concated the results.
+        pointwise = [
+            vals[0].tz_localize(tz),
+            Timestamp(vals[1], tz=tz),
+            to_datetime(vals[2], unit="us", utc=True).tz_convert(tz),
+        ]
+        exp_vals = [x.as_unit("us").asm8 for x in pointwise]
+        exp_arr = np.array(exp_vals, dtype="M8[us]")
+        expected = Series(exp_arr, dtype="M8[us]")
+        if tz is not None:
+            expected = expected.dt.tz_localize("UTC").dt.tz_convert(tz)
+        tm.assert_series_equal(result, expected)
+
+    def test_astype_mixed_object_to_dt64tz(self):
+        # pre-2.0 this raised ValueError bc of tz mismatch
+        # xref GH#32581
+        ts = Timestamp("2016-01-04 05:06:07", tz="US/Pacific")
+        ts2 = ts.tz_convert("Asia/Tokyo")
+
+        ser = Series([ts, ts2], dtype=object)
+        res = ser.astype("datetime64[ns, Europe/Brussels]")
+        expected = Series(
+            [ts.tz_convert("Europe/Brussels"), ts2.tz_convert("Europe/Brussels")],
+            dtype="datetime64[ns, Europe/Brussels]",
+        )
+        tm.assert_series_equal(res, expected)
+
+    @pytest.mark.parametrize("dtype", np.typecodes["All"])
+    def test_astype_empty_constructor_equality(self, dtype):
+        # see GH#15524
+
+        if dtype not in (
+            "S",
+            "V",  # poor support (if any) currently
+            "M",
+            "m",  # Generic timestamps raise a ValueError. Already tested.
+        ):
+            init_empty = Series([], dtype=dtype)
+            as_type_empty = Series([]).astype(dtype)
+            tm.assert_series_equal(init_empty, as_type_empty)
+
+    @pytest.mark.parametrize("dtype", [str, np.str_])
+    @pytest.mark.parametrize(
+        "series",
+        [
+            Series([string.digits * 10, rand_str(63), rand_str(64), rand_str(1000)]),
+            Series([string.digits * 10, rand_str(63), rand_str(64), np.nan, 1.0]),
+        ],
+    )
+    def test_astype_str_map(self, dtype, series, using_infer_string):
+        # see GH#4405
+        result = series.astype(dtype)
+        expected = series.map(str)
+        if using_infer_string:
+            expected = expected.astype(object)
+        tm.assert_series_equal(result, expected)
+
+    def test_astype_float_to_period(self):
+        result = Series([np.nan]).astype("period[D]")
+        expected = Series([NaT], dtype="period[D]")
+        tm.assert_series_equal(result, expected)
+
+    def test_astype_no_pandas_dtype(self):
+        # https://github.com/pandas-dev/pandas/pull/24866
+        ser = Series([1, 2], dtype="int64")
+        # Don't have NumpyEADtype in the public API, so we use `.array.dtype`,
+        # which is a NumpyEADtype.
+        result = ser.astype(ser.array.dtype)
+        tm.assert_series_equal(result, ser)
+
+    @pytest.mark.parametrize("dtype", [np.datetime64, np.timedelta64])
+    def test_astype_generic_timestamp_no_frequency(self, dtype, request):
+        # see GH#15524, GH#15987
+        data = [1]
+        ser = Series(data)
+
+        if np.dtype(dtype).name not in ["timedelta64", "datetime64"]:
+            mark = pytest.mark.xfail(reason="GH#33890 Is assigned ns unit")
+            request.applymarker(mark)
+
+        msg = (
+            rf"The '{dtype.__name__}' dtype has no unit\. "
+            rf"Please pass in '{dtype.__name__}\[ns\]' instead."
+        )
+        with pytest.raises(ValueError, match=msg):
+            ser.astype(dtype)
+
+    def test_astype_dt64_to_str(self):
+        # GH#10442 : testing astype(str) is correct for Series/DatetimeIndex
+        dti = date_range("2012-01-01", periods=3)
+        result = Series(dti).astype(str)
+        expected = Series(["2012-01-01", "2012-01-02", "2012-01-03"], dtype=object)
+        tm.assert_series_equal(result, expected)
+
+    def test_astype_dt64tz_to_str(self):
+        # GH#10442 : testing astype(str) is correct for Series/DatetimeIndex
+        dti_tz = date_range("2012-01-01", periods=3, tz="US/Eastern")
+        result = Series(dti_tz).astype(str)
+        expected = Series(
+            [
+                "2012-01-01 00:00:00-05:00",
+                "2012-01-02 00:00:00-05:00",
+                "2012-01-03 00:00:00-05:00",
+            ],
+            dtype=object,
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_astype_datetime(self, unit):
+        ser = Series(iNaT, dtype=f"M8[{unit}]", index=range(5))
+
+        ser = ser.astype("O")
+        assert ser.dtype == np.object_
+
+        ser = Series([datetime(2001, 1, 2, 0, 0)])
+
+        ser = ser.astype("O")
+        assert ser.dtype == np.object_
+
+        ser = Series(
+            [datetime(2001, 1, 2, 0, 0) for i in range(3)], dtype=f"M8[{unit}]"
+        )
+
+        ser[1] = np.nan
+        assert ser.dtype == f"M8[{unit}]"
+
+        ser = ser.astype("O")
+        assert ser.dtype == np.object_
+
+    def test_astype_datetime64tz(self):
+        ser = Series(date_range("20130101", periods=3, tz="US/Eastern"))
+
+        # astype
+        result = ser.astype(object)
+        expected = Series(ser.astype(object), dtype=object)
+        tm.assert_series_equal(result, expected)
+
+        result = Series(ser.values).dt.tz_localize("UTC").dt.tz_convert(ser.dt.tz)
+        tm.assert_series_equal(result, ser)
+
+        # astype - object, preserves on construction
+        result = Series(ser.astype(object))
+        expected = ser.astype(object)
+        tm.assert_series_equal(result, expected)
+
+        # astype - datetime64[ns, tz]
+        msg = "Cannot use .astype to convert from timezone-naive"
+        with pytest.raises(TypeError, match=msg):
+            # dt64->dt64tz astype deprecated
+            Series(ser.values).astype("datetime64[ns, US/Eastern]")
+
+        with pytest.raises(TypeError, match=msg):
+            # dt64->dt64tz astype deprecated
+            Series(ser.values).astype(ser.dtype)
+
+        result = ser.astype("datetime64[ns, CET]")
+        expected = Series(date_range("20130101 06:00:00", periods=3, tz="CET"))
+        tm.assert_series_equal(result, expected)
+
+    def test_astype_str_cast_dt64(self):
+        # see GH#9757
+        ts = Series([Timestamp("2010-01-04 00:00:00")])
+        res = ts.astype(str)
+
+        expected = Series(["2010-01-04"], dtype=object)
+        tm.assert_series_equal(res, expected)
+
+        ts = Series([Timestamp("2010-01-04 00:00:00", tz="US/Eastern")])
+        res = ts.astype(str)
+
+        expected = Series(["2010-01-04 00:00:00-05:00"], dtype=object)
+        tm.assert_series_equal(res, expected)
+
+    def test_astype_str_cast_td64(self):
+        # see GH#9757
+
+        td = Series([Timedelta(1, unit="d")])
+        ser = td.astype(str)
+
+        expected = Series(["1 days"], dtype=object)
+        tm.assert_series_equal(ser, expected)
+
+    def test_dt64_series_astype_object(self):
+        dt64ser = Series(date_range("20130101", periods=3))
+        result = dt64ser.astype(object)
+        assert isinstance(result.iloc[0], datetime)
+        assert result.dtype == np.object_
+
+    def test_td64_series_astype_object(self):
+        tdser = Series(["59 Days", "59 Days", "NaT"], dtype="timedelta64[ns]")
+        result = tdser.astype(object)
+        assert isinstance(result.iloc[0], timedelta)
+        assert result.dtype == np.object_
+
+    @pytest.mark.parametrize(
+        "data, dtype",
+        [
+            (["x", "y", "z"], "string[python]"),
+            pytest.param(
+                ["x", "y", "z"],
+                "string[pyarrow]",
+                marks=td.skip_if_no("pyarrow"),
+            ),
+            (["x", "y", "z"], "category"),
+            (3 * [Timestamp("2020-01-01", tz="UTC")], None),
+            (3 * [Interval(0, 1)], None),
+        ],
+    )
+    @pytest.mark.parametrize("errors", ["raise", "ignore"])
+    def test_astype_ignores_errors_for_extension_dtypes(self, data, dtype, errors):
+        # https://github.com/pandas-dev/pandas/issues/35471
+        ser = Series(data, dtype=dtype)
+        if errors == "ignore":
+            expected = ser
+            result = ser.astype(float, errors="ignore")
+            tm.assert_series_equal(result, expected)
+        else:
+            msg = "(Cannot cast)|(could not convert)"
+            with pytest.raises((ValueError, TypeError), match=msg):
+                ser.astype(float, errors=errors)
+
+    @pytest.mark.parametrize("dtype", [np.float16, np.float32, np.float64])
+    def test_astype_from_float_to_str(self, dtype):
+        # https://github.com/pandas-dev/pandas/issues/36451
+        ser = Series([0.1], dtype=dtype)
+        result = ser.astype(str)
+        expected = Series(["0.1"], dtype=object)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "value, string_value",
+        [
+            (None, "None"),
+            (np.nan, "nan"),
+            (NA, "<NA>"),
+        ],
+    )
+    def test_astype_to_str_preserves_na(self, value, string_value):
+        # https://github.com/pandas-dev/pandas/issues/36904
+        ser = Series(["a", "b", value], dtype=object)
+        result = ser.astype(str)
+        expected = Series(["a", "b", string_value], dtype=object)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", ["float32", "float64", "int64", "int32"])
+    def test_astype(self, dtype):
+        ser = Series(np.random.default_rng(2).standard_normal(5), name="foo")
+        as_typed = ser.astype(dtype)
+
+        assert as_typed.dtype == dtype
+        assert as_typed.name == ser.name
+
+    @pytest.mark.parametrize("value", [np.nan, np.inf])
+    @pytest.mark.parametrize("dtype", [np.int32, np.int64])
+    def test_astype_cast_nan_inf_int(self, dtype, value):
+        # gh-14265: check NaN and inf raise error when converting to int
+        msg = "Cannot convert non-finite values \\(NA or inf\\) to integer"
+        ser = Series([value])
+
+        with pytest.raises(ValueError, match=msg):
+            ser.astype(dtype)
+
+    @pytest.mark.parametrize("dtype", [int, np.int8, np.int64])
+    def test_astype_cast_object_int_fail(self, dtype):
+        arr = Series(["car", "house", "tree", "1"])
+        msg = r"invalid literal for int\(\) with base 10: 'car'"
+        with pytest.raises(ValueError, match=msg):
+            arr.astype(dtype)
+
+    def test_astype_float_to_uint_negatives_raise(
+        self, float_numpy_dtype, any_unsigned_int_numpy_dtype
+    ):
+        # GH#45151 We don't cast negative numbers to nonsense values
+        # TODO: same for EA float/uint dtypes, signed integers?
+        arr = np.arange(5).astype(float_numpy_dtype) - 3  # includes negatives
+        ser = Series(arr)
+
+        msg = "Cannot losslessly cast from .* to .*"
+        with pytest.raises(ValueError, match=msg):
+            ser.astype(any_unsigned_int_numpy_dtype)
+
+        with pytest.raises(ValueError, match=msg):
+            ser.to_frame().astype(any_unsigned_int_numpy_dtype)
+
+        with pytest.raises(ValueError, match=msg):
+            # We currently catch and re-raise in Index.astype
+            Index(ser).astype(any_unsigned_int_numpy_dtype)
+
+        with pytest.raises(ValueError, match=msg):
+            ser.array.astype(any_unsigned_int_numpy_dtype)
+
+    def test_astype_cast_object_int(self):
+        arr = Series(["1", "2", "3", "4"], dtype=object)
+        result = arr.astype(int)
+
+        tm.assert_series_equal(result, Series(np.arange(1, 5)))
+
+    def test_astype_unicode(self, using_infer_string):
+        # see GH#7758: A bit of magic is required to set
+        # default encoding to utf-8
+        digits = string.digits
+        test_series = [
+            Series([digits * 10, rand_str(63), rand_str(64), rand_str(1000)]),
+            Series(["データーサイエンス、お前はもう死んでいる"]),
+        ]
+
+        former_encoding = None
+
+        if sys.getdefaultencoding() == "utf-8":
+            # GH#45326 as of 2.0 Series.astype matches Index.astype by handling
+            #  bytes with obj.decode() instead of str(obj)
+            item = "野菜食べないとやばい"
+            ser = Series([item.encode()])
+            result = ser.astype(np.str_)
+            expected = Series([item], dtype=object)
+            tm.assert_series_equal(result, expected)
+
+        for ser in test_series:
+            res = ser.astype(np.str_)
+            expec = ser.map(str)
+            if using_infer_string:
+                expec = expec.astype(object)
+            tm.assert_series_equal(res, expec)
+
+        # Restore the former encoding
+        if former_encoding is not None and former_encoding != "utf-8":
+            reload(sys)
+            sys.setdefaultencoding(former_encoding)
+
+    def test_astype_bytes(self):
+        # GH#39474
+        result = Series(["foo", "bar", "baz"]).astype(bytes)
+        assert result.dtypes == np.dtype("S3")
+
+    def test_astype_nan_to_bool(self):
+        # GH#43018
+        ser = Series(np.nan, dtype="object")
+        result = ser.astype("bool")
+        expected = Series(True, dtype="bool")
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype",
+        tm.ALL_INT_EA_DTYPES + tm.FLOAT_EA_DTYPES,
+    )
+    def test_astype_ea_to_datetimetzdtype(self, dtype):
+        # GH37553
+        ser = Series([4, 0, 9], dtype=dtype)
+        result = ser.astype(DatetimeTZDtype(tz="US/Pacific"))
+
+        expected = Series(
+            {
+                0: Timestamp("1969-12-31 16:00:00.000000004-08:00", tz="US/Pacific"),
+                1: Timestamp("1969-12-31 16:00:00.000000000-08:00", tz="US/Pacific"),
+                2: Timestamp("1969-12-31 16:00:00.000000009-08:00", tz="US/Pacific"),
+            }
+        )
+
+        tm.assert_series_equal(result, expected)
+
+    def test_astype_retain_attrs(self, any_numpy_dtype):
+        # GH#44414
+        ser = Series([0, 1, 2, 3])
+        ser.attrs["Location"] = "Michigan"
+
+        result = ser.astype(any_numpy_dtype).attrs
+        expected = ser.attrs
+
+        tm.assert_dict_equal(expected, result)
+
+
+class TestAstypeString:
+    @pytest.mark.parametrize(
+        "data, dtype",
+        [
+            ([True, NA], "boolean"),
+            (["A", NA], "category"),
+            (["2020-10-10", "2020-10-10"], "datetime64[ns]"),
+            (["2020-10-10", "2020-10-10", NaT], "datetime64[ns]"),
+            (
+                ["2012-01-01 00:00:00-05:00", NaT],
+                "datetime64[ns, US/Eastern]",
+            ),
+            ([1, None], "UInt16"),
+            (["1/1/2021", "2/1/2021"], "period[M]"),
+            (["1/1/2021", "2/1/2021", NaT], "period[M]"),
+            (["1 Day", "59 Days", NaT], "timedelta64[ns]"),
+            # currently no way to parse IntervalArray from a list of strings
+        ],
+    )
+    def test_astype_string_to_extension_dtype_roundtrip(
+        self, data, dtype, request, nullable_string_dtype
+    ):
+        if dtype == "boolean":
+            mark = pytest.mark.xfail(
+                reason="TODO StringArray.astype() with missing values #GH40566"
+            )
+            request.applymarker(mark)
+        # GH-40351
+        ser = Series(data, dtype=dtype)
+
+        # Note: just passing .astype(dtype) fails for dtype="category"
+        #  with bc ser.dtype.categories will be object dtype whereas
+        #  result.dtype.categories will have string dtype
+        result = ser.astype(nullable_string_dtype).astype(ser.dtype)
+        tm.assert_series_equal(result, ser)
+
+
+class TestAstypeCategorical:
+    def test_astype_categorical_to_other(self):
+        cat = Categorical([f"{i} - {i + 499}" for i in range(0, 10000, 500)])
+        ser = Series(np.random.default_rng(2).integers(0, 10000, 100)).sort_values()
+        ser = cut(ser, range(0, 10500, 500), right=False, labels=cat)
+
+        expected = ser
+        tm.assert_series_equal(ser.astype("category"), expected)
+        tm.assert_series_equal(ser.astype(CategoricalDtype()), expected)
+        msg = r"Cannot cast object|string dtype to float64"
+        with pytest.raises(ValueError, match=msg):
+            ser.astype("float64")
+
+        cat = Series(Categorical(["a", "b", "b", "a", "a", "c", "c", "c"]))
+        exp = Series(["a", "b", "b", "a", "a", "c", "c", "c"], dtype=object)
+        tm.assert_series_equal(cat.astype("str"), exp)
+        s2 = Series(Categorical(["1", "2", "3", "4"]))
+        exp2 = Series([1, 2, 3, 4]).astype("int")
+        tm.assert_series_equal(s2.astype("int"), exp2)
+
+        # object don't sort correctly, so just compare that we have the same
+        # values
+        def cmp(a, b):
+            tm.assert_almost_equal(np.sort(np.unique(a)), np.sort(np.unique(b)))
+
+        expected = Series(np.array(ser.values), name="value_group")
+        cmp(ser.astype("object"), expected)
+        cmp(ser.astype(np.object_), expected)
+
+        # array conversion
+        tm.assert_almost_equal(np.array(ser), np.array(ser.values))
+
+        tm.assert_series_equal(ser.astype("category"), ser)
+        tm.assert_series_equal(ser.astype(CategoricalDtype()), ser)
+
+        roundtrip_expected = ser.cat.set_categories(
+            ser.cat.categories.sort_values()
+        ).cat.remove_unused_categories()
+        result = ser.astype("object").astype("category")
+        tm.assert_series_equal(result, roundtrip_expected)
+        result = ser.astype("object").astype(CategoricalDtype())
+        tm.assert_series_equal(result, roundtrip_expected)
+
+    def test_astype_categorical_invalid_conversions(self):
+        # invalid conversion (these are NOT a dtype)
+        cat = Categorical([f"{i} - {i + 499}" for i in range(0, 10000, 500)])
+        ser = Series(np.random.default_rng(2).integers(0, 10000, 100)).sort_values()
+        ser = cut(ser, range(0, 10500, 500), right=False, labels=cat)
+
+        msg = (
+            "dtype '<class 'pandas.core.arrays.categorical.Categorical'>' "
+            "not understood"
+        )
+        with pytest.raises(TypeError, match=msg):
+            ser.astype(Categorical)
+        with pytest.raises(TypeError, match=msg):
+            ser.astype("object").astype(Categorical)
+
+    def test_astype_categoricaldtype(self):
+        ser = Series(["a", "b", "a"])
+        result = ser.astype(CategoricalDtype(["a", "b"], ordered=True))
+        expected = Series(Categorical(["a", "b", "a"], ordered=True))
+        tm.assert_series_equal(result, expected)
+
+        result = ser.astype(CategoricalDtype(["a", "b"], ordered=False))
+        expected = Series(Categorical(["a", "b", "a"], ordered=False))
+        tm.assert_series_equal(result, expected)
+
+        result = ser.astype(CategoricalDtype(["a", "b", "c"], ordered=False))
+        expected = Series(
+            Categorical(["a", "b", "a"], categories=["a", "b", "c"], ordered=False)
+        )
+        tm.assert_series_equal(result, expected)
+        tm.assert_index_equal(result.cat.categories, Index(["a", "b", "c"]))
+
+    @pytest.mark.parametrize("name", [None, "foo"])
+    @pytest.mark.parametrize("dtype_ordered", [True, False])
+    @pytest.mark.parametrize("series_ordered", [True, False])
+    def test_astype_categorical_to_categorical(
+        self, name, dtype_ordered, series_ordered
+    ):
+        # GH#10696, GH#18593
+        s_data = list("abcaacbab")
+        s_dtype = CategoricalDtype(list("bac"), ordered=series_ordered)
+        ser = Series(s_data, dtype=s_dtype, name=name)
+
+        # unspecified categories
+        dtype = CategoricalDtype(ordered=dtype_ordered)
+        result = ser.astype(dtype)
+        exp_dtype = CategoricalDtype(s_dtype.categories, dtype_ordered)
+        expected = Series(s_data, name=name, dtype=exp_dtype)
+        tm.assert_series_equal(result, expected)
+
+        # different categories
+        dtype = CategoricalDtype(list("adc"), dtype_ordered)
+        result = ser.astype(dtype)
+        expected = Series(s_data, name=name, dtype=dtype)
+        tm.assert_series_equal(result, expected)
+
+        if dtype_ordered is False:
+            # not specifying ordered, so only test once
+            expected = ser
+            result = ser.astype("category")
+            tm.assert_series_equal(result, expected)
+
+    def test_astype_bool_missing_to_categorical(self):
+        # GH-19182
+        ser = Series([True, False, np.nan])
+        assert ser.dtypes == np.object_
+
+        result = ser.astype(CategoricalDtype(categories=[True, False]))
+        expected = Series(Categorical([True, False, np.nan], categories=[True, False]))
+        tm.assert_series_equal(result, expected)
+
+    def test_astype_categories_raises(self):
+        # deprecated GH#17636, removed in GH#27141
+        ser = Series(["a", "b", "a"])
+        with pytest.raises(TypeError, match="got an unexpected"):
+            ser.astype("category", categories=["a", "b"], ordered=True)
+
+    @pytest.mark.parametrize("items", [["a", "b", "c", "a"], [1, 2, 3, 1]])
+    def test_astype_from_categorical(self, items):
+        ser = Series(items)
+        exp = Series(Categorical(items))
+        res = ser.astype("category")
+        tm.assert_series_equal(res, exp)
+
+    def test_astype_from_categorical_with_keywords(self):
+        # with keywords
+        lst = ["a", "b", "c", "a"]
+        ser = Series(lst)
+        exp = Series(Categorical(lst, ordered=True))
+        res = ser.astype(CategoricalDtype(None, ordered=True))
+        tm.assert_series_equal(res, exp)
+
+        exp = Series(Categorical(lst, categories=list("abcdef"), ordered=True))
+        res = ser.astype(CategoricalDtype(list("abcdef"), ordered=True))
+        tm.assert_series_equal(res, exp)
+
+    def test_astype_timedelta64_with_np_nan(self):
+        # GH45798
+        result = Series([Timedelta(1), np.nan], dtype="timedelta64[ns]")
+        expected = Series([Timedelta(1), NaT], dtype="timedelta64[ns]")
+        tm.assert_series_equal(result, expected)
+
+    @td.skip_if_no("pyarrow")
+    def test_astype_int_na_string(self):
+        # GH#57418
+        ser = Series([12, NA], dtype="Int64[pyarrow]")
+        result = ser.astype("string[pyarrow]")
+        expected = Series(["12", NA], dtype="string[pyarrow]")
+        tm.assert_series_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_autocorr.py

@@ -0,0 +1,30 @@
+import numpy as np
+
+
+class TestAutoCorr:
+    def test_autocorr(self, datetime_series):
+        # Just run the function
+        corr1 = datetime_series.autocorr()
+
+        # Now run it with the lag parameter
+        corr2 = datetime_series.autocorr(lag=1)
+
+        # corr() with lag needs Series of at least length 2
+        if len(datetime_series) <= 2:
+            assert np.isnan(corr1)
+            assert np.isnan(corr2)
+        else:
+            assert corr1 == corr2
+
+        # Choose a random lag between 1 and length of Series - 2
+        # and compare the result with the Series corr() function
+        n = 1 + np.random.default_rng(2).integers(max(1, len(datetime_series) - 2))
+        corr1 = datetime_series.corr(datetime_series.shift(n))
+        corr2 = datetime_series.autocorr(lag=n)
+
+        # corr() with lag needs Series of at least length 2
+        if len(datetime_series) <= 2:
+            assert np.isnan(corr1)
+            assert np.isnan(corr2)
+        else:
+            assert corr1 == corr2

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_between.py

@@ -0,0 +1,75 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Series,
+    bdate_range,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestBetween:
+    def test_between(self):
+        series = Series(date_range("1/1/2000", periods=10))
+        left, right = series[[2, 7]]
+
+        result = series.between(left, right)
+        expected = (series >= left) & (series <= right)
+        tm.assert_series_equal(result, expected)
+
+    def test_between_datetime_object_dtype(self):
+        ser = Series(bdate_range("1/1/2000", periods=20), dtype=object)
+        ser[::2] = np.nan
+
+        result = ser[ser.between(ser[3], ser[17])]
+        expected = ser[3:18].dropna()
+        tm.assert_series_equal(result, expected)
+
+        result = ser[ser.between(ser[3], ser[17], inclusive="neither")]
+        expected = ser[5:16].dropna()
+        tm.assert_series_equal(result, expected)
+
+    def test_between_period_values(self):
+        ser = Series(period_range("2000-01-01", periods=10, freq="D"))
+        left, right = ser[[2, 7]]
+        result = ser.between(left, right)
+        expected = (ser >= left) & (ser <= right)
+        tm.assert_series_equal(result, expected)
+
+    def test_between_inclusive_string(self):
+        # GH 40628
+        series = Series(date_range("1/1/2000", periods=10))
+        left, right = series[[2, 7]]
+
+        result = series.between(left, right, inclusive="both")
+        expected = (series >= left) & (series <= right)
+        tm.assert_series_equal(result, expected)
+
+        result = series.between(left, right, inclusive="left")
+        expected = (series >= left) & (series < right)
+        tm.assert_series_equal(result, expected)
+
+        result = series.between(left, right, inclusive="right")
+        expected = (series > left) & (series <= right)
+        tm.assert_series_equal(result, expected)
+
+        result = series.between(left, right, inclusive="neither")
+        expected = (series > left) & (series < right)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("inclusive", ["yes", True, False])
+    def test_between_error_args(self, inclusive):
+        # GH 40628
+        series = Series(date_range("1/1/2000", periods=10))
+        left, right = series[[2, 7]]
+
+        value_error_msg = (
+            "Inclusive has to be either string of 'both',"
+            "'left', 'right', or 'neither'."
+        )
+
+        with pytest.raises(ValueError, match=value_error_msg):
+            series = Series(date_range("1/1/2000", periods=10))
+            series.between(left, right, inclusive=inclusive)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_case_when.py

@@ -0,0 +1,148 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+    array as pd_array,
+    date_range,
+)
+import pandas._testing as tm
+
+
+@pytest.fixture
+def df():
+    """
+    base dataframe for testing
+    """
+    return DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+
+
+def test_case_when_caselist_is_not_a_list(df):
+    """
+    Raise ValueError if caselist is not a list.
+    """
+    msg = "The caselist argument should be a list; "
+    msg += "instead got.+"
+    with pytest.raises(TypeError, match=msg):  # GH39154
+        df["a"].case_when(caselist=())
+
+
+def test_case_when_no_caselist(df):
+    """
+    Raise ValueError if no caselist is provided.
+    """
+    msg = "provide at least one boolean condition, "
+    msg += "with a corresponding replacement."
+    with pytest.raises(ValueError, match=msg):  # GH39154
+        df["a"].case_when([])
+
+
+def test_case_when_odd_caselist(df):
+    """
+    Raise ValueError if no of caselist is odd.
+    """
+    msg = "Argument 0 must have length 2; "
+    msg += "a condition and replacement; instead got length 3."
+
+    with pytest.raises(ValueError, match=msg):
+        df["a"].case_when([(df["a"].eq(1), 1, df.a.gt(1))])
+
+
+def test_case_when_raise_error_from_mask(df):
+    """
+    Raise Error from within Series.mask
+    """
+    msg = "Failed to apply condition0 and replacement0."
+    with pytest.raises(ValueError, match=msg):
+        df["a"].case_when([(df["a"].eq(1), [1, 2])])
+
+
+def test_case_when_single_condition(df):
+    """
+    Test output on a single condition.
+    """
+    result = Series([np.nan, np.nan, np.nan]).case_when([(df.a.eq(1), 1)])
+    expected = Series([1, np.nan, np.nan])
+    tm.assert_series_equal(result, expected)
+
+
+def test_case_when_multiple_conditions(df):
+    """
+    Test output when booleans are derived from a computation
+    """
+    result = Series([np.nan, np.nan, np.nan]).case_when(
+        [(df.a.eq(1), 1), (Series([False, True, False]), 2)]
+    )
+    expected = Series([1, 2, np.nan])
+    tm.assert_series_equal(result, expected)
+
+
+def test_case_when_multiple_conditions_replacement_list(df):
+    """
+    Test output when replacement is a list
+    """
+    result = Series([np.nan, np.nan, np.nan]).case_when(
+        [([True, False, False], 1), (df["a"].gt(1) & df["b"].eq(5), [1, 2, 3])]
+    )
+    expected = Series([1, 2, np.nan])
+    tm.assert_series_equal(result, expected)
+
+
+def test_case_when_multiple_conditions_replacement_extension_dtype(df):
+    """
+    Test output when replacement has an extension dtype
+    """
+    result = Series([np.nan, np.nan, np.nan]).case_when(
+        [
+            ([True, False, False], 1),
+            (df["a"].gt(1) & df["b"].eq(5), pd_array([1, 2, 3], dtype="Int64")),
+        ],
+    )
+    expected = Series([1, 2, np.nan], dtype="Float64")
+    tm.assert_series_equal(result, expected)
+
+
+def test_case_when_multiple_conditions_replacement_series(df):
+    """
+    Test output when replacement is a Series
+    """
+    result = Series([np.nan, np.nan, np.nan]).case_when(
+        [
+            (np.array([True, False, False]), 1),
+            (df["a"].gt(1) & df["b"].eq(5), Series([1, 2, 3])),
+        ],
+    )
+    expected = Series([1, 2, np.nan])
+    tm.assert_series_equal(result, expected)
+
+
+def test_case_when_non_range_index():
+    """
+    Test output if index is not RangeIndex
+    """
+    rng = np.random.default_rng(seed=123)
+    dates = date_range("1/1/2000", periods=8)
+    df = DataFrame(
+        rng.standard_normal(size=(8, 4)), index=dates, columns=["A", "B", "C", "D"]
+    )
+    result = Series(5, index=df.index, name="A").case_when([(df.A.gt(0), df.B)])
+    expected = df.A.mask(df.A.gt(0), df.B).where(df.A.gt(0), 5)
+    tm.assert_series_equal(result, expected)
+
+
+def test_case_when_callable():
+    """
+    Test output on a callable
+    """
+    # https://numpy.org/doc/stable/reference/generated/numpy.piecewise.html
+    x = np.linspace(-2.5, 2.5, 6)
+    ser = Series(x)
+    result = ser.case_when(
+        caselist=[
+            (lambda df: df < 0, lambda df: -df),
+            (lambda df: df >= 0, lambda df: df),
+        ]
+    )
+    expected = np.piecewise(x, [x < 0, x >= 0], [lambda x: -x, lambda x: x])
+    tm.assert_series_equal(result, Series(expected))

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_combine.py

@@ -0,0 +1,17 @@
+from pandas import Series
+import pandas._testing as tm
+
+
+class TestCombine:
+    def test_combine_scalar(self):
+        # GH#21248
+        # Note - combine() with another Series is tested elsewhere because
+        # it is used when testing operators
+        ser = Series([i * 10 for i in range(5)])
+        result = ser.combine(3, lambda x, y: x + y)
+        expected = Series([i * 10 + 3 for i in range(5)])
+        tm.assert_series_equal(result, expected)
+
+        result = ser.combine(22, lambda x, y: min(x, y))
+        expected = Series([min(i * 10, 22) for i in range(5)])
+        tm.assert_series_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_compare.py

@@ -0,0 +1,141 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize("align_axis", [0, 1, "index", "columns"])
+def test_compare_axis(align_axis):
+    # GH#30429
+    s1 = pd.Series(["a", "b", "c"])
+    s2 = pd.Series(["x", "b", "z"])
+
+    result = s1.compare(s2, align_axis=align_axis)
+
+    if align_axis in (1, "columns"):
+        indices = pd.Index([0, 2])
+        columns = pd.Index(["self", "other"])
+        expected = pd.DataFrame(
+            [["a", "x"], ["c", "z"]], index=indices, columns=columns
+        )
+        tm.assert_frame_equal(result, expected)
+    else:
+        indices = pd.MultiIndex.from_product([[0, 2], ["self", "other"]])
+        expected = pd.Series(["a", "x", "c", "z"], index=indices)
+        tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "keep_shape, keep_equal",
+    [
+        (True, False),
+        (False, True),
+        (True, True),
+        # False, False case is already covered in test_compare_axis
+    ],
+)
+def test_compare_various_formats(keep_shape, keep_equal):
+    s1 = pd.Series(["a", "b", "c"])
+    s2 = pd.Series(["x", "b", "z"])
+
+    result = s1.compare(s2, keep_shape=keep_shape, keep_equal=keep_equal)
+
+    if keep_shape:
+        indices = pd.Index([0, 1, 2])
+        columns = pd.Index(["self", "other"])
+        if keep_equal:
+            expected = pd.DataFrame(
+                [["a", "x"], ["b", "b"], ["c", "z"]], index=indices, columns=columns
+            )
+        else:
+            expected = pd.DataFrame(
+                [["a", "x"], [np.nan, np.nan], ["c", "z"]],
+                index=indices,
+                columns=columns,
+            )
+    else:
+        indices = pd.Index([0, 2])
+        columns = pd.Index(["self", "other"])
+        expected = pd.DataFrame(
+            [["a", "x"], ["c", "z"]], index=indices, columns=columns
+        )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_compare_with_equal_nulls():
+    # We want to make sure two NaNs are considered the same
+    # and dropped where applicable
+    s1 = pd.Series(["a", "b", np.nan])
+    s2 = pd.Series(["x", "b", np.nan])
+
+    result = s1.compare(s2)
+    expected = pd.DataFrame([["a", "x"]], columns=["self", "other"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_compare_with_non_equal_nulls():
+    # We want to make sure the relevant NaNs do not get dropped
+    s1 = pd.Series(["a", "b", "c"])
+    s2 = pd.Series(["x", "b", np.nan])
+
+    result = s1.compare(s2, align_axis=0)
+
+    indices = pd.MultiIndex.from_product([[0, 2], ["self", "other"]])
+    expected = pd.Series(["a", "x", "c", np.nan], index=indices)
+    tm.assert_series_equal(result, expected)
+
+
+def test_compare_multi_index():
+    index = pd.MultiIndex.from_arrays([[0, 0, 1], [0, 1, 2]])
+    s1 = pd.Series(["a", "b", "c"], index=index)
+    s2 = pd.Series(["x", "b", "z"], index=index)
+
+    result = s1.compare(s2, align_axis=0)
+
+    indices = pd.MultiIndex.from_arrays(
+        [[0, 0, 1, 1], [0, 0, 2, 2], ["self", "other", "self", "other"]]
+    )
+    expected = pd.Series(["a", "x", "c", "z"], index=indices)
+    tm.assert_series_equal(result, expected)
+
+
+def test_compare_unaligned_objects():
+    # test Series with different indices
+    msg = "Can only compare identically-labeled Series objects"
+    with pytest.raises(ValueError, match=msg):
+        ser1 = pd.Series([1, 2, 3], index=["a", "b", "c"])
+        ser2 = pd.Series([1, 2, 3], index=["a", "b", "d"])
+        ser1.compare(ser2)
+
+    # test Series with different lengths
+    msg = "Can only compare identically-labeled Series objects"
+    with pytest.raises(ValueError, match=msg):
+        ser1 = pd.Series([1, 2, 3])
+        ser2 = pd.Series([1, 2, 3, 4])
+        ser1.compare(ser2)
+
+
+def test_compare_datetime64_and_string():
+    # Issue https://github.com/pandas-dev/pandas/issues/45506
+    # Catch OverflowError when comparing datetime64 and string
+    data = [
+        {"a": "2015-07-01", "b": "08335394550"},
+        {"a": "2015-07-02", "b": "+49 (0) 0345 300033"},
+        {"a": "2015-07-03", "b": "+49(0)2598 04457"},
+        {"a": "2015-07-04", "b": "0741470003"},
+        {"a": "2015-07-05", "b": "04181 83668"},
+    ]
+    dtypes = {"a": "datetime64[ns]", "b": "string"}
+    df = pd.DataFrame(data=data).astype(dtypes)
+
+    result_eq1 = df["a"].eq(df["b"])
+    result_eq2 = df["a"] == df["b"]
+    result_neq = df["a"] != df["b"]
+
+    expected_eq = pd.Series([False] * 5)  # For .eq and ==
+    expected_neq = pd.Series([True] * 5)  # For !=
+
+    tm.assert_series_equal(result_eq1, expected_eq)
+    tm.assert_series_equal(result_eq2, expected_eq)
+    tm.assert_series_equal(result_neq, expected_neq)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_convert_dtypes.py

@@ -0,0 +1,306 @@
+from itertools import product
+
+import numpy as np
+import pytest
+
+from pandas._libs import lib
+
+import pandas as pd
+import pandas._testing as tm
+
+# Each test case consists of a tuple with the data and dtype to create the
+# test Series, the default dtype for the expected result (which is valid
+# for most cases), and the specific cases where the result deviates from
+# this default. Those overrides are defined as a dict with (keyword, val) as
+# dictionary key. In case of multiple items, the last override takes precedence.
+
+
+@pytest.fixture(
+    params=[
+        (
+            # data
+            [1, 2, 3],
+            # original dtype
+            np.dtype("int32"),
+            # default expected dtype
+            "Int32",
+            # exceptions on expected dtype
+            {("convert_integer", False): np.dtype("int32")},
+        ),
+        (
+            [1, 2, 3],
+            np.dtype("int64"),
+            "Int64",
+            {("convert_integer", False): np.dtype("int64")},
+        ),
+        (
+            ["x", "y", "z"],
+            np.dtype("O"),
+            pd.StringDtype(),
+            {("convert_string", False): np.dtype("O")},
+        ),
+        (
+            [True, False, np.nan],
+            np.dtype("O"),
+            pd.BooleanDtype(),
+            {("convert_boolean", False): np.dtype("O")},
+        ),
+        (
+            ["h", "i", np.nan],
+            np.dtype("O"),
+            pd.StringDtype(),
+            {("convert_string", False): np.dtype("O")},
+        ),
+        (  # GH32117
+            ["h", "i", 1],
+            np.dtype("O"),
+            np.dtype("O"),
+            {},
+        ),
+        (
+            [10, np.nan, 20],
+            np.dtype("float"),
+            "Int64",
+            {
+                ("convert_integer", False, "convert_floating", True): "Float64",
+                ("convert_integer", False, "convert_floating", False): np.dtype(
+                    "float"
+                ),
+            },
+        ),
+        (
+            [np.nan, 100.5, 200],
+            np.dtype("float"),
+            "Float64",
+            {("convert_floating", False): np.dtype("float")},
+        ),
+        (
+            [3, 4, 5],
+            "Int8",
+            "Int8",
+            {},
+        ),
+        (
+            [[1, 2], [3, 4], [5]],
+            None,
+            np.dtype("O"),
+            {},
+        ),
+        (
+            [4, 5, 6],
+            np.dtype("uint32"),
+            "UInt32",
+            {("convert_integer", False): np.dtype("uint32")},
+        ),
+        (
+            [-10, 12, 13],
+            np.dtype("i1"),
+            "Int8",
+            {("convert_integer", False): np.dtype("i1")},
+        ),
+        (
+            [1.2, 1.3],
+            np.dtype("float32"),
+            "Float32",
+            {("convert_floating", False): np.dtype("float32")},
+        ),
+        (
+            [1, 2.0],
+            object,
+            "Int64",
+            {
+                ("convert_integer", False): "Float64",
+                ("convert_integer", False, "convert_floating", False): np.dtype(
+                    "float"
+                ),
+                ("infer_objects", False): np.dtype("object"),
+            },
+        ),
+        (
+            [1, 2.5],
+            object,
+            "Float64",
+            {
+                ("convert_floating", False): np.dtype("float"),
+                ("infer_objects", False): np.dtype("object"),
+            },
+        ),
+        (["a", "b"], pd.CategoricalDtype(), pd.CategoricalDtype(), {}),
+        (
+            pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("s"),
+            pd.DatetimeTZDtype(tz="UTC"),
+            pd.DatetimeTZDtype(tz="UTC"),
+            {},
+        ),
+        (
+            pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ms"),
+            pd.DatetimeTZDtype(tz="UTC"),
+            pd.DatetimeTZDtype(tz="UTC"),
+            {},
+        ),
+        (
+            pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("us"),
+            pd.DatetimeTZDtype(tz="UTC"),
+            pd.DatetimeTZDtype(tz="UTC"),
+            {},
+        ),
+        (
+            pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ns"),
+            pd.DatetimeTZDtype(tz="UTC"),
+            pd.DatetimeTZDtype(tz="UTC"),
+            {},
+        ),
+        (
+            pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ns"),
+            "datetime64[ns]",
+            np.dtype("datetime64[ns]"),
+            {},
+        ),
+        (
+            pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ns"),
+            object,
+            np.dtype("datetime64[ns]"),
+            {("infer_objects", False): np.dtype("object")},
+        ),
+        (
+            pd.period_range("1/1/2011", freq="M", periods=3),
+            None,
+            pd.PeriodDtype("M"),
+            {},
+        ),
+        (
+            pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)]),
+            None,
+            pd.IntervalDtype("int64", "right"),
+            {},
+        ),
+    ]
+)
+def test_cases(request):
+    return request.param
+
+
+class TestSeriesConvertDtypes:
+    @pytest.mark.parametrize("params", product(*[(True, False)] * 5))
+    def test_convert_dtypes(
+        self,
+        test_cases,
+        params,
+        using_infer_string,
+    ):
+        data, maindtype, expected_default, expected_other = test_cases
+        if (
+            hasattr(data, "dtype")
+            and lib.is_np_dtype(data.dtype, "M")
+            and isinstance(maindtype, pd.DatetimeTZDtype)
+        ):
+            # this astype is deprecated in favor of tz_localize
+            msg = "Cannot use .astype to convert from timezone-naive dtype"
+            with pytest.raises(TypeError, match=msg):
+                pd.Series(data, dtype=maindtype)
+            return
+
+        if maindtype is not None:
+            series = pd.Series(data, dtype=maindtype)
+        else:
+            series = pd.Series(data)
+
+        result = series.convert_dtypes(*params)
+
+        param_names = [
+            "infer_objects",
+            "convert_string",
+            "convert_integer",
+            "convert_boolean",
+            "convert_floating",
+        ]
+        params_dict = dict(zip(param_names, params))
+
+        expected_dtype = expected_default
+        for spec, dtype in expected_other.items():
+            if all(params_dict[key] is val for key, val in zip(spec[::2], spec[1::2])):
+                expected_dtype = dtype
+        if (
+            using_infer_string
+            and expected_default == "string"
+            and expected_dtype == object
+            and params[0]
+            and not params[1]
+        ):
+            # If we would convert with convert strings then infer_objects converts
+            # with the option
+            expected_dtype = "string[pyarrow_numpy]"
+
+        expected = pd.Series(data, dtype=expected_dtype)
+        tm.assert_series_equal(result, expected)
+
+        # Test that it is a copy
+        copy = series.copy(deep=True)
+
+        if result.notna().sum() > 0 and result.dtype in ["interval[int64, right]"]:
+            with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+                result[result.notna()] = np.nan
+        else:
+            result[result.notna()] = np.nan
+
+        # Make sure original not changed
+        tm.assert_series_equal(series, copy)
+
+    def test_convert_string_dtype(self, nullable_string_dtype):
+        # https://github.com/pandas-dev/pandas/issues/31731 -> converting columns
+        # that are already string dtype
+        df = pd.DataFrame(
+            {"A": ["a", "b", pd.NA], "B": ["ä", "ö", "ü"]}, dtype=nullable_string_dtype
+        )
+        result = df.convert_dtypes()
+        tm.assert_frame_equal(df, result)
+
+    def test_convert_bool_dtype(self):
+        # GH32287
+        df = pd.DataFrame({"A": pd.array([True])})
+        tm.assert_frame_equal(df, df.convert_dtypes())
+
+    def test_convert_byte_string_dtype(self):
+        # GH-43183
+        byte_str = b"binary-string"
+
+        df = pd.DataFrame(data={"A": byte_str}, index=[0])
+        result = df.convert_dtypes()
+        expected = df
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "infer_objects, dtype", [(True, "Int64"), (False, "object")]
+    )
+    def test_convert_dtype_object_with_na(self, infer_objects, dtype):
+        # GH#48791
+        ser = pd.Series([1, pd.NA])
+        result = ser.convert_dtypes(infer_objects=infer_objects)
+        expected = pd.Series([1, pd.NA], dtype=dtype)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "infer_objects, dtype", [(True, "Float64"), (False, "object")]
+    )
+    def test_convert_dtype_object_with_na_float(self, infer_objects, dtype):
+        # GH#48791
+        ser = pd.Series([1.5, pd.NA])
+        result = ser.convert_dtypes(infer_objects=infer_objects)
+        expected = pd.Series([1.5, pd.NA], dtype=dtype)
+        tm.assert_series_equal(result, expected)
+
+    def test_convert_dtypes_pyarrow_to_np_nullable(self):
+        # GH 53648
+        pytest.importorskip("pyarrow")
+        ser = pd.Series(range(2), dtype="int32[pyarrow]")
+        result = ser.convert_dtypes(dtype_backend="numpy_nullable")
+        expected = pd.Series(range(2), dtype="Int32")
+        tm.assert_series_equal(result, expected)
+
+    def test_convert_dtypes_pyarrow_null(self):
+        # GH#55346
+        pa = pytest.importorskip("pyarrow")
+        ser = pd.Series([None, None])
+        result = ser.convert_dtypes(dtype_backend="pyarrow")
+        expected = pd.Series([None, None], dtype=pd.ArrowDtype(pa.null()))
+        tm.assert_series_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_copy.py

@@ -0,0 +1,91 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Series,
+    Timestamp,
+)
+import pandas._testing as tm
+
+
+class TestCopy:
+    @pytest.mark.parametrize("deep", ["default", None, False, True])
+    def test_copy(self, deep, using_copy_on_write, warn_copy_on_write):
+        ser = Series(np.arange(10), dtype="float64")
+
+        # default deep is True
+        if deep == "default":
+            ser2 = ser.copy()
+        else:
+            ser2 = ser.copy(deep=deep)
+
+        if using_copy_on_write:
+            # INFO(CoW) a shallow copy doesn't yet copy the data
+            # but parent will not be modified (CoW)
+            if deep is None or deep is False:
+                assert np.may_share_memory(ser.values, ser2.values)
+            else:
+                assert not np.may_share_memory(ser.values, ser2.values)
+
+        with tm.assert_cow_warning(warn_copy_on_write and deep is False):
+            ser2[::2] = np.nan
+
+        if deep is not False or using_copy_on_write:
+            # Did not modify original Series
+            assert np.isnan(ser2[0])
+            assert not np.isnan(ser[0])
+        else:
+            # we DID modify the original Series
+            assert np.isnan(ser2[0])
+            assert np.isnan(ser[0])
+
+    @pytest.mark.filterwarnings("ignore:Setting a value on a view:FutureWarning")
+    @pytest.mark.parametrize("deep", ["default", None, False, True])
+    def test_copy_tzaware(self, deep, using_copy_on_write):
+        # GH#11794
+        # copy of tz-aware
+        expected = Series([Timestamp("2012/01/01", tz="UTC")])
+        expected2 = Series([Timestamp("1999/01/01", tz="UTC")])
+
+        ser = Series([Timestamp("2012/01/01", tz="UTC")])
+
+        if deep == "default":
+            ser2 = ser.copy()
+        else:
+            ser2 = ser.copy(deep=deep)
+
+        if using_copy_on_write:
+            # INFO(CoW) a shallow copy doesn't yet copy the data
+            # but parent will not be modified (CoW)
+            if deep is None or deep is False:
+                assert np.may_share_memory(ser.values, ser2.values)
+            else:
+                assert not np.may_share_memory(ser.values, ser2.values)
+
+        ser2[0] = Timestamp("1999/01/01", tz="UTC")
+
+        # default deep is True
+        if deep is not False or using_copy_on_write:
+            # Did not modify original Series
+            tm.assert_series_equal(ser2, expected2)
+            tm.assert_series_equal(ser, expected)
+        else:
+            # we DID modify the original Series
+            tm.assert_series_equal(ser2, expected2)
+            tm.assert_series_equal(ser, expected2)
+
+    def test_copy_name(self, datetime_series):
+        result = datetime_series.copy()
+        assert result.name == datetime_series.name
+
+    def test_copy_index_name_checking(self, datetime_series):
+        # don't want to be able to modify the index stored elsewhere after
+        # making a copy
+
+        datetime_series.index.name = None
+        assert datetime_series.index.name is None
+        assert datetime_series is datetime_series
+
+        cp = datetime_series.copy()
+        cp.index.name = "foo"
+        assert datetime_series.index.name is None

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_count.py

@@ -0,0 +1,34 @@
+import numpy as np
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestSeriesCount:
+    def test_count(self, datetime_series):
+        assert datetime_series.count() == len(datetime_series)
+
+        datetime_series[::2] = np.nan
+
+        assert datetime_series.count() == np.isfinite(datetime_series).sum()
+
+    def test_count_inf_as_na(self):
+        # GH#29478
+        ser = Series([pd.Timestamp("1990/1/1")])
+        msg = "use_inf_as_na option is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            with pd.option_context("use_inf_as_na", True):
+                assert ser.count() == 1
+
+    def test_count_categorical(self):
+        ser = Series(
+            Categorical(
+                [np.nan, 1, 2, np.nan], categories=[5, 4, 3, 2, 1], ordered=True
+            )
+        )
+        result = ser.count()
+        assert result == 2

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_describe.py

@@ -0,0 +1,203 @@
+import numpy as np
+import pytest
+
+from pandas.compat.numpy import np_version_gte1p25
+
+from pandas.core.dtypes.common import (
+    is_complex_dtype,
+    is_extension_array_dtype,
+)
+
+from pandas import (
+    NA,
+    Period,
+    Series,
+    Timedelta,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestSeriesDescribe:
+    def test_describe_ints(self):
+        ser = Series([0, 1, 2, 3, 4], name="int_data")
+        result = ser.describe()
+        expected = Series(
+            [5, 2, ser.std(), 0, 1, 2, 3, 4],
+            name="int_data",
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_describe_bools(self):
+        ser = Series([True, True, False, False, False], name="bool_data")
+        result = ser.describe()
+        expected = Series(
+            [5, 2, False, 3], name="bool_data", index=["count", "unique", "top", "freq"]
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_describe_strs(self):
+        ser = Series(["a", "a", "b", "c", "d"], name="str_data")
+        result = ser.describe()
+        expected = Series(
+            [5, 4, "a", 2], name="str_data", index=["count", "unique", "top", "freq"]
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_describe_timedelta64(self):
+        ser = Series(
+            [
+                Timedelta("1 days"),
+                Timedelta("2 days"),
+                Timedelta("3 days"),
+                Timedelta("4 days"),
+                Timedelta("5 days"),
+            ],
+            name="timedelta_data",
+        )
+        result = ser.describe()
+        expected = Series(
+            [5, ser[2], ser.std(), ser[0], ser[1], ser[2], ser[3], ser[4]],
+            name="timedelta_data",
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_describe_period(self):
+        ser = Series(
+            [Period("2020-01", "M"), Period("2020-01", "M"), Period("2019-12", "M")],
+            name="period_data",
+        )
+        result = ser.describe()
+        expected = Series(
+            [3, 2, ser[0], 2],
+            name="period_data",
+            index=["count", "unique", "top", "freq"],
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_describe_empty_object(self):
+        # https://github.com/pandas-dev/pandas/issues/27183
+        s = Series([None, None], dtype=object)
+        result = s.describe()
+        expected = Series(
+            [0, 0, np.nan, np.nan],
+            dtype=object,
+            index=["count", "unique", "top", "freq"],
+        )
+        tm.assert_series_equal(result, expected)
+
+        result = s[:0].describe()
+        tm.assert_series_equal(result, expected)
+        # ensure NaN, not None
+        assert np.isnan(result.iloc[2])
+        assert np.isnan(result.iloc[3])
+
+    def test_describe_with_tz(self, tz_naive_fixture):
+        # GH 21332
+        tz = tz_naive_fixture
+        name = str(tz_naive_fixture)
+        start = Timestamp(2018, 1, 1)
+        end = Timestamp(2018, 1, 5)
+        s = Series(date_range(start, end, tz=tz), name=name)
+        result = s.describe()
+        expected = Series(
+            [
+                5,
+                Timestamp(2018, 1, 3).tz_localize(tz),
+                start.tz_localize(tz),
+                s[1],
+                s[2],
+                s[3],
+                end.tz_localize(tz),
+            ],
+            name=name,
+            index=["count", "mean", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_describe_with_tz_numeric(self):
+        name = tz = "CET"
+        start = Timestamp(2018, 1, 1)
+        end = Timestamp(2018, 1, 5)
+        s = Series(date_range(start, end, tz=tz), name=name)
+
+        result = s.describe()
+
+        expected = Series(
+            [
+                5,
+                Timestamp("2018-01-03 00:00:00", tz=tz),
+                Timestamp("2018-01-01 00:00:00", tz=tz),
+                Timestamp("2018-01-02 00:00:00", tz=tz),
+                Timestamp("2018-01-03 00:00:00", tz=tz),
+                Timestamp("2018-01-04 00:00:00", tz=tz),
+                Timestamp("2018-01-05 00:00:00", tz=tz),
+            ],
+            name=name,
+            index=["count", "mean", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_datetime_is_numeric_includes_datetime(self):
+        s = Series(date_range("2012", periods=3))
+        result = s.describe()
+        expected = Series(
+            [
+                3,
+                Timestamp("2012-01-02"),
+                Timestamp("2012-01-01"),
+                Timestamp("2012-01-01T12:00:00"),
+                Timestamp("2012-01-02"),
+                Timestamp("2012-01-02T12:00:00"),
+                Timestamp("2012-01-03"),
+            ],
+            index=["count", "mean", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.filterwarnings("ignore:Casting complex values to real discards")
+    def test_numeric_result_dtype(self, any_numeric_dtype):
+        # GH#48340 - describe should always return float on non-complex numeric input
+        if is_extension_array_dtype(any_numeric_dtype):
+            dtype = "Float64"
+        else:
+            dtype = "complex128" if is_complex_dtype(any_numeric_dtype) else None
+
+        ser = Series([0, 1], dtype=any_numeric_dtype)
+        if dtype == "complex128" and np_version_gte1p25:
+            with pytest.raises(
+                TypeError, match=r"^a must be an array of real numbers$"
+            ):
+                ser.describe()
+            return
+        result = ser.describe()
+        expected = Series(
+            [
+                2.0,
+                0.5,
+                ser.std(),
+                0,
+                0.25,
+                0.5,
+                0.75,
+                1.0,
+            ],
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+            dtype=dtype,
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_describe_one_element_ea(self):
+        # GH#52515
+        ser = Series([0.0], dtype="Float64")
+        with tm.assert_produces_warning(None):
+            result = ser.describe()
+        expected = Series(
+            [1, 0, NA, 0, 0, 0, 0, 0],
+            dtype="Float64",
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_series_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_diff.py

@@ -0,0 +1,88 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Series,
+    TimedeltaIndex,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestSeriesDiff:
+    def test_diff_np(self):
+        # TODO(__array_function__): could make np.diff return a Series
+        #  matching ser.diff()
+
+        ser = Series(np.arange(5))
+
+        res = np.diff(ser)
+        expected = np.array([1, 1, 1, 1])
+        tm.assert_numpy_array_equal(res, expected)
+
+    def test_diff_int(self):
+        # int dtype
+        a = 10000000000000000
+        b = a + 1
+        ser = Series([a, b])
+
+        result = ser.diff()
+        assert result[1] == 1
+
+    def test_diff_tz(self):
+        # Combined datetime diff, normal diff and boolean diff test
+        ts = Series(
+            np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10),
+            name="ts",
+        )
+        ts.diff()
+
+        # neg n
+        result = ts.diff(-1)
+        expected = ts - ts.shift(-1)
+        tm.assert_series_equal(result, expected)
+
+        # 0
+        result = ts.diff(0)
+        expected = ts - ts
+        tm.assert_series_equal(result, expected)
+
+    def test_diff_dt64(self):
+        # datetime diff (GH#3100)
+        ser = Series(date_range("20130102", periods=5))
+        result = ser.diff()
+        expected = ser - ser.shift(1)
+        tm.assert_series_equal(result, expected)
+
+        # timedelta diff
+        result = result - result.shift(1)  # previous result
+        expected = expected.diff()  # previously expected
+        tm.assert_series_equal(result, expected)
+
+    def test_diff_dt64tz(self):
+        # with tz
+        ser = Series(
+            date_range("2000-01-01 09:00:00", periods=5, tz="US/Eastern"), name="foo"
+        )
+        result = ser.diff()
+        expected = Series(TimedeltaIndex(["NaT"] + ["1 days"] * 4), name="foo")
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "input,output,diff",
+        [([False, True, True, False, False], [np.nan, True, False, True, False], 1)],
+    )
+    def test_diff_bool(self, input, output, diff):
+        # boolean series (test for fixing #17294)
+        ser = Series(input)
+        result = ser.diff()
+        expected = Series(output)
+        tm.assert_series_equal(result, expected)
+
+    def test_diff_object_dtype(self):
+        # object series
+        ser = Series([False, True, 5.0, np.nan, True, False])
+        result = ser.diff()
+        expected = ser - ser.shift(1)
+        tm.assert_series_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_drop_duplicates.py

@@ -0,0 +1,267 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    Series,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "keep, expected",
+    [
+        ("first", Series([False, False, False, False, True, True, False])),
+        ("last", Series([False, True, True, False, False, False, False])),
+        (False, Series([False, True, True, False, True, True, False])),
+    ],
+)
+def test_drop_duplicates(any_numpy_dtype, keep, expected):
+    tc = Series([1, 0, 3, 5, 3, 0, 4], dtype=np.dtype(any_numpy_dtype))
+
+    if tc.dtype == "bool":
+        pytest.skip("tested separately in test_drop_duplicates_bool")
+
+    tm.assert_series_equal(tc.duplicated(keep=keep), expected)
+    tm.assert_series_equal(tc.drop_duplicates(keep=keep), tc[~expected])
+    sc = tc.copy()
+    return_value = sc.drop_duplicates(keep=keep, inplace=True)
+    assert return_value is None
+    tm.assert_series_equal(sc, tc[~expected])
+
+
+@pytest.mark.parametrize(
+    "keep, expected",
+    [
+        ("first", Series([False, False, True, True])),
+        ("last", Series([True, True, False, False])),
+        (False, Series([True, True, True, True])),
+    ],
+)
+def test_drop_duplicates_bool(keep, expected):
+    tc = Series([True, False, True, False])
+
+    tm.assert_series_equal(tc.duplicated(keep=keep), expected)
+    tm.assert_series_equal(tc.drop_duplicates(keep=keep), tc[~expected])
+    sc = tc.copy()
+    return_value = sc.drop_duplicates(keep=keep, inplace=True)
+    tm.assert_series_equal(sc, tc[~expected])
+    assert return_value is None
+
+
+@pytest.mark.parametrize("values", [[], list(range(5))])
+def test_drop_duplicates_no_duplicates(any_numpy_dtype, keep, values):
+    tc = Series(values, dtype=np.dtype(any_numpy_dtype))
+    expected = Series([False] * len(tc), dtype="bool")
+
+    if tc.dtype == "bool":
+        # 0 -> False and 1-> True
+        # any other value would be duplicated
+        tc = tc[:2]
+        expected = expected[:2]
+
+    tm.assert_series_equal(tc.duplicated(keep=keep), expected)
+
+    result_dropped = tc.drop_duplicates(keep=keep)
+    tm.assert_series_equal(result_dropped, tc)
+
+    # validate shallow copy
+    assert result_dropped is not tc
+
+
+class TestSeriesDropDuplicates:
+    @pytest.fixture(
+        params=["int_", "uint", "float64", "str_", "timedelta64[h]", "datetime64[D]"]
+    )
+    def dtype(self, request):
+        return request.param
+
+    @pytest.fixture
+    def cat_series_unused_category(self, dtype, ordered):
+        # Test case 1
+        cat_array = np.array([1, 2, 3, 4, 5], dtype=np.dtype(dtype))
+
+        input1 = np.array([1, 2, 3, 3], dtype=np.dtype(dtype))
+        cat = Categorical(input1, categories=cat_array, ordered=ordered)
+        tc1 = Series(cat)
+        return tc1
+
+    def test_drop_duplicates_categorical_non_bool(self, cat_series_unused_category):
+        tc1 = cat_series_unused_category
+
+        expected = Series([False, False, False, True])
+
+        result = tc1.duplicated()
+        tm.assert_series_equal(result, expected)
+
+        result = tc1.drop_duplicates()
+        tm.assert_series_equal(result, tc1[~expected])
+
+        sc = tc1.copy()
+        return_value = sc.drop_duplicates(inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(sc, tc1[~expected])
+
+    def test_drop_duplicates_categorical_non_bool_keeplast(
+        self, cat_series_unused_category
+    ):
+        tc1 = cat_series_unused_category
+
+        expected = Series([False, False, True, False])
+
+        result = tc1.duplicated(keep="last")
+        tm.assert_series_equal(result, expected)
+
+        result = tc1.drop_duplicates(keep="last")
+        tm.assert_series_equal(result, tc1[~expected])
+
+        sc = tc1.copy()
+        return_value = sc.drop_duplicates(keep="last", inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(sc, tc1[~expected])
+
+    def test_drop_duplicates_categorical_non_bool_keepfalse(
+        self, cat_series_unused_category
+    ):
+        tc1 = cat_series_unused_category
+
+        expected = Series([False, False, True, True])
+
+        result = tc1.duplicated(keep=False)
+        tm.assert_series_equal(result, expected)
+
+        result = tc1.drop_duplicates(keep=False)
+        tm.assert_series_equal(result, tc1[~expected])
+
+        sc = tc1.copy()
+        return_value = sc.drop_duplicates(keep=False, inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(sc, tc1[~expected])
+
+    @pytest.fixture
+    def cat_series(self, dtype, ordered):
+        # no unused categories, unlike cat_series_unused_category
+        cat_array = np.array([1, 2, 3, 4, 5], dtype=np.dtype(dtype))
+
+        input2 = np.array([1, 2, 3, 5, 3, 2, 4], dtype=np.dtype(dtype))
+        cat = Categorical(input2, categories=cat_array, ordered=ordered)
+        tc2 = Series(cat)
+        return tc2
+
+    def test_drop_duplicates_categorical_non_bool2(self, cat_series):
+        tc2 = cat_series
+
+        expected = Series([False, False, False, False, True, True, False])
+
+        result = tc2.duplicated()
+        tm.assert_series_equal(result, expected)
+
+        result = tc2.drop_duplicates()
+        tm.assert_series_equal(result, tc2[~expected])
+
+        sc = tc2.copy()
+        return_value = sc.drop_duplicates(inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(sc, tc2[~expected])
+
+    def test_drop_duplicates_categorical_non_bool2_keeplast(self, cat_series):
+        tc2 = cat_series
+
+        expected = Series([False, True, True, False, False, False, False])
+
+        result = tc2.duplicated(keep="last")
+        tm.assert_series_equal(result, expected)
+
+        result = tc2.drop_duplicates(keep="last")
+        tm.assert_series_equal(result, tc2[~expected])
+
+        sc = tc2.copy()
+        return_value = sc.drop_duplicates(keep="last", inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(sc, tc2[~expected])
+
+    def test_drop_duplicates_categorical_non_bool2_keepfalse(self, cat_series):
+        tc2 = cat_series
+
+        expected = Series([False, True, True, False, True, True, False])
+
+        result = tc2.duplicated(keep=False)
+        tm.assert_series_equal(result, expected)
+
+        result = tc2.drop_duplicates(keep=False)
+        tm.assert_series_equal(result, tc2[~expected])
+
+        sc = tc2.copy()
+        return_value = sc.drop_duplicates(keep=False, inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(sc, tc2[~expected])
+
+    def test_drop_duplicates_categorical_bool(self, ordered):
+        tc = Series(
+            Categorical(
+                [True, False, True, False], categories=[True, False], ordered=ordered
+            )
+        )
+
+        expected = Series([False, False, True, True])
+        tm.assert_series_equal(tc.duplicated(), expected)
+        tm.assert_series_equal(tc.drop_duplicates(), tc[~expected])
+        sc = tc.copy()
+        return_value = sc.drop_duplicates(inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(sc, tc[~expected])
+
+        expected = Series([True, True, False, False])
+        tm.assert_series_equal(tc.duplicated(keep="last"), expected)
+        tm.assert_series_equal(tc.drop_duplicates(keep="last"), tc[~expected])
+        sc = tc.copy()
+        return_value = sc.drop_duplicates(keep="last", inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(sc, tc[~expected])
+
+        expected = Series([True, True, True, True])
+        tm.assert_series_equal(tc.duplicated(keep=False), expected)
+        tm.assert_series_equal(tc.drop_duplicates(keep=False), tc[~expected])
+        sc = tc.copy()
+        return_value = sc.drop_duplicates(keep=False, inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(sc, tc[~expected])
+
+    def test_drop_duplicates_categorical_bool_na(self, nulls_fixture):
+        # GH#44351
+        ser = Series(
+            Categorical(
+                [True, False, True, False, nulls_fixture],
+                categories=[True, False],
+                ordered=True,
+            )
+        )
+        result = ser.drop_duplicates()
+        expected = Series(
+            Categorical([True, False, np.nan], categories=[True, False], ordered=True),
+            index=[0, 1, 4],
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_drop_duplicates_ignore_index(self):
+        # GH#48304
+        ser = Series([1, 2, 2, 3])
+        result = ser.drop_duplicates(ignore_index=True)
+        expected = Series([1, 2, 3])
+        tm.assert_series_equal(result, expected)
+
+    def test_duplicated_arrow_dtype(self):
+        pytest.importorskip("pyarrow")
+        ser = Series([True, False, None, False], dtype="bool[pyarrow]")
+        result = ser.drop_duplicates()
+        expected = Series([True, False, None], dtype="bool[pyarrow]")
+        tm.assert_series_equal(result, expected)
+
+    def test_drop_duplicates_arrow_strings(self):
+        # GH#54904
+        pa = pytest.importorskip("pyarrow")
+        ser = Series(["a", "a"], dtype=pd.ArrowDtype(pa.string()))
+        result = ser.drop_duplicates()
+        expecetd = Series(["a"], dtype=pd.ArrowDtype(pa.string()))
+        tm.assert_series_equal(result, expecetd)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_dropna.py

@@ -0,0 +1,117 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DatetimeIndex,
+    IntervalIndex,
+    NaT,
+    Period,
+    Series,
+    Timestamp,
+)
+import pandas._testing as tm
+
+
+class TestDropna:
+    def test_dropna_empty(self):
+        ser = Series([], dtype=object)
+
+        assert len(ser.dropna()) == 0
+        return_value = ser.dropna(inplace=True)
+        assert return_value is None
+        assert len(ser) == 0
+
+        # invalid axis
+        msg = "No axis named 1 for object type Series"
+        with pytest.raises(ValueError, match=msg):
+            ser.dropna(axis=1)
+
+    def test_dropna_preserve_name(self, datetime_series):
+        datetime_series[:5] = np.nan
+        result = datetime_series.dropna()
+        assert result.name == datetime_series.name
+        name = datetime_series.name
+        ts = datetime_series.copy()
+        return_value = ts.dropna(inplace=True)
+        assert return_value is None
+        assert ts.name == name
+
+    def test_dropna_no_nan(self):
+        for ser in [
+            Series([1, 2, 3], name="x"),
+            Series([False, True, False], name="x"),
+        ]:
+            result = ser.dropna()
+            tm.assert_series_equal(result, ser)
+            assert result is not ser
+
+            s2 = ser.copy()
+            return_value = s2.dropna(inplace=True)
+            assert return_value is None
+            tm.assert_series_equal(s2, ser)
+
+    def test_dropna_intervals(self):
+        ser = Series(
+            [np.nan, 1, 2, 3],
+            IntervalIndex.from_arrays([np.nan, 0, 1, 2], [np.nan, 1, 2, 3]),
+        )
+
+        result = ser.dropna()
+        expected = ser.iloc[1:]
+        tm.assert_series_equal(result, expected)
+
+    def test_dropna_period_dtype(self):
+        # GH#13737
+        ser = Series([Period("2011-01", freq="M"), Period("NaT", freq="M")])
+        result = ser.dropna()
+        expected = Series([Period("2011-01", freq="M")])
+
+        tm.assert_series_equal(result, expected)
+
+    def test_datetime64_tz_dropna(self, unit):
+        # DatetimeLikeBlock
+        ser = Series(
+            [
+                Timestamp("2011-01-01 10:00"),
+                NaT,
+                Timestamp("2011-01-03 10:00"),
+                NaT,
+            ],
+            dtype=f"M8[{unit}]",
+        )
+        result = ser.dropna()
+        expected = Series(
+            [Timestamp("2011-01-01 10:00"), Timestamp("2011-01-03 10:00")],
+            index=[0, 2],
+            dtype=f"M8[{unit}]",
+        )
+        tm.assert_series_equal(result, expected)
+
+        # DatetimeTZBlock
+        idx = DatetimeIndex(
+            ["2011-01-01 10:00", NaT, "2011-01-03 10:00", NaT], tz="Asia/Tokyo"
+        ).as_unit(unit)
+        ser = Series(idx)
+        assert ser.dtype == f"datetime64[{unit}, Asia/Tokyo]"
+        result = ser.dropna()
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00", tz="Asia/Tokyo"),
+                Timestamp("2011-01-03 10:00", tz="Asia/Tokyo"),
+            ],
+            index=[0, 2],
+            dtype=f"datetime64[{unit}, Asia/Tokyo]",
+        )
+        assert result.dtype == f"datetime64[{unit}, Asia/Tokyo]"
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("val", [1, 1.5])
+    def test_dropna_ignore_index(self, val):
+        # GH#31725
+        ser = Series([1, 2, val], index=[3, 2, 1])
+        result = ser.dropna(ignore_index=True)
+        expected = Series([1, 2, val])
+        tm.assert_series_equal(result, expected)
+
+        ser.dropna(ignore_index=True, inplace=True)
+        tm.assert_series_equal(ser, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_dtypes.py

@@ -0,0 +1,7 @@
+import numpy as np
+
+
+class TestSeriesDtypes:
+    def test_dtype(self, datetime_series):
+        assert datetime_series.dtype == np.dtype("float64")
+        assert datetime_series.dtypes == np.dtype("float64")

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_explode.py

@@ -0,0 +1,175 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+def test_basic():
+    s = pd.Series([[0, 1, 2], np.nan, [], (3, 4)], index=list("abcd"), name="foo")
+    result = s.explode()
+    expected = pd.Series(
+        [0, 1, 2, np.nan, np.nan, 3, 4], index=list("aaabcdd"), dtype=object, name="foo"
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_mixed_type():
+    s = pd.Series(
+        [[0, 1, 2], np.nan, None, np.array([]), pd.Series(["a", "b"])], name="foo"
+    )
+    result = s.explode()
+    expected = pd.Series(
+        [0, 1, 2, np.nan, None, np.nan, "a", "b"],
+        index=[0, 0, 0, 1, 2, 3, 4, 4],
+        dtype=object,
+        name="foo",
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_empty():
+    s = pd.Series(dtype=object)
+    result = s.explode()
+    expected = s.copy()
+    tm.assert_series_equal(result, expected)
+
+
+def test_nested_lists():
+    s = pd.Series([[[1, 2, 3]], [1, 2], 1])
+    result = s.explode()
+    expected = pd.Series([[1, 2, 3], 1, 2, 1], index=[0, 1, 1, 2])
+    tm.assert_series_equal(result, expected)
+
+
+def test_multi_index():
+    s = pd.Series(
+        [[0, 1, 2], np.nan, [], (3, 4)],
+        name="foo",
+        index=pd.MultiIndex.from_product([list("ab"), range(2)], names=["foo", "bar"]),
+    )
+    result = s.explode()
+    index = pd.MultiIndex.from_tuples(
+        [("a", 0), ("a", 0), ("a", 0), ("a", 1), ("b", 0), ("b", 1), ("b", 1)],
+        names=["foo", "bar"],
+    )
+    expected = pd.Series(
+        [0, 1, 2, np.nan, np.nan, 3, 4], index=index, dtype=object, name="foo"
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_large():
+    s = pd.Series([range(256)]).explode()
+    result = s.explode()
+    tm.assert_series_equal(result, s)
+
+
+def test_invert_array():
+    df = pd.DataFrame({"a": pd.date_range("20190101", periods=3, tz="UTC")})
+
+    listify = df.apply(lambda x: x.array, axis=1)
+    result = listify.explode()
+    tm.assert_series_equal(result, df["a"].rename())
+
+
+@pytest.mark.parametrize(
+    "s", [pd.Series([1, 2, 3]), pd.Series(pd.date_range("2019", periods=3, tz="UTC"))]
+)
+def test_non_object_dtype(s):
+    result = s.explode()
+    tm.assert_series_equal(result, s)
+
+
+def test_typical_usecase():
+    df = pd.DataFrame(
+        [{"var1": "a,b,c", "var2": 1}, {"var1": "d,e,f", "var2": 2}],
+        columns=["var1", "var2"],
+    )
+    exploded = df.var1.str.split(",").explode()
+    result = df[["var2"]].join(exploded)
+    expected = pd.DataFrame(
+        {"var2": [1, 1, 1, 2, 2, 2], "var1": list("abcdef")},
+        columns=["var2", "var1"],
+        index=[0, 0, 0, 1, 1, 1],
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_nested_EA():
+    # a nested EA array
+    s = pd.Series(
+        [
+            pd.date_range("20170101", periods=3, tz="UTC"),
+            pd.date_range("20170104", periods=3, tz="UTC"),
+        ]
+    )
+    result = s.explode()
+    expected = pd.Series(
+        pd.date_range("20170101", periods=6, tz="UTC"), index=[0, 0, 0, 1, 1, 1]
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_duplicate_index():
+    # GH 28005
+    s = pd.Series([[1, 2], [3, 4]], index=[0, 0])
+    result = s.explode()
+    expected = pd.Series([1, 2, 3, 4], index=[0, 0, 0, 0], dtype=object)
+    tm.assert_series_equal(result, expected)
+
+
+def test_ignore_index():
+    # GH 34932
+    s = pd.Series([[1, 2], [3, 4]])
+    result = s.explode(ignore_index=True)
+    expected = pd.Series([1, 2, 3, 4], index=[0, 1, 2, 3], dtype=object)
+    tm.assert_series_equal(result, expected)
+
+
+def test_explode_sets():
+    # https://github.com/pandas-dev/pandas/issues/35614
+    s = pd.Series([{"a", "b", "c"}], index=[1])
+    result = s.explode().sort_values()
+    expected = pd.Series(["a", "b", "c"], index=[1, 1, 1])
+    tm.assert_series_equal(result, expected)
+
+
+def test_explode_scalars_can_ignore_index():
+    # https://github.com/pandas-dev/pandas/issues/40487
+    s = pd.Series([1, 2, 3], index=["a", "b", "c"])
+    result = s.explode(ignore_index=True)
+    expected = pd.Series([1, 2, 3])
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("ignore_index", [True, False])
+def test_explode_pyarrow_list_type(ignore_index):
+    # GH 53602
+    pa = pytest.importorskip("pyarrow")
+
+    data = [
+        [None, None],
+        [1],
+        [],
+        [2, 3],
+        None,
+    ]
+    ser = pd.Series(data, dtype=pd.ArrowDtype(pa.list_(pa.int64())))
+    result = ser.explode(ignore_index=ignore_index)
+    expected = pd.Series(
+        data=[None, None, 1, None, 2, 3, None],
+        index=None if ignore_index else [0, 0, 1, 2, 3, 3, 4],
+        dtype=pd.ArrowDtype(pa.int64()),
+    )
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("ignore_index", [True, False])
+def test_explode_pyarrow_non_list_type(ignore_index):
+    pa = pytest.importorskip("pyarrow")
+    data = [1, 2, 3]
+    ser = pd.Series(data, dtype=pd.ArrowDtype(pa.int64()))
+    result = ser.explode(ignore_index=ignore_index)
+    expected = pd.Series([1, 2, 3], dtype="int64[pyarrow]", index=[0, 1, 2])
+    tm.assert_series_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_fillna.py

@@ -0,0 +1,1155 @@
+from datetime import (
+    datetime,
+    timedelta,
+    timezone,
+)
+
+import numpy as np
+import pytest
+import pytz
+
+from pandas import (
+    Categorical,
+    DataFrame,
+    DatetimeIndex,
+    NaT,
+    Period,
+    Series,
+    Timedelta,
+    Timestamp,
+    date_range,
+    isna,
+    timedelta_range,
+)
+import pandas._testing as tm
+from pandas.core.arrays import period_array
+
+
+@pytest.mark.filterwarnings(
+    "ignore:(Series|DataFrame).fillna with 'method' is deprecated:FutureWarning"
+)
+class TestSeriesFillNA:
+    def test_fillna_nat(self):
+        series = Series([0, 1, 2, NaT._value], dtype="M8[ns]")
+
+        filled = series.fillna(method="pad")
+        filled2 = series.fillna(value=series.values[2])
+
+        expected = series.copy()
+        expected.iloc[3] = expected.iloc[2]
+
+        tm.assert_series_equal(filled, expected)
+        tm.assert_series_equal(filled2, expected)
+
+        df = DataFrame({"A": series})
+        filled = df.fillna(method="pad")
+        filled2 = df.fillna(value=series.values[2])
+        expected = DataFrame({"A": expected})
+        tm.assert_frame_equal(filled, expected)
+        tm.assert_frame_equal(filled2, expected)
+
+        series = Series([NaT._value, 0, 1, 2], dtype="M8[ns]")
+
+        filled = series.fillna(method="bfill")
+        filled2 = series.fillna(value=series[1])
+
+        expected = series.copy()
+        expected[0] = expected[1]
+
+        tm.assert_series_equal(filled, expected)
+        tm.assert_series_equal(filled2, expected)
+
+        df = DataFrame({"A": series})
+        filled = df.fillna(method="bfill")
+        filled2 = df.fillna(value=series[1])
+        expected = DataFrame({"A": expected})
+        tm.assert_frame_equal(filled, expected)
+        tm.assert_frame_equal(filled2, expected)
+
+    def test_fillna_value_or_method(self, datetime_series):
+        msg = "Cannot specify both 'value' and 'method'"
+        with pytest.raises(ValueError, match=msg):
+            datetime_series.fillna(value=0, method="ffill")
+
+    def test_fillna(self):
+        ts = Series(
+            [0.0, 1.0, 2.0, 3.0, 4.0], index=date_range("2020-01-01", periods=5)
+        )
+
+        tm.assert_series_equal(ts, ts.fillna(method="ffill"))
+
+        ts.iloc[2] = np.nan
+
+        exp = Series([0.0, 1.0, 1.0, 3.0, 4.0], index=ts.index)
+        tm.assert_series_equal(ts.fillna(method="ffill"), exp)
+
+        exp = Series([0.0, 1.0, 3.0, 3.0, 4.0], index=ts.index)
+        tm.assert_series_equal(ts.fillna(method="backfill"), exp)
+
+        exp = Series([0.0, 1.0, 5.0, 3.0, 4.0], index=ts.index)
+        tm.assert_series_equal(ts.fillna(value=5), exp)
+
+        msg = "Must specify a fill 'value' or 'method'"
+        with pytest.raises(ValueError, match=msg):
+            ts.fillna()
+
+    def test_fillna_nonscalar(self):
+        # GH#5703
+        s1 = Series([np.nan])
+        s2 = Series([1])
+        result = s1.fillna(s2)
+        expected = Series([1.0])
+        tm.assert_series_equal(result, expected)
+        result = s1.fillna({})
+        tm.assert_series_equal(result, s1)
+        result = s1.fillna(Series((), dtype=object))
+        tm.assert_series_equal(result, s1)
+        result = s2.fillna(s1)
+        tm.assert_series_equal(result, s2)
+        result = s1.fillna({0: 1})
+        tm.assert_series_equal(result, expected)
+        result = s1.fillna({1: 1})
+        tm.assert_series_equal(result, Series([np.nan]))
+        result = s1.fillna({0: 1, 1: 1})
+        tm.assert_series_equal(result, expected)
+        result = s1.fillna(Series({0: 1, 1: 1}))
+        tm.assert_series_equal(result, expected)
+        result = s1.fillna(Series({0: 1, 1: 1}, index=[4, 5]))
+        tm.assert_series_equal(result, s1)
+
+    def test_fillna_aligns(self):
+        s1 = Series([0, 1, 2], list("abc"))
+        s2 = Series([0, np.nan, 2], list("bac"))
+        result = s2.fillna(s1)
+        expected = Series([0, 0, 2.0], list("bac"))
+        tm.assert_series_equal(result, expected)
+
+    def test_fillna_limit(self):
+        ser = Series(np.nan, index=[0, 1, 2])
+        result = ser.fillna(999, limit=1)
+        expected = Series([999, np.nan, np.nan], index=[0, 1, 2])
+        tm.assert_series_equal(result, expected)
+
+        result = ser.fillna(999, limit=2)
+        expected = Series([999, 999, np.nan], index=[0, 1, 2])
+        tm.assert_series_equal(result, expected)
+
+    def test_fillna_dont_cast_strings(self):
+        # GH#9043
+        # make sure a string representation of int/float values can be filled
+        # correctly without raising errors or being converted
+        vals = ["0", "1.5", "-0.3"]
+        for val in vals:
+            ser = Series([0, 1, np.nan, np.nan, 4], dtype="float64")
+            result = ser.fillna(val)
+            expected = Series([0, 1, val, val, 4], dtype="object")
+            tm.assert_series_equal(result, expected)
+
+    def test_fillna_consistency(self):
+        # GH#16402
+        # fillna with a tz aware to a tz-naive, should result in object
+
+        ser = Series([Timestamp("20130101"), NaT])
+
+        result = ser.fillna(Timestamp("20130101", tz="US/Eastern"))
+        expected = Series(
+            [Timestamp("20130101"), Timestamp("2013-01-01", tz="US/Eastern")],
+            dtype="object",
+        )
+        tm.assert_series_equal(result, expected)
+
+        result = ser.where([True, False], Timestamp("20130101", tz="US/Eastern"))
+        tm.assert_series_equal(result, expected)
+
+        result = ser.where([True, False], Timestamp("20130101", tz="US/Eastern"))
+        tm.assert_series_equal(result, expected)
+
+        # with a non-datetime
+        result = ser.fillna("foo")
+        expected = Series([Timestamp("20130101"), "foo"])
+        tm.assert_series_equal(result, expected)
+
+        # assignment
+        ser2 = ser.copy()
+        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+            ser2[1] = "foo"
+        tm.assert_series_equal(ser2, expected)
+
+    def test_fillna_downcast(self):
+        # GH#15277
+        # infer int64 from float64
+        ser = Series([1.0, np.nan])
+        msg = "The 'downcast' keyword in fillna is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = ser.fillna(0, downcast="infer")
+        expected = Series([1, 0])
+        tm.assert_series_equal(result, expected)
+
+        # infer int64 from float64 when fillna value is a dict
+        ser = Series([1.0, np.nan])
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = ser.fillna({1: 0}, downcast="infer")
+        expected = Series([1, 0])
+        tm.assert_series_equal(result, expected)
+
+    def test_fillna_downcast_infer_objects_to_numeric(self):
+        # GH#44241 if we have object-dtype, 'downcast="infer"' should
+        #  _actually_ infer
+
+        arr = np.arange(5).astype(object)
+        arr[3] = np.nan
+
+        ser = Series(arr)
+
+        msg = "The 'downcast' keyword in fillna is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = ser.fillna(3, downcast="infer")
+        expected = Series(np.arange(5), dtype=np.int64)
+        tm.assert_series_equal(res, expected)
+
+        msg = "The 'downcast' keyword in ffill is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = ser.ffill(downcast="infer")
+        expected = Series([0, 1, 2, 2, 4], dtype=np.int64)
+        tm.assert_series_equal(res, expected)
+
+        msg = "The 'downcast' keyword in bfill is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = ser.bfill(downcast="infer")
+        expected = Series([0, 1, 2, 4, 4], dtype=np.int64)
+        tm.assert_series_equal(res, expected)
+
+        # with a non-round float present, we will downcast to float64
+        ser[2] = 2.5
+
+        expected = Series([0, 1, 2.5, 3, 4], dtype=np.float64)
+        msg = "The 'downcast' keyword in fillna is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = ser.fillna(3, downcast="infer")
+        tm.assert_series_equal(res, expected)
+
+        msg = "The 'downcast' keyword in ffill is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = ser.ffill(downcast="infer")
+        expected = Series([0, 1, 2.5, 2.5, 4], dtype=np.float64)
+        tm.assert_series_equal(res, expected)
+
+        msg = "The 'downcast' keyword in bfill is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = ser.bfill(downcast="infer")
+        expected = Series([0, 1, 2.5, 4, 4], dtype=np.float64)
+        tm.assert_series_equal(res, expected)
+
+    def test_timedelta_fillna(self, frame_or_series, unit):
+        # GH#3371
+        ser = Series(
+            [
+                Timestamp("20130101"),
+                Timestamp("20130101"),
+                Timestamp("20130102"),
+                Timestamp("20130103 9:01:01"),
+            ],
+            dtype=f"M8[{unit}]",
+        )
+        td = ser.diff()
+        obj = frame_or_series(td).copy()
+
+        # reg fillna
+        result = obj.fillna(Timedelta(seconds=0))
+        expected = Series(
+            [
+                timedelta(0),
+                timedelta(0),
+                timedelta(1),
+                timedelta(days=1, seconds=9 * 3600 + 60 + 1),
+            ],
+            dtype=f"m8[{unit}]",
+        )
+        expected = frame_or_series(expected)
+        tm.assert_equal(result, expected)
+
+        # GH#45746 pre-1.? ints were interpreted as seconds.  then that was
+        #  deprecated and changed to raise. In 2.0 it casts to common dtype,
+        #  consistent with every other dtype's behavior
+        res = obj.fillna(1)
+        expected = obj.astype(object).fillna(1)
+        tm.assert_equal(res, expected)
+
+        result = obj.fillna(Timedelta(seconds=1))
+        expected = Series(
+            [
+                timedelta(seconds=1),
+                timedelta(0),
+                timedelta(1),
+                timedelta(days=1, seconds=9 * 3600 + 60 + 1),
+            ],
+            dtype=f"m8[{unit}]",
+        )
+        expected = frame_or_series(expected)
+        tm.assert_equal(result, expected)
+
+        result = obj.fillna(timedelta(days=1, seconds=1))
+        expected = Series(
+            [
+                timedelta(days=1, seconds=1),
+                timedelta(0),
+                timedelta(1),
+                timedelta(days=1, seconds=9 * 3600 + 60 + 1),
+            ],
+            dtype=f"m8[{unit}]",
+        )
+        expected = frame_or_series(expected)
+        tm.assert_equal(result, expected)
+
+        result = obj.fillna(np.timedelta64(10**9))
+        expected = Series(
+            [
+                timedelta(seconds=1),
+                timedelta(0),
+                timedelta(1),
+                timedelta(days=1, seconds=9 * 3600 + 60 + 1),
+            ],
+            dtype=f"m8[{unit}]",
+        )
+        expected = frame_or_series(expected)
+        tm.assert_equal(result, expected)
+
+        result = obj.fillna(NaT)
+        expected = Series(
+            [
+                NaT,
+                timedelta(0),
+                timedelta(1),
+                timedelta(days=1, seconds=9 * 3600 + 60 + 1),
+            ],
+            dtype=f"m8[{unit}]",
+        )
+        expected = frame_or_series(expected)
+        tm.assert_equal(result, expected)
+
+        # ffill
+        td[2] = np.nan
+        obj = frame_or_series(td).copy()
+        result = obj.ffill()
+        expected = td.fillna(Timedelta(seconds=0))
+        expected[0] = np.nan
+        expected = frame_or_series(expected)
+
+        tm.assert_equal(result, expected)
+
+        # bfill
+        td[2] = np.nan
+        obj = frame_or_series(td)
+        result = obj.bfill()
+        expected = td.fillna(Timedelta(seconds=0))
+        expected[2] = timedelta(days=1, seconds=9 * 3600 + 60 + 1)
+        expected = frame_or_series(expected)
+        tm.assert_equal(result, expected)
+
+    def test_datetime64_fillna(self):
+        ser = Series(
+            [
+                Timestamp("20130101"),
+                Timestamp("20130101"),
+                Timestamp("20130102"),
+                Timestamp("20130103 9:01:01"),
+            ]
+        )
+        ser[2] = np.nan
+
+        # ffill
+        result = ser.ffill()
+        expected = Series(
+            [
+                Timestamp("20130101"),
+                Timestamp("20130101"),
+                Timestamp("20130101"),
+                Timestamp("20130103 9:01:01"),
+            ]
+        )
+        tm.assert_series_equal(result, expected)
+
+        # bfill
+        result = ser.bfill()
+        expected = Series(
+            [
+                Timestamp("20130101"),
+                Timestamp("20130101"),
+                Timestamp("20130103 9:01:01"),
+                Timestamp("20130103 9:01:01"),
+            ]
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "scalar",
+        [
+            False,
+            pytest.param(
+                True,
+                marks=pytest.mark.xfail(
+                    reason="GH#56410 scalar case not yet addressed"
+                ),
+            ),
+        ],
+    )
+    @pytest.mark.parametrize("tz", [None, "UTC"])
+    def test_datetime64_fillna_mismatched_reso_no_rounding(self, tz, scalar):
+        # GH#56410
+        dti = date_range("2016-01-01", periods=3, unit="s", tz=tz)
+        item = Timestamp("2016-02-03 04:05:06.789", tz=tz)
+        vec = date_range(item, periods=3, unit="ms")
+
+        exp_dtype = "M8[ms]" if tz is None else "M8[ms, UTC]"
+        expected = Series([item, dti[1], dti[2]], dtype=exp_dtype)
+
+        ser = Series(dti)
+        ser[0] = NaT
+        ser2 = ser.copy()
+
+        res = ser.fillna(item)
+        res2 = ser2.fillna(Series(vec))
+
+        if scalar:
+            tm.assert_series_equal(res, expected)
+        else:
+            tm.assert_series_equal(res2, expected)
+
+    @pytest.mark.parametrize(
+        "scalar",
+        [
+            False,
+            pytest.param(
+                True,
+                marks=pytest.mark.xfail(
+                    reason="GH#56410 scalar case not yet addressed"
+                ),
+            ),
+        ],
+    )
+    def test_timedelta64_fillna_mismatched_reso_no_rounding(self, scalar):
+        # GH#56410
+        tdi = date_range("2016-01-01", periods=3, unit="s") - Timestamp("1970-01-01")
+        item = Timestamp("2016-02-03 04:05:06.789") - Timestamp("1970-01-01")
+        vec = timedelta_range(item, periods=3, unit="ms")
+
+        expected = Series([item, tdi[1], tdi[2]], dtype="m8[ms]")
+
+        ser = Series(tdi)
+        ser[0] = NaT
+        ser2 = ser.copy()
+
+        res = ser.fillna(item)
+        res2 = ser2.fillna(Series(vec))
+
+        if scalar:
+            tm.assert_series_equal(res, expected)
+        else:
+            tm.assert_series_equal(res2, expected)
+
+    def test_datetime64_fillna_backfill(self):
+        # GH#6587
+        # make sure that we are treating as integer when filling
+        ser = Series([NaT, NaT, "2013-08-05 15:30:00.000001"], dtype="M8[ns]")
+
+        expected = Series(
+            [
+                "2013-08-05 15:30:00.000001",
+                "2013-08-05 15:30:00.000001",
+                "2013-08-05 15:30:00.000001",
+            ],
+            dtype="M8[ns]",
+        )
+        result = ser.fillna(method="backfill")
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", ["US/Eastern", "Asia/Tokyo"])
+    def test_datetime64_tz_fillna(self, tz, unit):
+        # DatetimeLikeBlock
+        ser = Series(
+            [
+                Timestamp("2011-01-01 10:00"),
+                NaT,
+                Timestamp("2011-01-03 10:00"),
+                NaT,
+            ],
+            dtype=f"M8[{unit}]",
+        )
+        null_loc = Series([False, True, False, True])
+
+        result = ser.fillna(Timestamp("2011-01-02 10:00"))
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00"),
+                Timestamp("2011-01-02 10:00"),
+                Timestamp("2011-01-03 10:00"),
+                Timestamp("2011-01-02 10:00"),
+            ],
+            dtype=f"M8[{unit}]",
+        )
+        tm.assert_series_equal(expected, result)
+        # check s is not changed
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna(Timestamp("2011-01-02 10:00", tz=tz))
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00"),
+                Timestamp("2011-01-02 10:00", tz=tz),
+                Timestamp("2011-01-03 10:00"),
+                Timestamp("2011-01-02 10:00", tz=tz),
+            ]
+        )
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna("AAA")
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00"),
+                "AAA",
+                Timestamp("2011-01-03 10:00"),
+                "AAA",
+            ],
+            dtype=object,
+        )
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna(
+            {
+                1: Timestamp("2011-01-02 10:00", tz=tz),
+                3: Timestamp("2011-01-04 10:00"),
+            }
+        )
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00"),
+                Timestamp("2011-01-02 10:00", tz=tz),
+                Timestamp("2011-01-03 10:00"),
+                Timestamp("2011-01-04 10:00"),
+            ]
+        )
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna(
+            {1: Timestamp("2011-01-02 10:00"), 3: Timestamp("2011-01-04 10:00")}
+        )
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00"),
+                Timestamp("2011-01-02 10:00"),
+                Timestamp("2011-01-03 10:00"),
+                Timestamp("2011-01-04 10:00"),
+            ],
+            dtype=f"M8[{unit}]",
+        )
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        # DatetimeTZBlock
+        idx = DatetimeIndex(
+            ["2011-01-01 10:00", NaT, "2011-01-03 10:00", NaT], tz=tz
+        ).as_unit(unit)
+        ser = Series(idx)
+        assert ser.dtype == f"datetime64[{unit}, {tz}]"
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna(Timestamp("2011-01-02 10:00"))
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00", tz=tz),
+                Timestamp("2011-01-02 10:00"),
+                Timestamp("2011-01-03 10:00", tz=tz),
+                Timestamp("2011-01-02 10:00"),
+            ]
+        )
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna(Timestamp("2011-01-02 10:00", tz=tz))
+        idx = DatetimeIndex(
+            [
+                "2011-01-01 10:00",
+                "2011-01-02 10:00",
+                "2011-01-03 10:00",
+                "2011-01-02 10:00",
+            ],
+            tz=tz,
+        ).as_unit(unit)
+        expected = Series(idx)
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna(Timestamp("2011-01-02 10:00", tz=tz).to_pydatetime())
+        idx = DatetimeIndex(
+            [
+                "2011-01-01 10:00",
+                "2011-01-02 10:00",
+                "2011-01-03 10:00",
+                "2011-01-02 10:00",
+            ],
+            tz=tz,
+        ).as_unit(unit)
+        expected = Series(idx)
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna("AAA")
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00", tz=tz),
+                "AAA",
+                Timestamp("2011-01-03 10:00", tz=tz),
+                "AAA",
+            ],
+            dtype=object,
+        )
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna(
+            {
+                1: Timestamp("2011-01-02 10:00", tz=tz),
+                3: Timestamp("2011-01-04 10:00"),
+            }
+        )
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00", tz=tz),
+                Timestamp("2011-01-02 10:00", tz=tz),
+                Timestamp("2011-01-03 10:00", tz=tz),
+                Timestamp("2011-01-04 10:00"),
+            ]
+        )
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna(
+            {
+                1: Timestamp("2011-01-02 10:00", tz=tz),
+                3: Timestamp("2011-01-04 10:00", tz=tz),
+            }
+        )
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00", tz=tz),
+                Timestamp("2011-01-02 10:00", tz=tz),
+                Timestamp("2011-01-03 10:00", tz=tz),
+                Timestamp("2011-01-04 10:00", tz=tz),
+            ]
+        ).dt.as_unit(unit)
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        # filling with a naive/other zone, coerce to object
+        result = ser.fillna(Timestamp("20130101"))
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00", tz=tz),
+                Timestamp("2013-01-01"),
+                Timestamp("2011-01-03 10:00", tz=tz),
+                Timestamp("2013-01-01"),
+            ]
+        )
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        # pre-2.0 fillna with mixed tzs would cast to object, in 2.0
+        #  it retains dtype.
+        result = ser.fillna(Timestamp("20130101", tz="US/Pacific"))
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00", tz=tz),
+                Timestamp("2013-01-01", tz="US/Pacific").tz_convert(tz),
+                Timestamp("2011-01-03 10:00", tz=tz),
+                Timestamp("2013-01-01", tz="US/Pacific").tz_convert(tz),
+            ]
+        ).dt.as_unit(unit)
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+    def test_fillna_dt64tz_with_method(self):
+        # with timezone
+        # GH#15855
+        ser = Series([Timestamp("2012-11-11 00:00:00+01:00"), NaT])
+        exp = Series(
+            [
+                Timestamp("2012-11-11 00:00:00+01:00"),
+                Timestamp("2012-11-11 00:00:00+01:00"),
+            ]
+        )
+        tm.assert_series_equal(ser.fillna(method="pad"), exp)
+
+        ser = Series([NaT, Timestamp("2012-11-11 00:00:00+01:00")])
+        exp = Series(
+            [
+                Timestamp("2012-11-11 00:00:00+01:00"),
+                Timestamp("2012-11-11 00:00:00+01:00"),
+            ]
+        )
+        tm.assert_series_equal(ser.fillna(method="bfill"), exp)
+
+    def test_fillna_pytimedelta(self):
+        # GH#8209
+        ser = Series([np.nan, Timedelta("1 days")], index=["A", "B"])
+
+        result = ser.fillna(timedelta(1))
+        expected = Series(Timedelta("1 days"), index=["A", "B"])
+        tm.assert_series_equal(result, expected)
+
+    def test_fillna_period(self):
+        # GH#13737
+        ser = Series([Period("2011-01", freq="M"), Period("NaT", freq="M")])
+
+        res = ser.fillna(Period("2012-01", freq="M"))
+        exp = Series([Period("2011-01", freq="M"), Period("2012-01", freq="M")])
+        tm.assert_series_equal(res, exp)
+        assert res.dtype == "Period[M]"
+
+    def test_fillna_dt64_timestamp(self, frame_or_series):
+        ser = Series(
+            [
+                Timestamp("20130101"),
+                Timestamp("20130101"),
+                Timestamp("20130102"),
+                Timestamp("20130103 9:01:01"),
+            ]
+        )
+        ser[2] = np.nan
+        obj = frame_or_series(ser)
+
+        # reg fillna
+        result = obj.fillna(Timestamp("20130104"))
+        expected = Series(
+            [
+                Timestamp("20130101"),
+                Timestamp("20130101"),
+                Timestamp("20130104"),
+                Timestamp("20130103 9:01:01"),
+            ]
+        )
+        expected = frame_or_series(expected)
+        tm.assert_equal(result, expected)
+
+        result = obj.fillna(NaT)
+        expected = obj
+        tm.assert_equal(result, expected)
+
+    def test_fillna_dt64_non_nao(self):
+        # GH#27419
+        ser = Series([Timestamp("2010-01-01"), NaT, Timestamp("2000-01-01")])
+        val = np.datetime64("1975-04-05", "ms")
+
+        result = ser.fillna(val)
+        expected = Series(
+            [Timestamp("2010-01-01"), Timestamp("1975-04-05"), Timestamp("2000-01-01")]
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_fillna_numeric_inplace(self):
+        x = Series([np.nan, 1.0, np.nan, 3.0, np.nan], ["z", "a", "b", "c", "d"])
+        y = x.copy()
+
+        return_value = y.fillna(value=0, inplace=True)
+        assert return_value is None
+
+        expected = x.fillna(value=0)
+        tm.assert_series_equal(y, expected)
+
+    # ---------------------------------------------------------------
+    # CategoricalDtype
+
+    @pytest.mark.parametrize(
+        "fill_value, expected_output",
+        [
+            ("a", ["a", "a", "b", "a", "a"]),
+            ({1: "a", 3: "b", 4: "b"}, ["a", "a", "b", "b", "b"]),
+            ({1: "a"}, ["a", "a", "b", np.nan, np.nan]),
+            ({1: "a", 3: "b"}, ["a", "a", "b", "b", np.nan]),
+            (Series("a"), ["a", np.nan, "b", np.nan, np.nan]),
+            (Series("a", index=[1]), ["a", "a", "b", np.nan, np.nan]),
+            (Series({1: "a", 3: "b"}), ["a", "a", "b", "b", np.nan]),
+            (Series(["a", "b"], index=[3, 4]), ["a", np.nan, "b", "a", "b"]),
+        ],
+    )
+    def test_fillna_categorical(self, fill_value, expected_output):
+        # GH#17033
+        # Test fillna for a Categorical series
+        data = ["a", np.nan, "b", np.nan, np.nan]
+        ser = Series(Categorical(data, categories=["a", "b"]))
+        exp = Series(Categorical(expected_output, categories=["a", "b"]))
+        result = ser.fillna(fill_value)
+        tm.assert_series_equal(result, exp)
+
+    @pytest.mark.parametrize(
+        "fill_value, expected_output",
+        [
+            (Series(["a", "b", "c", "d", "e"]), ["a", "b", "b", "d", "e"]),
+            (Series(["b", "d", "a", "d", "a"]), ["a", "d", "b", "d", "a"]),
+            (
+                Series(
+                    Categorical(
+                        ["b", "d", "a", "d", "a"], categories=["b", "c", "d", "e", "a"]
+                    )
+                ),
+                ["a", "d", "b", "d", "a"],
+            ),
+        ],
+    )
+    def test_fillna_categorical_with_new_categories(self, fill_value, expected_output):
+        # GH#26215
+        data = ["a", np.nan, "b", np.nan, np.nan]
+        ser = Series(Categorical(data, categories=["a", "b", "c", "d", "e"]))
+        exp = Series(Categorical(expected_output, categories=["a", "b", "c", "d", "e"]))
+        result = ser.fillna(fill_value)
+        tm.assert_series_equal(result, exp)
+
+    def test_fillna_categorical_raises(self):
+        data = ["a", np.nan, "b", np.nan, np.nan]
+        ser = Series(Categorical(data, categories=["a", "b"]))
+        cat = ser._values
+
+        msg = "Cannot setitem on a Categorical with a new category"
+        with pytest.raises(TypeError, match=msg):
+            ser.fillna("d")
+
+        msg2 = "Length of 'value' does not match."
+        with pytest.raises(ValueError, match=msg2):
+            cat.fillna(Series("d"))
+
+        with pytest.raises(TypeError, match=msg):
+            ser.fillna({1: "d", 3: "a"})
+
+        msg = '"value" parameter must be a scalar or dict, but you passed a "list"'
+        with pytest.raises(TypeError, match=msg):
+            ser.fillna(["a", "b"])
+
+        msg = '"value" parameter must be a scalar or dict, but you passed a "tuple"'
+        with pytest.raises(TypeError, match=msg):
+            ser.fillna(("a", "b"))
+
+        msg = (
+            '"value" parameter must be a scalar, dict '
+            'or Series, but you passed a "DataFrame"'
+        )
+        with pytest.raises(TypeError, match=msg):
+            ser.fillna(DataFrame({1: ["a"], 3: ["b"]}))
+
+    @pytest.mark.parametrize("dtype", [float, "float32", "float64"])
+    @pytest.mark.parametrize("fill_type", tm.ALL_REAL_NUMPY_DTYPES)
+    @pytest.mark.parametrize("scalar", [True, False])
+    def test_fillna_float_casting(self, dtype, fill_type, scalar):
+        # GH-43424
+        ser = Series([np.nan, 1.2], dtype=dtype)
+        fill_values = Series([2, 2], dtype=fill_type)
+        if scalar:
+            fill_values = fill_values.dtype.type(2)
+
+        result = ser.fillna(fill_values)
+        expected = Series([2.0, 1.2], dtype=dtype)
+        tm.assert_series_equal(result, expected)
+
+        ser = Series([np.nan, 1.2], dtype=dtype)
+        mask = ser.isna().to_numpy()
+        ser[mask] = fill_values
+        tm.assert_series_equal(ser, expected)
+
+        ser = Series([np.nan, 1.2], dtype=dtype)
+        ser.mask(mask, fill_values, inplace=True)
+        tm.assert_series_equal(ser, expected)
+
+        ser = Series([np.nan, 1.2], dtype=dtype)
+        res = ser.where(~mask, fill_values)
+        tm.assert_series_equal(res, expected)
+
+    def test_fillna_f32_upcast_with_dict(self):
+        # GH-43424
+        ser = Series([np.nan, 1.2], dtype=np.float32)
+        result = ser.fillna({0: 1})
+        expected = Series([1.0, 1.2], dtype=np.float32)
+        tm.assert_series_equal(result, expected)
+
+    # ---------------------------------------------------------------
+    # Invalid Usages
+
+    def test_fillna_invalid_method(self, datetime_series):
+        try:
+            datetime_series.fillna(method="ffil")
+        except ValueError as inst:
+            assert "ffil" in str(inst)
+
+    def test_fillna_listlike_invalid(self):
+        ser = Series(np.random.default_rng(2).integers(-100, 100, 50))
+        msg = '"value" parameter must be a scalar or dict, but you passed a "list"'
+        with pytest.raises(TypeError, match=msg):
+            ser.fillna([1, 2])
+
+        msg = '"value" parameter must be a scalar or dict, but you passed a "tuple"'
+        with pytest.raises(TypeError, match=msg):
+            ser.fillna((1, 2))
+
+    def test_fillna_method_and_limit_invalid(self):
+        # related GH#9217, make sure limit is an int and greater than 0
+        ser = Series([1, 2, 3, None])
+        msg = "|".join(
+            [
+                r"Cannot specify both 'value' and 'method'\.",
+                "Limit must be greater than 0",
+                "Limit must be an integer",
+            ]
+        )
+        for limit in [-1, 0, 1.0, 2.0]:
+            for method in ["backfill", "bfill", "pad", "ffill", None]:
+                with pytest.raises(ValueError, match=msg):
+                    ser.fillna(1, limit=limit, method=method)
+
+    def test_fillna_datetime64_with_timezone_tzinfo(self):
+        # https://github.com/pandas-dev/pandas/issues/38851
+        # different tzinfos representing UTC treated as equal
+        ser = Series(date_range("2020", periods=3, tz="UTC"))
+        expected = ser.copy()
+        ser[1] = NaT
+        result = ser.fillna(datetime(2020, 1, 2, tzinfo=timezone.utc))
+        tm.assert_series_equal(result, expected)
+
+        # pre-2.0 we cast to object with mixed tzs, in 2.0 we retain dtype
+        ts = Timestamp("2000-01-01", tz="US/Pacific")
+        ser2 = Series(ser._values.tz_convert("dateutil/US/Pacific"))
+        assert ser2.dtype.kind == "M"
+        result = ser2.fillna(ts)
+        expected = Series(
+            [ser2[0], ts.tz_convert(ser2.dtype.tz), ser2[2]],
+            dtype=ser2.dtype,
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "input, input_fillna, expected_data, expected_categories",
+        [
+            (["A", "B", None, "A"], "B", ["A", "B", "B", "A"], ["A", "B"]),
+            (["A", "B", np.nan, "A"], "B", ["A", "B", "B", "A"], ["A", "B"]),
+        ],
+    )
+    def test_fillna_categorical_accept_same_type(
+        self, input, input_fillna, expected_data, expected_categories
+    ):
+        # GH32414
+        cat = Categorical(input)
+        ser = Series(cat).fillna(input_fillna)
+        filled = cat.fillna(ser)
+        result = cat.fillna(filled)
+        expected = Categorical(expected_data, categories=expected_categories)
+        tm.assert_categorical_equal(result, expected)
+
+
+@pytest.mark.filterwarnings(
+    "ignore:Series.fillna with 'method' is deprecated:FutureWarning"
+)
+class TestFillnaPad:
+    def test_fillna_bug(self):
+        ser = Series([np.nan, 1.0, np.nan, 3.0, np.nan], ["z", "a", "b", "c", "d"])
+        filled = ser.fillna(method="ffill")
+        expected = Series([np.nan, 1.0, 1.0, 3.0, 3.0], ser.index)
+        tm.assert_series_equal(filled, expected)
+
+        filled = ser.fillna(method="bfill")
+        expected = Series([1.0, 1.0, 3.0, 3.0, np.nan], ser.index)
+        tm.assert_series_equal(filled, expected)
+
+    def test_ffill(self):
+        ts = Series(
+            [0.0, 1.0, 2.0, 3.0, 4.0], index=date_range("2020-01-01", periods=5)
+        )
+        ts.iloc[2] = np.nan
+        tm.assert_series_equal(ts.ffill(), ts.fillna(method="ffill"))
+
+    def test_ffill_mixed_dtypes_without_missing_data(self):
+        # GH#14956
+        series = Series([datetime(2015, 1, 1, tzinfo=pytz.utc), 1])
+        result = series.ffill()
+        tm.assert_series_equal(series, result)
+
+    def test_bfill(self):
+        ts = Series(
+            [0.0, 1.0, 2.0, 3.0, 4.0], index=date_range("2020-01-01", periods=5)
+        )
+        ts.iloc[2] = np.nan
+        tm.assert_series_equal(ts.bfill(), ts.fillna(method="bfill"))
+
+    def test_pad_nan(self):
+        x = Series(
+            [np.nan, 1.0, np.nan, 3.0, np.nan], ["z", "a", "b", "c", "d"], dtype=float
+        )
+
+        return_value = x.fillna(method="pad", inplace=True)
+        assert return_value is None
+
+        expected = Series(
+            [np.nan, 1.0, 1.0, 3.0, 3.0], ["z", "a", "b", "c", "d"], dtype=float
+        )
+        tm.assert_series_equal(x[1:], expected[1:])
+        assert np.isnan(x.iloc[0]), np.isnan(expected.iloc[0])
+
+    def test_series_fillna_limit(self):
+        index = np.arange(10)
+        s = Series(np.random.default_rng(2).standard_normal(10), index=index)
+
+        result = s[:2].reindex(index)
+        result = result.fillna(method="pad", limit=5)
+
+        expected = s[:2].reindex(index).fillna(method="pad")
+        expected[-3:] = np.nan
+        tm.assert_series_equal(result, expected)
+
+        result = s[-2:].reindex(index)
+        result = result.fillna(method="bfill", limit=5)
+
+        expected = s[-2:].reindex(index).fillna(method="backfill")
+        expected[:3] = np.nan
+        tm.assert_series_equal(result, expected)
+
+    def test_series_pad_backfill_limit(self):
+        index = np.arange(10)
+        s = Series(np.random.default_rng(2).standard_normal(10), index=index)
+
+        result = s[:2].reindex(index, method="pad", limit=5)
+
+        expected = s[:2].reindex(index).fillna(method="pad")
+        expected[-3:] = np.nan
+        tm.assert_series_equal(result, expected)
+
+        result = s[-2:].reindex(index, method="backfill", limit=5)
+
+        expected = s[-2:].reindex(index).fillna(method="backfill")
+        expected[:3] = np.nan
+        tm.assert_series_equal(result, expected)
+
+    def test_fillna_int(self):
+        ser = Series(np.random.default_rng(2).integers(-100, 100, 50))
+        return_value = ser.fillna(method="ffill", inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(ser.fillna(method="ffill", inplace=False), ser)
+
+    def test_datetime64tz_fillna_round_issue(self):
+        # GH#14872
+
+        data = Series(
+            [NaT, NaT, datetime(2016, 12, 12, 22, 24, 6, 100001, tzinfo=pytz.utc)]
+        )
+
+        filled = data.bfill()
+
+        expected = Series(
+            [
+                datetime(2016, 12, 12, 22, 24, 6, 100001, tzinfo=pytz.utc),
+                datetime(2016, 12, 12, 22, 24, 6, 100001, tzinfo=pytz.utc),
+                datetime(2016, 12, 12, 22, 24, 6, 100001, tzinfo=pytz.utc),
+            ]
+        )
+
+        tm.assert_series_equal(filled, expected)
+
+    def test_fillna_parr(self):
+        # GH-24537
+        dti = date_range(
+            Timestamp.max - Timedelta(nanoseconds=10), periods=5, freq="ns"
+        )
+        ser = Series(dti.to_period("ns"))
+        ser[2] = NaT
+        arr = period_array(
+            [
+                Timestamp("2262-04-11 23:47:16.854775797"),
+                Timestamp("2262-04-11 23:47:16.854775798"),
+                Timestamp("2262-04-11 23:47:16.854775798"),
+                Timestamp("2262-04-11 23:47:16.854775800"),
+                Timestamp("2262-04-11 23:47:16.854775801"),
+            ],
+            freq="ns",
+        )
+        expected = Series(arr)
+
+        filled = ser.ffill()
+
+        tm.assert_series_equal(filled, expected)
+
+    @pytest.mark.parametrize("func", ["pad", "backfill"])
+    def test_pad_backfill_deprecated(self, func):
+        # GH#33396
+        ser = Series([1, 2, 3])
+        with tm.assert_produces_warning(FutureWarning):
+            getattr(ser, func)()
+
+
+@pytest.mark.parametrize(
+    "data, expected_data, method, kwargs",
+    (
+        (
+            [np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
+            [np.nan, np.nan, 3.0, 3.0, 3.0, 3.0, 7.0, np.nan, np.nan],
+            "ffill",
+            {"limit_area": "inside"},
+        ),
+        (
+            [np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
+            [np.nan, np.nan, 3.0, 3.0, np.nan, np.nan, 7.0, np.nan, np.nan],
+            "ffill",
+            {"limit_area": "inside", "limit": 1},
+        ),
+        (
+            [np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
+            [np.nan, np.nan, 3.0, np.nan, np.nan, np.nan, 7.0, 7.0, 7.0],
+            "ffill",
+            {"limit_area": "outside"},
+        ),
+        (
+            [np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
+            [np.nan, np.nan, 3.0, np.nan, np.nan, np.nan, 7.0, 7.0, np.nan],
+            "ffill",
+            {"limit_area": "outside", "limit": 1},
+        ),
+        (
+            [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
+            [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
+            "ffill",
+            {"limit_area": "outside", "limit": 1},
+        ),
+        (
+            range(5),
+            range(5),
+            "ffill",
+            {"limit_area": "outside", "limit": 1},
+        ),
+        (
+            [np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
+            [np.nan, np.nan, 3.0, 7.0, 7.0, 7.0, 7.0, np.nan, np.nan],
+            "bfill",
+            {"limit_area": "inside"},
+        ),
+        (
+            [np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
+            [np.nan, np.nan, 3.0, np.nan, np.nan, 7.0, 7.0, np.nan, np.nan],
+            "bfill",
+            {"limit_area": "inside", "limit": 1},
+        ),
+        (
+            [np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
+            [3.0, 3.0, 3.0, np.nan, np.nan, np.nan, 7.0, np.nan, np.nan],
+            "bfill",
+            {"limit_area": "outside"},
+        ),
+        (
+            [np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
+            [np.nan, 3.0, 3.0, np.nan, np.nan, np.nan, 7.0, np.nan, np.nan],
+            "bfill",
+            {"limit_area": "outside", "limit": 1},
+        ),
+    ),
+)
+def test_ffill_bfill_limit_area(data, expected_data, method, kwargs):
+    # GH#56492
+    s = Series(data)
+    expected = Series(expected_data)
+    result = getattr(s, method)(**kwargs)
+    tm.assert_series_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_infer_objects.py

@@ -0,0 +1,56 @@
+import numpy as np
+
+from pandas import (
+    Series,
+    interval_range,
+)
+import pandas._testing as tm
+
+
+class TestInferObjects:
+    def test_copy(self, index_or_series):
+        # GH#50096
+        # case where we don't need to do inference because it is already non-object
+        obj = index_or_series(np.array([1, 2, 3], dtype="int64"))
+
+        result = obj.infer_objects(copy=False)
+        assert tm.shares_memory(result, obj)
+
+        # case where we try to do inference but can't do better than object
+        obj2 = index_or_series(np.array(["foo", 2], dtype=object))
+        result2 = obj2.infer_objects(copy=False)
+        assert tm.shares_memory(result2, obj2)
+
+    def test_infer_objects_series(self, index_or_series):
+        # GH#11221
+        actual = index_or_series(np.array([1, 2, 3], dtype="O")).infer_objects()
+        expected = index_or_series([1, 2, 3])
+        tm.assert_equal(actual, expected)
+
+        actual = index_or_series(np.array([1, 2, 3, None], dtype="O")).infer_objects()
+        expected = index_or_series([1.0, 2.0, 3.0, np.nan])
+        tm.assert_equal(actual, expected)
+
+        # only soft conversions, unconvertible pass thru unchanged
+
+        obj = index_or_series(np.array([1, 2, 3, None, "a"], dtype="O"))
+        actual = obj.infer_objects()
+        expected = index_or_series([1, 2, 3, None, "a"], dtype=object)
+
+        assert actual.dtype == "object"
+        tm.assert_equal(actual, expected)
+
+    def test_infer_objects_interval(self, index_or_series):
+        # GH#50090
+        ii = interval_range(1, 10)
+        obj = index_or_series(ii)
+
+        result = obj.astype(object).infer_objects()
+        tm.assert_equal(result, obj)
+
+    def test_infer_objects_bytes(self):
+        # GH#49650
+        ser = Series([b"a"], dtype="bytes")
+        expected = ser.copy()
+        result = ser.infer_objects()
+        tm.assert_series_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_info.py

@@ -0,0 +1,181 @@
+from io import StringIO
+from string import ascii_uppercase
+import textwrap
+
+import numpy as np
+import pytest
+
+from pandas.compat import PYPY
+
+from pandas import (
+    CategoricalIndex,
+    MultiIndex,
+    Series,
+    date_range,
+)
+
+
+def test_info_categorical_column_just_works():
+    n = 2500
+    data = np.array(list("abcdefghij")).take(
+        np.random.default_rng(2).integers(0, 10, size=n, dtype=int)
+    )
+    s = Series(data).astype("category")
+    s.isna()
+    buf = StringIO()
+    s.info(buf=buf)
+
+    s2 = s[s == "d"]
+    buf = StringIO()
+    s2.info(buf=buf)
+
+
+def test_info_categorical():
+    # GH14298
+    idx = CategoricalIndex(["a", "b"])
+    s = Series(np.zeros(2), index=idx)
+    buf = StringIO()
+    s.info(buf=buf)
+
+
+@pytest.mark.parametrize("verbose", [True, False])
+def test_info_series(lexsorted_two_level_string_multiindex, verbose):
+    index = lexsorted_two_level_string_multiindex
+    ser = Series(range(len(index)), index=index, name="sth")
+    buf = StringIO()
+    ser.info(verbose=verbose, buf=buf)
+    result = buf.getvalue()
+
+    expected = textwrap.dedent(
+        """\
+        <class 'pandas.core.series.Series'>
+        MultiIndex: 10 entries, ('foo', 'one') to ('qux', 'three')
+        """
+    )
+    if verbose:
+        expected += textwrap.dedent(
+            """\
+            Series name: sth
+            Non-Null Count  Dtype
+            --------------  -----
+            10 non-null     int64
+            """
+        )
+    expected += textwrap.dedent(
+        f"""\
+        dtypes: int64(1)
+        memory usage: {ser.memory_usage()}.0+ bytes
+        """
+    )
+    assert result == expected
+
+
+def test_info_memory():
+    s = Series([1, 2], dtype="i8")
+    buf = StringIO()
+    s.info(buf=buf)
+    result = buf.getvalue()
+    memory_bytes = float(s.memory_usage())
+    expected = textwrap.dedent(
+        f"""\
+    <class 'pandas.core.series.Series'>
+    RangeIndex: 2 entries, 0 to 1
+    Series name: None
+    Non-Null Count  Dtype
+    --------------  -----
+    2 non-null      int64
+    dtypes: int64(1)
+    memory usage: {memory_bytes} bytes
+    """
+    )
+    assert result == expected
+
+
+def test_info_wide():
+    s = Series(np.random.default_rng(2).standard_normal(101))
+    msg = "Argument `max_cols` can only be passed in DataFrame.info, not Series.info"
+    with pytest.raises(ValueError, match=msg):
+        s.info(max_cols=1)
+
+
+def test_info_shows_dtypes():
+    dtypes = [
+        "int64",
+        "float64",
+        "datetime64[ns]",
+        "timedelta64[ns]",
+        "complex128",
+        "object",
+        "bool",
+    ]
+    n = 10
+    for dtype in dtypes:
+        s = Series(np.random.default_rng(2).integers(2, size=n).astype(dtype))
+        buf = StringIO()
+        s.info(buf=buf)
+        res = buf.getvalue()
+        name = f"{n:d} non-null     {dtype}"
+        assert name in res
+
+
+@pytest.mark.xfail(PYPY, reason="on PyPy deep=True doesn't change result")
+def test_info_memory_usage_deep_not_pypy():
+    s_with_object_index = Series({"a": [1]}, index=["foo"])
+    assert s_with_object_index.memory_usage(
+        index=True, deep=True
+    ) > s_with_object_index.memory_usage(index=True)
+
+    s_object = Series({"a": ["a"]})
+    assert s_object.memory_usage(deep=True) > s_object.memory_usage()
+
+
+@pytest.mark.xfail(not PYPY, reason="on PyPy deep=True does not change result")
+def test_info_memory_usage_deep_pypy():
+    s_with_object_index = Series({"a": [1]}, index=["foo"])
+    assert s_with_object_index.memory_usage(
+        index=True, deep=True
+    ) == s_with_object_index.memory_usage(index=True)
+
+    s_object = Series({"a": ["a"]})
+    assert s_object.memory_usage(deep=True) == s_object.memory_usage()
+
+
+@pytest.mark.parametrize(
+    "series, plus",
+    [
+        (Series(1, index=[1, 2, 3]), False),
+        (Series(1, index=list("ABC")), True),
+        (Series(1, index=MultiIndex.from_product([range(3), range(3)])), False),
+        (
+            Series(1, index=MultiIndex.from_product([range(3), ["foo", "bar"]])),
+            True,
+        ),
+    ],
+)
+def test_info_memory_usage_qualified(series, plus):
+    buf = StringIO()
+    series.info(buf=buf)
+    if plus:
+        assert "+" in buf.getvalue()
+    else:
+        assert "+" not in buf.getvalue()
+
+
+def test_info_memory_usage_bug_on_multiindex():
+    # GH 14308
+    # memory usage introspection should not materialize .values
+    N = 100
+    M = len(ascii_uppercase)
+    index = MultiIndex.from_product(
+        [list(ascii_uppercase), date_range("20160101", periods=N)],
+        names=["id", "date"],
+    )
+    s = Series(np.random.default_rng(2).standard_normal(N * M), index=index)
+
+    unstacked = s.unstack("id")
+    assert s.values.nbytes == unstacked.values.nbytes
+    assert s.memory_usage(deep=True) > unstacked.memory_usage(deep=True).sum()
+
+    # high upper bound
+    diff = unstacked.memory_usage(deep=True).sum() - s.memory_usage(deep=True)
+    assert diff < 2000

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_is_monotonic.py

@@ -0,0 +1,26 @@
+import numpy as np
+
+from pandas import (
+    Series,
+    date_range,
+)
+
+
+class TestIsMonotonic:
+    def test_is_monotonic_numeric(self):
+        ser = Series(np.random.default_rng(2).integers(0, 10, size=1000))
+        assert not ser.is_monotonic_increasing
+        ser = Series(np.arange(1000))
+        assert ser.is_monotonic_increasing is True
+        assert ser.is_monotonic_increasing is True
+        ser = Series(np.arange(1000, 0, -1))
+        assert ser.is_monotonic_decreasing is True
+
+    def test_is_monotonic_dt64(self):
+        ser = Series(date_range("20130101", periods=10))
+        assert ser.is_monotonic_increasing is True
+        assert ser.is_monotonic_increasing is True
+
+        ser = Series(list(reversed(ser)))
+        assert ser.is_monotonic_increasing is False
+        assert ser.is_monotonic_decreasing is True

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_isna.py

@@ -0,0 +1,35 @@
+"""
+We also test Series.notna in this file.
+"""
+import numpy as np
+
+from pandas import (
+    Period,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestIsna:
+    def test_isna_period_dtype(self):
+        # GH#13737
+        ser = Series([Period("2011-01", freq="M"), Period("NaT", freq="M")])
+
+        expected = Series([False, True])
+
+        result = ser.isna()
+        tm.assert_series_equal(result, expected)
+
+        result = ser.notna()
+        tm.assert_series_equal(result, ~expected)
+
+    def test_isna(self):
+        ser = Series([0, 5.4, 3, np.nan, -0.001])
+        expected = Series([False, False, False, True, False])
+        tm.assert_series_equal(ser.isna(), expected)
+        tm.assert_series_equal(ser.notna(), ~expected)
+
+        ser = Series(["hi", "", np.nan])
+        expected = Series([False, False, True])
+        tm.assert_series_equal(ser.isna(), expected)
+        tm.assert_series_equal(ser.notna(), ~expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_item.py

@@ -0,0 +1,59 @@
+"""
+Series.item method, mainly testing that we get python scalars as opposed to
+numpy scalars.
+"""
+import pytest
+
+from pandas import (
+    Series,
+    Timedelta,
+    Timestamp,
+    date_range,
+)
+
+
+class TestItem:
+    def test_item(self):
+        # We are testing that we get python scalars as opposed to numpy scalars
+        ser = Series([1])
+        result = ser.item()
+        assert result == 1
+        assert result == ser.iloc[0]
+        assert isinstance(result, int)  # i.e. not np.int64
+
+        ser = Series([0.5], index=[3])
+        result = ser.item()
+        assert isinstance(result, float)
+        assert result == 0.5
+
+        ser = Series([1, 2])
+        msg = "can only convert an array of size 1"
+        with pytest.raises(ValueError, match=msg):
+            ser.item()
+
+        dti = date_range("2016-01-01", periods=2)
+        with pytest.raises(ValueError, match=msg):
+            dti.item()
+        with pytest.raises(ValueError, match=msg):
+            Series(dti).item()
+
+        val = dti[:1].item()
+        assert isinstance(val, Timestamp)
+        val = Series(dti)[:1].item()
+        assert isinstance(val, Timestamp)
+
+        tdi = dti - dti
+        with pytest.raises(ValueError, match=msg):
+            tdi.item()
+        with pytest.raises(ValueError, match=msg):
+            Series(tdi).item()
+
+        val = tdi[:1].item()
+        assert isinstance(val, Timedelta)
+        val = Series(tdi)[:1].item()
+        assert isinstance(val, Timedelta)
+
+        # Case where ser[0] would not work
+        ser = Series(dti, index=[5, 6])
+        val = ser.iloc[:1].item()
+        assert val == dti[0]

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_nlargest.py

@@ -0,0 +1,248 @@
+"""
+Note: for naming purposes, most tests are title with as e.g. "test_nlargest_foo"
+but are implicitly also testing nsmallest_foo.
+"""
+from itertools import product
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import Series
+import pandas._testing as tm
+
+main_dtypes = [
+    "datetime",
+    "datetimetz",
+    "timedelta",
+    "int8",
+    "int16",
+    "int32",
+    "int64",
+    "float32",
+    "float64",
+    "uint8",
+    "uint16",
+    "uint32",
+    "uint64",
+]
+
+
+@pytest.fixture
+def s_main_dtypes():
+    """
+    A DataFrame with many dtypes
+
+    * datetime
+    * datetimetz
+    * timedelta
+    * [u]int{8,16,32,64}
+    * float{32,64}
+
+    The columns are the name of the dtype.
+    """
+    df = pd.DataFrame(
+        {
+            "datetime": pd.to_datetime(["2003", "2002", "2001", "2002", "2005"]),
+            "datetimetz": pd.to_datetime(
+                ["2003", "2002", "2001", "2002", "2005"]
+            ).tz_localize("US/Eastern"),
+            "timedelta": pd.to_timedelta(["3d", "2d", "1d", "2d", "5d"]),
+        }
+    )
+
+    for dtype in [
+        "int8",
+        "int16",
+        "int32",
+        "int64",
+        "float32",
+        "float64",
+        "uint8",
+        "uint16",
+        "uint32",
+        "uint64",
+    ]:
+        df[dtype] = Series([3, 2, 1, 2, 5], dtype=dtype)
+
+    return df
+
+
+@pytest.fixture(params=main_dtypes)
+def s_main_dtypes_split(request, s_main_dtypes):
+    """Each series in s_main_dtypes."""
+    return s_main_dtypes[request.param]
+
+
+def assert_check_nselect_boundary(vals, dtype, method):
+    # helper function for 'test_boundary_{dtype}' tests
+    ser = Series(vals, dtype=dtype)
+    result = getattr(ser, method)(3)
+    expected_idxr = [0, 1, 2] if method == "nsmallest" else [3, 2, 1]
+    expected = ser.loc[expected_idxr]
+    tm.assert_series_equal(result, expected)
+
+
+class TestSeriesNLargestNSmallest:
+    @pytest.mark.parametrize(
+        "r",
+        [
+            Series([3.0, 2, 1, 2, "5"], dtype="object"),
+            Series([3.0, 2, 1, 2, 5], dtype="object"),
+            # not supported on some archs
+            # Series([3., 2, 1, 2, 5], dtype='complex256'),
+            Series([3.0, 2, 1, 2, 5], dtype="complex128"),
+            Series(list("abcde")),
+            Series(list("abcde"), dtype="category"),
+        ],
+    )
+    def test_nlargest_error(self, r):
+        dt = r.dtype
+        msg = f"Cannot use method 'n(largest|smallest)' with dtype {dt}"
+        args = 2, len(r), 0, -1
+        methods = r.nlargest, r.nsmallest
+        for method, arg in product(methods, args):
+            with pytest.raises(TypeError, match=msg):
+                method(arg)
+
+    def test_nsmallest_nlargest(self, s_main_dtypes_split):
+        # float, int, datetime64 (use i8), timedelts64 (same),
+        # object that are numbers, object that are strings
+        ser = s_main_dtypes_split
+
+        tm.assert_series_equal(ser.nsmallest(2), ser.iloc[[2, 1]])
+        tm.assert_series_equal(ser.nsmallest(2, keep="last"), ser.iloc[[2, 3]])
+
+        empty = ser.iloc[0:0]
+        tm.assert_series_equal(ser.nsmallest(0), empty)
+        tm.assert_series_equal(ser.nsmallest(-1), empty)
+        tm.assert_series_equal(ser.nlargest(0), empty)
+        tm.assert_series_equal(ser.nlargest(-1), empty)
+
+        tm.assert_series_equal(ser.nsmallest(len(ser)), ser.sort_values())
+        tm.assert_series_equal(ser.nsmallest(len(ser) + 1), ser.sort_values())
+        tm.assert_series_equal(ser.nlargest(len(ser)), ser.iloc[[4, 0, 1, 3, 2]])
+        tm.assert_series_equal(ser.nlargest(len(ser) + 1), ser.iloc[[4, 0, 1, 3, 2]])
+
+    def test_nlargest_misc(self):
+        ser = Series([3.0, np.nan, 1, 2, 5])
+        result = ser.nlargest()
+        expected = ser.iloc[[4, 0, 3, 2, 1]]
+        tm.assert_series_equal(result, expected)
+        result = ser.nsmallest()
+        expected = ser.iloc[[2, 3, 0, 4, 1]]
+        tm.assert_series_equal(result, expected)
+
+        msg = 'keep must be either "first", "last"'
+        with pytest.raises(ValueError, match=msg):
+            ser.nsmallest(keep="invalid")
+        with pytest.raises(ValueError, match=msg):
+            ser.nlargest(keep="invalid")
+
+        # GH#15297
+        ser = Series([1] * 5, index=[1, 2, 3, 4, 5])
+        expected_first = Series([1] * 3, index=[1, 2, 3])
+        expected_last = Series([1] * 3, index=[5, 4, 3])
+
+        result = ser.nsmallest(3)
+        tm.assert_series_equal(result, expected_first)
+
+        result = ser.nsmallest(3, keep="last")
+        tm.assert_series_equal(result, expected_last)
+
+        result = ser.nlargest(3)
+        tm.assert_series_equal(result, expected_first)
+
+        result = ser.nlargest(3, keep="last")
+        tm.assert_series_equal(result, expected_last)
+
+    @pytest.mark.parametrize("n", range(1, 5))
+    def test_nlargest_n(self, n):
+        # GH 13412
+        ser = Series([1, 4, 3, 2], index=[0, 0, 1, 1])
+        result = ser.nlargest(n)
+        expected = ser.sort_values(ascending=False).head(n)
+        tm.assert_series_equal(result, expected)
+
+        result = ser.nsmallest(n)
+        expected = ser.sort_values().head(n)
+        tm.assert_series_equal(result, expected)
+
+    def test_nlargest_boundary_integer(self, nselect_method, any_int_numpy_dtype):
+        # GH#21426
+        dtype_info = np.iinfo(any_int_numpy_dtype)
+        min_val, max_val = dtype_info.min, dtype_info.max
+        vals = [min_val, min_val + 1, max_val - 1, max_val]
+        assert_check_nselect_boundary(vals, any_int_numpy_dtype, nselect_method)
+
+    def test_nlargest_boundary_float(self, nselect_method, float_numpy_dtype):
+        # GH#21426
+        dtype_info = np.finfo(float_numpy_dtype)
+        min_val, max_val = dtype_info.min, dtype_info.max
+        min_2nd, max_2nd = np.nextafter([min_val, max_val], 0, dtype=float_numpy_dtype)
+        vals = [min_val, min_2nd, max_2nd, max_val]
+        assert_check_nselect_boundary(vals, float_numpy_dtype, nselect_method)
+
+    @pytest.mark.parametrize("dtype", ["datetime64[ns]", "timedelta64[ns]"])
+    def test_nlargest_boundary_datetimelike(self, nselect_method, dtype):
+        # GH#21426
+        # use int64 bounds and +1 to min_val since true minimum is NaT
+        # (include min_val/NaT at end to maintain same expected_idxr)
+        dtype_info = np.iinfo("int64")
+        min_val, max_val = dtype_info.min, dtype_info.max
+        vals = [min_val + 1, min_val + 2, max_val - 1, max_val, min_val]
+        assert_check_nselect_boundary(vals, dtype, nselect_method)
+
+    def test_nlargest_duplicate_keep_all_ties(self):
+        # see GH#16818
+        ser = Series([10, 9, 8, 7, 7, 7, 7, 6])
+        result = ser.nlargest(4, keep="all")
+        expected = Series([10, 9, 8, 7, 7, 7, 7])
+        tm.assert_series_equal(result, expected)
+
+        result = ser.nsmallest(2, keep="all")
+        expected = Series([6, 7, 7, 7, 7], index=[7, 3, 4, 5, 6])
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "data,expected", [([True, False], [True]), ([True, False, True, True], [True])]
+    )
+    def test_nlargest_boolean(self, data, expected):
+        # GH#26154 : ensure True > False
+        ser = Series(data)
+        result = ser.nlargest(1)
+        expected = Series(expected)
+        tm.assert_series_equal(result, expected)
+
+    def test_nlargest_nullable(self, any_numeric_ea_dtype):
+        # GH#42816
+        dtype = any_numeric_ea_dtype
+        if dtype.startswith("UInt"):
+            # Can't cast from negative float to uint on some platforms
+            arr = np.random.default_rng(2).integers(1, 10, 10)
+        else:
+            arr = np.random.default_rng(2).standard_normal(10)
+        arr = arr.astype(dtype.lower(), copy=False)
+
+        ser = Series(arr.copy(), dtype=dtype)
+        ser[1] = pd.NA
+        result = ser.nlargest(5)
+
+        expected = (
+            Series(np.delete(arr, 1), index=ser.index.delete(1))
+            .nlargest(5)
+            .astype(dtype)
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_nsmallest_nan_when_keep_is_all(self):
+        # GH#46589
+        s = Series([1, 2, 3, 3, 3, None])
+        result = s.nsmallest(3, keep="all")
+        expected = Series([1.0, 2.0, 3.0, 3.0, 3.0])
+        tm.assert_series_equal(result, expected)
+
+        s = Series([1, 2, None, None, None])
+        result = s.nsmallest(3, keep="all")
+        expected = Series([1, 2, None, None, None])
+        tm.assert_series_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_nunique.py

@@ -0,0 +1,24 @@
+import numpy as np
+
+from pandas import (
+    Categorical,
+    Series,
+)
+
+
+def test_nunique():
+    # basics.rst doc example
+    series = Series(np.random.default_rng(2).standard_normal(500))
+    series[20:500] = np.nan
+    series[10:20] = 5000
+    result = series.nunique()
+    assert result == 11
+
+
+def test_nunique_categorical():
+    # GH#18051
+    ser = Series(Categorical([]))
+    assert ser.nunique() == 0
+
+    ser = Series(Categorical([np.nan]))
+    assert ser.nunique() == 0

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_pct_change.py

@@ -0,0 +1,128 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestSeriesPctChange:
+    def test_pct_change(self, datetime_series):
+        msg = (
+            "The 'fill_method' keyword being not None and the 'limit' keyword in "
+            "Series.pct_change are deprecated"
+        )
+
+        rs = datetime_series.pct_change(fill_method=None)
+        tm.assert_series_equal(rs, datetime_series / datetime_series.shift(1) - 1)
+
+        rs = datetime_series.pct_change(2)
+        filled = datetime_series.ffill()
+        tm.assert_series_equal(rs, filled / filled.shift(2) - 1)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs = datetime_series.pct_change(fill_method="bfill", limit=1)
+        filled = datetime_series.bfill(limit=1)
+        tm.assert_series_equal(rs, filled / filled.shift(1) - 1)
+
+        rs = datetime_series.pct_change(freq="5D")
+        filled = datetime_series.ffill()
+        tm.assert_series_equal(
+            rs, (filled / filled.shift(freq="5D") - 1).reindex_like(filled)
+        )
+
+    def test_pct_change_with_duplicate_axis(self):
+        # GH#28664
+        common_idx = date_range("2019-11-14", periods=5, freq="D")
+        result = Series(range(5), common_idx).pct_change(freq="B")
+
+        # the reason that the expected should be like this is documented at PR 28681
+        expected = Series([np.nan, np.inf, np.nan, np.nan, 3.0], common_idx)
+
+        tm.assert_series_equal(result, expected)
+
+    def test_pct_change_shift_over_nas(self):
+        s = Series([1.0, 1.5, np.nan, 2.5, 3.0])
+
+        msg = "The default fill_method='pad' in Series.pct_change is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            chg = s.pct_change()
+
+        expected = Series([np.nan, 0.5, 0.0, 2.5 / 1.5 - 1, 0.2])
+        tm.assert_series_equal(chg, expected)
+
+    @pytest.mark.parametrize(
+        "freq, periods, fill_method, limit",
+        [
+            ("5B", 5, None, None),
+            ("3B", 3, None, None),
+            ("3B", 3, "bfill", None),
+            ("7B", 7, "pad", 1),
+            ("7B", 7, "bfill", 3),
+            ("14B", 14, None, None),
+        ],
+    )
+    def test_pct_change_periods_freq(
+        self, freq, periods, fill_method, limit, datetime_series
+    ):
+        msg = (
+            "The 'fill_method' keyword being not None and the 'limit' keyword in "
+            "Series.pct_change are deprecated"
+        )
+
+        # GH#7292
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs_freq = datetime_series.pct_change(
+                freq=freq, fill_method=fill_method, limit=limit
+            )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs_periods = datetime_series.pct_change(
+                periods, fill_method=fill_method, limit=limit
+            )
+        tm.assert_series_equal(rs_freq, rs_periods)
+
+        empty_ts = Series(index=datetime_series.index, dtype=object)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs_freq = empty_ts.pct_change(
+                freq=freq, fill_method=fill_method, limit=limit
+            )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs_periods = empty_ts.pct_change(
+                periods, fill_method=fill_method, limit=limit
+            )
+        tm.assert_series_equal(rs_freq, rs_periods)
+
+
+@pytest.mark.parametrize("fill_method", ["pad", "ffill", None])
+def test_pct_change_with_duplicated_indices(fill_method):
+    # GH30463
+    s = Series([np.nan, 1, 2, 3, 9, 18], index=["a", "b"] * 3)
+
+    warn = None if fill_method is None else FutureWarning
+    msg = (
+        "The 'fill_method' keyword being not None and the 'limit' keyword in "
+        "Series.pct_change are deprecated"
+    )
+    with tm.assert_produces_warning(warn, match=msg):
+        result = s.pct_change(fill_method=fill_method)
+
+    expected = Series([np.nan, np.nan, 1.0, 0.5, 2.0, 1.0], index=["a", "b"] * 3)
+    tm.assert_series_equal(result, expected)
+
+
+def test_pct_change_no_warning_na_beginning():
+    # GH#54981
+    ser = Series([None, None, 1, 2, 3])
+    result = ser.pct_change()
+    expected = Series([np.nan, np.nan, np.nan, 1, 0.5])
+    tm.assert_series_equal(result, expected)
+
+
+def test_pct_change_empty():
+    # GH 57056
+    ser = Series([], dtype="float64")
+    expected = ser.copy()
+    result = ser.pct_change(periods=0)
+    tm.assert_series_equal(expected, result)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_pop.py

@@ -0,0 +1,13 @@
+from pandas import Series
+import pandas._testing as tm
+
+
+def test_pop():
+    # GH#6600
+    ser = Series([0, 4, 0], index=["A", "B", "C"], name=4)
+
+    result = ser.pop("B")
+    assert result == 4
+
+    expected = Series([0, 0], index=["A", "C"], name=4)
+    tm.assert_series_equal(ser, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_quantile.py

@@ -0,0 +1,247 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import is_integer
+
+import pandas as pd
+from pandas import (
+    Index,
+    Series,
+)
+import pandas._testing as tm
+from pandas.core.indexes.datetimes import Timestamp
+
+
+class TestSeriesQuantile:
+    def test_quantile(self, datetime_series):
+        q = datetime_series.quantile(0.1)
+        assert q == np.percentile(datetime_series.dropna(), 10)
+
+        q = datetime_series.quantile(0.9)
+        assert q == np.percentile(datetime_series.dropna(), 90)
+
+        # object dtype
+        q = Series(datetime_series, dtype=object).quantile(0.9)
+        assert q == np.percentile(datetime_series.dropna(), 90)
+
+        # datetime64[ns] dtype
+        dts = datetime_series.index.to_series()
+        q = dts.quantile(0.2)
+        assert q == Timestamp("2000-01-10 19:12:00")
+
+        # timedelta64[ns] dtype
+        tds = dts.diff()
+        q = tds.quantile(0.25)
+        assert q == pd.to_timedelta("24:00:00")
+
+        # GH7661
+        result = Series([np.timedelta64("NaT")]).sum()
+        assert result == pd.Timedelta(0)
+
+        msg = "percentiles should all be in the interval \\[0, 1\\]"
+        for invalid in [-1, 2, [0.5, -1], [0.5, 2]]:
+            with pytest.raises(ValueError, match=msg):
+                datetime_series.quantile(invalid)
+
+        s = Series(np.random.default_rng(2).standard_normal(100))
+        percentile_array = [-0.5, 0.25, 1.5]
+        with pytest.raises(ValueError, match=msg):
+            s.quantile(percentile_array)
+
+    def test_quantile_multi(self, datetime_series, unit):
+        datetime_series.index = datetime_series.index.as_unit(unit)
+        qs = [0.1, 0.9]
+        result = datetime_series.quantile(qs)
+        expected = Series(
+            [
+                np.percentile(datetime_series.dropna(), 10),
+                np.percentile(datetime_series.dropna(), 90),
+            ],
+            index=qs,
+            name=datetime_series.name,
+        )
+        tm.assert_series_equal(result, expected)
+
+        dts = datetime_series.index.to_series()
+        dts.name = "xxx"
+        result = dts.quantile((0.2, 0.2))
+        expected = Series(
+            [Timestamp("2000-01-10 19:12:00"), Timestamp("2000-01-10 19:12:00")],
+            index=[0.2, 0.2],
+            name="xxx",
+            dtype=f"M8[{unit}]",
+        )
+        tm.assert_series_equal(result, expected)
+
+        result = datetime_series.quantile([])
+        expected = Series(
+            [], name=datetime_series.name, index=Index([], dtype=float), dtype="float64"
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_quantile_interpolation(self, datetime_series):
+        # see gh-10174
+
+        # interpolation = linear (default case)
+        q = datetime_series.quantile(0.1, interpolation="linear")
+        assert q == np.percentile(datetime_series.dropna(), 10)
+        q1 = datetime_series.quantile(0.1)
+        assert q1 == np.percentile(datetime_series.dropna(), 10)
+
+        # test with and without interpolation keyword
+        assert q == q1
+
+    def test_quantile_interpolation_dtype(self):
+        # GH #10174
+
+        # interpolation = linear (default case)
+        q = Series([1, 3, 4]).quantile(0.5, interpolation="lower")
+        assert q == np.percentile(np.array([1, 3, 4]), 50)
+        assert is_integer(q)
+
+        q = Series([1, 3, 4]).quantile(0.5, interpolation="higher")
+        assert q == np.percentile(np.array([1, 3, 4]), 50)
+        assert is_integer(q)
+
+    def test_quantile_nan(self):
+        # GH 13098
+        ser = Series([1, 2, 3, 4, np.nan])
+        result = ser.quantile(0.5)
+        expected = 2.5
+        assert result == expected
+
+        # all nan/empty
+        s1 = Series([], dtype=object)
+        cases = [s1, Series([np.nan, np.nan])]
+
+        for ser in cases:
+            res = ser.quantile(0.5)
+            assert np.isnan(res)
+
+            res = ser.quantile([0.5])
+            tm.assert_series_equal(res, Series([np.nan], index=[0.5]))
+
+            res = ser.quantile([0.2, 0.3])
+            tm.assert_series_equal(res, Series([np.nan, np.nan], index=[0.2, 0.3]))
+
+    @pytest.mark.parametrize(
+        "case",
+        [
+            [
+                Timestamp("2011-01-01"),
+                Timestamp("2011-01-02"),
+                Timestamp("2011-01-03"),
+            ],
+            [
+                Timestamp("2011-01-01", tz="US/Eastern"),
+                Timestamp("2011-01-02", tz="US/Eastern"),
+                Timestamp("2011-01-03", tz="US/Eastern"),
+            ],
+            [pd.Timedelta("1 days"), pd.Timedelta("2 days"), pd.Timedelta("3 days")],
+            # NaT
+            [
+                Timestamp("2011-01-01"),
+                Timestamp("2011-01-02"),
+                Timestamp("2011-01-03"),
+                pd.NaT,
+            ],
+            [
+                Timestamp("2011-01-01", tz="US/Eastern"),
+                Timestamp("2011-01-02", tz="US/Eastern"),
+                Timestamp("2011-01-03", tz="US/Eastern"),
+                pd.NaT,
+            ],
+            [
+                pd.Timedelta("1 days"),
+                pd.Timedelta("2 days"),
+                pd.Timedelta("3 days"),
+                pd.NaT,
+            ],
+        ],
+    )
+    def test_quantile_box(self, case):
+        ser = Series(case, name="XXX")
+        res = ser.quantile(0.5)
+        assert res == case[1]
+
+        res = ser.quantile([0.5])
+        exp = Series([case[1]], index=[0.5], name="XXX")
+        tm.assert_series_equal(res, exp)
+
+    def test_datetime_timedelta_quantiles(self):
+        # covers #9694
+        assert pd.isna(Series([], dtype="M8[ns]").quantile(0.5))
+        assert pd.isna(Series([], dtype="m8[ns]").quantile(0.5))
+
+    def test_quantile_nat(self):
+        res = Series([pd.NaT, pd.NaT]).quantile(0.5)
+        assert res is pd.NaT
+
+        res = Series([pd.NaT, pd.NaT]).quantile([0.5])
+        tm.assert_series_equal(res, Series([pd.NaT], index=[0.5]))
+
+    @pytest.mark.parametrize(
+        "values, dtype",
+        [([0, 0, 0, 1, 2, 3], "Sparse[int]"), ([0.0, None, 1.0, 2.0], "Sparse[float]")],
+    )
+    def test_quantile_sparse(self, values, dtype):
+        ser = Series(values, dtype=dtype)
+        result = ser.quantile([0.5])
+        expected = Series(np.asarray(ser)).quantile([0.5]).astype("Sparse[float]")
+        tm.assert_series_equal(result, expected)
+
+    def test_quantile_empty_float64(self):
+        # floats
+        ser = Series([], dtype="float64")
+
+        res = ser.quantile(0.5)
+        assert np.isnan(res)
+
+        res = ser.quantile([0.5])
+        exp = Series([np.nan], index=[0.5])
+        tm.assert_series_equal(res, exp)
+
+    def test_quantile_empty_int64(self):
+        # int
+        ser = Series([], dtype="int64")
+
+        res = ser.quantile(0.5)
+        assert np.isnan(res)
+
+        res = ser.quantile([0.5])
+        exp = Series([np.nan], index=[0.5])
+        tm.assert_series_equal(res, exp)
+
+    def test_quantile_empty_dt64(self):
+        # datetime
+        ser = Series([], dtype="datetime64[ns]")
+
+        res = ser.quantile(0.5)
+        assert res is pd.NaT
+
+        res = ser.quantile([0.5])
+        exp = Series([pd.NaT], index=[0.5], dtype=ser.dtype)
+        tm.assert_series_equal(res, exp)
+
+    @pytest.mark.parametrize("dtype", [int, float, "Int64"])
+    def test_quantile_dtypes(self, dtype):
+        result = Series([1, 2, 3], dtype=dtype).quantile(np.arange(0, 1, 0.25))
+        expected = Series(np.arange(1, 3, 0.5), index=np.arange(0, 1, 0.25))
+        if dtype == "Int64":
+            expected = expected.astype("Float64")
+        tm.assert_series_equal(result, expected)
+
+    def test_quantile_all_na(self, any_int_ea_dtype):
+        # GH#50681
+        ser = Series([pd.NA, pd.NA], dtype=any_int_ea_dtype)
+        with tm.assert_produces_warning(None):
+            result = ser.quantile([0.1, 0.5])
+        expected = Series([pd.NA, pd.NA], dtype=any_int_ea_dtype, index=[0.1, 0.5])
+        tm.assert_series_equal(result, expected)
+
+    def test_quantile_dtype_size(self, any_int_ea_dtype):
+        # GH#50681
+        ser = Series([pd.NA, pd.NA, 1], dtype=any_int_ea_dtype)
+        result = ser.quantile([0.1, 0.5])
+        expected = Series([1, 1], dtype=any_int_ea_dtype, index=[0.1, 0.5])
+        tm.assert_series_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_rank.py

@@ -0,0 +1,519 @@
+from itertools import chain
+import operator
+
+import numpy as np
+import pytest
+
+from pandas._libs.algos import (
+    Infinity,
+    NegInfinity,
+)
+import pandas.util._test_decorators as td
+
+from pandas import (
+    NA,
+    NaT,
+    Series,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+from pandas.api.types import CategoricalDtype
+
+
+@pytest.fixture
+def ser():
+    return Series([1, 3, 4, 2, np.nan, 2, 1, 5, np.nan, 3])
+
+
+@pytest.fixture(
+    params=[
+        ["average", np.array([1.5, 5.5, 7.0, 3.5, np.nan, 3.5, 1.5, 8.0, np.nan, 5.5])],
+        ["min", np.array([1, 5, 7, 3, np.nan, 3, 1, 8, np.nan, 5])],
+        ["max", np.array([2, 6, 7, 4, np.nan, 4, 2, 8, np.nan, 6])],
+        ["first", np.array([1, 5, 7, 3, np.nan, 4, 2, 8, np.nan, 6])],
+        ["dense", np.array([1, 3, 4, 2, np.nan, 2, 1, 5, np.nan, 3])],
+    ]
+)
+def results(request):
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        "object",
+        "float64",
+        "int64",
+        "Float64",
+        "Int64",
+        pytest.param("float64[pyarrow]", marks=td.skip_if_no("pyarrow")),
+        pytest.param("int64[pyarrow]", marks=td.skip_if_no("pyarrow")),
+    ]
+)
+def dtype(request):
+    return request.param
+
+
+class TestSeriesRank:
+    def test_rank(self, datetime_series):
+        sp_stats = pytest.importorskip("scipy.stats")
+
+        datetime_series[::2] = np.nan
+        datetime_series[:10:3] = 4.0
+
+        ranks = datetime_series.rank()
+        oranks = datetime_series.astype("O").rank()
+
+        tm.assert_series_equal(ranks, oranks)
+
+        mask = np.isnan(datetime_series)
+        filled = datetime_series.fillna(np.inf)
+
+        # rankdata returns a ndarray
+        exp = Series(sp_stats.rankdata(filled), index=filled.index, name="ts")
+        exp[mask] = np.nan
+
+        tm.assert_series_equal(ranks, exp)
+
+        iseries = Series(np.arange(5).repeat(2))
+
+        iranks = iseries.rank()
+        exp = iseries.astype(float).rank()
+        tm.assert_series_equal(iranks, exp)
+        iseries = Series(np.arange(5)) + 1.0
+        exp = iseries / 5.0
+        iranks = iseries.rank(pct=True)
+
+        tm.assert_series_equal(iranks, exp)
+
+        iseries = Series(np.repeat(1, 100))
+        exp = Series(np.repeat(0.505, 100))
+        iranks = iseries.rank(pct=True)
+        tm.assert_series_equal(iranks, exp)
+
+        # Explicit cast to float to avoid implicit cast when setting nan
+        iseries = iseries.astype("float")
+        iseries[1] = np.nan
+        exp = Series(np.repeat(50.0 / 99.0, 100))
+        exp[1] = np.nan
+        iranks = iseries.rank(pct=True)
+        tm.assert_series_equal(iranks, exp)
+
+        iseries = Series(np.arange(5)) + 1.0
+        iseries[4] = np.nan
+        exp = iseries / 4.0
+        iranks = iseries.rank(pct=True)
+        tm.assert_series_equal(iranks, exp)
+
+        iseries = Series(np.repeat(np.nan, 100))
+        exp = iseries.copy()
+        iranks = iseries.rank(pct=True)
+        tm.assert_series_equal(iranks, exp)
+
+        # Explicit cast to float to avoid implicit cast when setting nan
+        iseries = Series(np.arange(5), dtype="float") + 1
+        iseries[4] = np.nan
+        exp = iseries / 4.0
+        iranks = iseries.rank(pct=True)
+        tm.assert_series_equal(iranks, exp)
+
+        rng = date_range("1/1/1990", periods=5)
+        # Explicit cast to float to avoid implicit cast when setting nan
+        iseries = Series(np.arange(5), rng, dtype="float") + 1
+        iseries.iloc[4] = np.nan
+        exp = iseries / 4.0
+        iranks = iseries.rank(pct=True)
+        tm.assert_series_equal(iranks, exp)
+
+        iseries = Series([1e-50, 1e-100, 1e-20, 1e-2, 1e-20 + 1e-30, 1e-1])
+        exp = Series([2, 1, 3, 5, 4, 6.0])
+        iranks = iseries.rank()
+        tm.assert_series_equal(iranks, exp)
+
+        # GH 5968
+        iseries = Series(["3 day", "1 day 10m", "-2 day", NaT], dtype="m8[ns]")
+        exp = Series([3, 2, 1, np.nan])
+        iranks = iseries.rank()
+        tm.assert_series_equal(iranks, exp)
+
+        values = np.array(
+            [-50, -1, -1e-20, -1e-25, -1e-50, 0, 1e-40, 1e-20, 1e-10, 2, 40],
+            dtype="float64",
+        )
+        random_order = np.random.default_rng(2).permutation(len(values))
+        iseries = Series(values[random_order])
+        exp = Series(random_order + 1.0, dtype="float64")
+        iranks = iseries.rank()
+        tm.assert_series_equal(iranks, exp)
+
+    def test_rank_categorical(self):
+        # GH issue #15420 rank incorrectly orders ordered categories
+
+        # Test ascending/descending ranking for ordered categoricals
+        exp = Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
+        exp_desc = Series([6.0, 5.0, 4.0, 3.0, 2.0, 1.0])
+        ordered = Series(
+            ["first", "second", "third", "fourth", "fifth", "sixth"]
+        ).astype(
+            CategoricalDtype(
+                categories=["first", "second", "third", "fourth", "fifth", "sixth"],
+                ordered=True,
+            )
+        )
+        tm.assert_series_equal(ordered.rank(), exp)
+        tm.assert_series_equal(ordered.rank(ascending=False), exp_desc)
+
+        # Unordered categoricals should be ranked as objects
+        unordered = Series(
+            ["first", "second", "third", "fourth", "fifth", "sixth"]
+        ).astype(
+            CategoricalDtype(
+                categories=["first", "second", "third", "fourth", "fifth", "sixth"],
+                ordered=False,
+            )
+        )
+        exp_unordered = Series([2.0, 4.0, 6.0, 3.0, 1.0, 5.0])
+        res = unordered.rank()
+        tm.assert_series_equal(res, exp_unordered)
+
+        unordered1 = Series([1, 2, 3, 4, 5, 6]).astype(
+            CategoricalDtype([1, 2, 3, 4, 5, 6], False)
+        )
+        exp_unordered1 = Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
+        res1 = unordered1.rank()
+        tm.assert_series_equal(res1, exp_unordered1)
+
+        # Test na_option for rank data
+        na_ser = Series(
+            ["first", "second", "third", "fourth", "fifth", "sixth", np.nan]
+        ).astype(
+            CategoricalDtype(
+                ["first", "second", "third", "fourth", "fifth", "sixth", "seventh"],
+                True,
+            )
+        )
+
+        exp_top = Series([2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 1.0])
+        exp_bot = Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0])
+        exp_keep = Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, np.nan])
+
+        tm.assert_series_equal(na_ser.rank(na_option="top"), exp_top)
+        tm.assert_series_equal(na_ser.rank(na_option="bottom"), exp_bot)
+        tm.assert_series_equal(na_ser.rank(na_option="keep"), exp_keep)
+
+        # Test na_option for rank data with ascending False
+        exp_top = Series([7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0])
+        exp_bot = Series([6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 7.0])
+        exp_keep = Series([6.0, 5.0, 4.0, 3.0, 2.0, 1.0, np.nan])
+
+        tm.assert_series_equal(na_ser.rank(na_option="top", ascending=False), exp_top)
+        tm.assert_series_equal(
+            na_ser.rank(na_option="bottom", ascending=False), exp_bot
+        )
+        tm.assert_series_equal(na_ser.rank(na_option="keep", ascending=False), exp_keep)
+
+        # Test invalid values for na_option
+        msg = "na_option must be one of 'keep', 'top', or 'bottom'"
+
+        with pytest.raises(ValueError, match=msg):
+            na_ser.rank(na_option="bad", ascending=False)
+
+        # invalid type
+        with pytest.raises(ValueError, match=msg):
+            na_ser.rank(na_option=True, ascending=False)
+
+        # Test with pct=True
+        na_ser = Series(["first", "second", "third", "fourth", np.nan]).astype(
+            CategoricalDtype(["first", "second", "third", "fourth"], True)
+        )
+        exp_top = Series([0.4, 0.6, 0.8, 1.0, 0.2])
+        exp_bot = Series([0.2, 0.4, 0.6, 0.8, 1.0])
+        exp_keep = Series([0.25, 0.5, 0.75, 1.0, np.nan])
+
+        tm.assert_series_equal(na_ser.rank(na_option="top", pct=True), exp_top)
+        tm.assert_series_equal(na_ser.rank(na_option="bottom", pct=True), exp_bot)
+        tm.assert_series_equal(na_ser.rank(na_option="keep", pct=True), exp_keep)
+
+    def test_rank_signature(self):
+        s = Series([0, 1])
+        s.rank(method="average")
+        msg = "No axis named average for object type Series"
+        with pytest.raises(ValueError, match=msg):
+            s.rank("average")
+
+    @pytest.mark.parametrize("dtype", [None, object])
+    def test_rank_tie_methods(self, ser, results, dtype):
+        method, exp = results
+        ser = ser if dtype is None else ser.astype(dtype)
+        result = ser.rank(method=method)
+        tm.assert_series_equal(result, Series(exp))
+
+    @pytest.mark.parametrize("ascending", [True, False])
+    @pytest.mark.parametrize("method", ["average", "min", "max", "first", "dense"])
+    @pytest.mark.parametrize("na_option", ["top", "bottom", "keep"])
+    @pytest.mark.parametrize(
+        "dtype, na_value, pos_inf, neg_inf",
+        [
+            ("object", None, Infinity(), NegInfinity()),
+            ("float64", np.nan, np.inf, -np.inf),
+            ("Float64", NA, np.inf, -np.inf),
+            pytest.param(
+                "float64[pyarrow]",
+                NA,
+                np.inf,
+                -np.inf,
+                marks=td.skip_if_no("pyarrow"),
+            ),
+        ],
+    )
+    def test_rank_tie_methods_on_infs_nans(
+        self, method, na_option, ascending, dtype, na_value, pos_inf, neg_inf
+    ):
+        pytest.importorskip("scipy")
+        if dtype == "float64[pyarrow]":
+            if method == "average":
+                exp_dtype = "float64[pyarrow]"
+            else:
+                exp_dtype = "uint64[pyarrow]"
+        else:
+            exp_dtype = "float64"
+
+        chunk = 3
+        in_arr = [neg_inf] * chunk + [na_value] * chunk + [pos_inf] * chunk
+        iseries = Series(in_arr, dtype=dtype)
+        exp_ranks = {
+            "average": ([2, 2, 2], [5, 5, 5], [8, 8, 8]),
+            "min": ([1, 1, 1], [4, 4, 4], [7, 7, 7]),
+            "max": ([3, 3, 3], [6, 6, 6], [9, 9, 9]),
+            "first": ([1, 2, 3], [4, 5, 6], [7, 8, 9]),
+            "dense": ([1, 1, 1], [2, 2, 2], [3, 3, 3]),
+        }
+        ranks = exp_ranks[method]
+        if na_option == "top":
+            order = [ranks[1], ranks[0], ranks[2]]
+        elif na_option == "bottom":
+            order = [ranks[0], ranks[2], ranks[1]]
+        else:
+            order = [ranks[0], [np.nan] * chunk, ranks[1]]
+        expected = order if ascending else order[::-1]
+        expected = list(chain.from_iterable(expected))
+        result = iseries.rank(method=method, na_option=na_option, ascending=ascending)
+        tm.assert_series_equal(result, Series(expected, dtype=exp_dtype))
+
+    def test_rank_desc_mix_nans_infs(self):
+        # GH 19538
+        # check descending ranking when mix nans and infs
+        iseries = Series([1, np.nan, np.inf, -np.inf, 25])
+        result = iseries.rank(ascending=False)
+        exp = Series([3, np.nan, 1, 4, 2], dtype="float64")
+        tm.assert_series_equal(result, exp)
+
+    @pytest.mark.parametrize("method", ["average", "min", "max", "first", "dense"])
+    @pytest.mark.parametrize(
+        "op, value",
+        [
+            [operator.add, 0],
+            [operator.add, 1e6],
+            [operator.mul, 1e-6],
+        ],
+    )
+    def test_rank_methods_series(self, method, op, value):
+        sp_stats = pytest.importorskip("scipy.stats")
+
+        xs = np.random.default_rng(2).standard_normal(9)
+        xs = np.concatenate([xs[i:] for i in range(0, 9, 2)])  # add duplicates
+        np.random.default_rng(2).shuffle(xs)
+
+        index = [chr(ord("a") + i) for i in range(len(xs))]
+        vals = op(xs, value)
+        ts = Series(vals, index=index)
+        result = ts.rank(method=method)
+        sprank = sp_stats.rankdata(vals, method if method != "first" else "ordinal")
+        expected = Series(sprank, index=index).astype("float64")
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "ser, exp",
+        [
+            ([1], [1]),
+            ([2], [1]),
+            ([0], [1]),
+            ([2, 2], [1, 1]),
+            ([1, 2, 3], [1, 2, 3]),
+            ([4, 2, 1], [3, 2, 1]),
+            ([1, 1, 5, 5, 3], [1, 1, 3, 3, 2]),
+            ([-5, -4, -3, -2, -1], [1, 2, 3, 4, 5]),
+        ],
+    )
+    def test_rank_dense_method(self, dtype, ser, exp):
+        s = Series(ser).astype(dtype)
+        result = s.rank(method="dense")
+        expected = Series(exp).astype(result.dtype)
+        tm.assert_series_equal(result, expected)
+
+    def test_rank_descending(self, ser, results, dtype):
+        method, _ = results
+        if "i" in dtype:
+            s = ser.dropna()
+        else:
+            s = ser.astype(dtype)
+
+        res = s.rank(ascending=False)
+        expected = (s.max() - s).rank()
+        tm.assert_series_equal(res, expected)
+
+        expected = (s.max() - s).rank(method=method)
+        res2 = s.rank(method=method, ascending=False)
+        tm.assert_series_equal(res2, expected)
+
+    def test_rank_int(self, ser, results):
+        method, exp = results
+        s = ser.dropna().astype("i8")
+
+        result = s.rank(method=method)
+        expected = Series(exp).dropna()
+        expected.index = result.index
+        tm.assert_series_equal(result, expected)
+
+    def test_rank_object_bug(self):
+        # GH 13445
+
+        # smoke tests
+        Series([np.nan] * 32).astype(object).rank(ascending=True)
+        Series([np.nan] * 32).astype(object).rank(ascending=False)
+
+    def test_rank_modify_inplace(self):
+        # GH 18521
+        # Check rank does not mutate series
+        s = Series([Timestamp("2017-01-05 10:20:27.569000"), NaT])
+        expected = s.copy()
+
+        s.rank()
+        result = s
+        tm.assert_series_equal(result, expected)
+
+    def test_rank_ea_small_values(self):
+        # GH#52471
+        ser = Series(
+            [5.4954145e29, -9.791984e-21, 9.3715776e-26, NA, 1.8790257e-28],
+            dtype="Float64",
+        )
+        result = ser.rank(method="min")
+        expected = Series([4, 1, 3, np.nan, 2])
+        tm.assert_series_equal(result, expected)
+
+
+# GH15630, pct should be on 100% basis when method='dense'
+
+
+@pytest.mark.parametrize(
+    "ser, exp",
+    [
+        ([1], [1.0]),
+        ([1, 2], [1.0 / 2, 2.0 / 2]),
+        ([2, 2], [1.0, 1.0]),
+        ([1, 2, 3], [1.0 / 3, 2.0 / 3, 3.0 / 3]),
+        ([1, 2, 2], [1.0 / 2, 2.0 / 2, 2.0 / 2]),
+        ([4, 2, 1], [3.0 / 3, 2.0 / 3, 1.0 / 3]),
+        ([1, 1, 5, 5, 3], [1.0 / 3, 1.0 / 3, 3.0 / 3, 3.0 / 3, 2.0 / 3]),
+        ([1, 1, 3, 3, 5, 5], [1.0 / 3, 1.0 / 3, 2.0 / 3, 2.0 / 3, 3.0 / 3, 3.0 / 3]),
+        ([-5, -4, -3, -2, -1], [1.0 / 5, 2.0 / 5, 3.0 / 5, 4.0 / 5, 5.0 / 5]),
+    ],
+)
+def test_rank_dense_pct(dtype, ser, exp):
+    s = Series(ser).astype(dtype)
+    result = s.rank(method="dense", pct=True)
+    expected = Series(exp).astype(result.dtype)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ser, exp",
+    [
+        ([1], [1.0]),
+        ([1, 2], [1.0 / 2, 2.0 / 2]),
+        ([2, 2], [1.0 / 2, 1.0 / 2]),
+        ([1, 2, 3], [1.0 / 3, 2.0 / 3, 3.0 / 3]),
+        ([1, 2, 2], [1.0 / 3, 2.0 / 3, 2.0 / 3]),
+        ([4, 2, 1], [3.0 / 3, 2.0 / 3, 1.0 / 3]),
+        ([1, 1, 5, 5, 3], [1.0 / 5, 1.0 / 5, 4.0 / 5, 4.0 / 5, 3.0 / 5]),
+        ([1, 1, 3, 3, 5, 5], [1.0 / 6, 1.0 / 6, 3.0 / 6, 3.0 / 6, 5.0 / 6, 5.0 / 6]),
+        ([-5, -4, -3, -2, -1], [1.0 / 5, 2.0 / 5, 3.0 / 5, 4.0 / 5, 5.0 / 5]),
+    ],
+)
+def test_rank_min_pct(dtype, ser, exp):
+    s = Series(ser).astype(dtype)
+    result = s.rank(method="min", pct=True)
+    expected = Series(exp).astype(result.dtype)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ser, exp",
+    [
+        ([1], [1.0]),
+        ([1, 2], [1.0 / 2, 2.0 / 2]),
+        ([2, 2], [1.0, 1.0]),
+        ([1, 2, 3], [1.0 / 3, 2.0 / 3, 3.0 / 3]),
+        ([1, 2, 2], [1.0 / 3, 3.0 / 3, 3.0 / 3]),
+        ([4, 2, 1], [3.0 / 3, 2.0 / 3, 1.0 / 3]),
+        ([1, 1, 5, 5, 3], [2.0 / 5, 2.0 / 5, 5.0 / 5, 5.0 / 5, 3.0 / 5]),
+        ([1, 1, 3, 3, 5, 5], [2.0 / 6, 2.0 / 6, 4.0 / 6, 4.0 / 6, 6.0 / 6, 6.0 / 6]),
+        ([-5, -4, -3, -2, -1], [1.0 / 5, 2.0 / 5, 3.0 / 5, 4.0 / 5, 5.0 / 5]),
+    ],
+)
+def test_rank_max_pct(dtype, ser, exp):
+    s = Series(ser).astype(dtype)
+    result = s.rank(method="max", pct=True)
+    expected = Series(exp).astype(result.dtype)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ser, exp",
+    [
+        ([1], [1.0]),
+        ([1, 2], [1.0 / 2, 2.0 / 2]),
+        ([2, 2], [1.5 / 2, 1.5 / 2]),
+        ([1, 2, 3], [1.0 / 3, 2.0 / 3, 3.0 / 3]),
+        ([1, 2, 2], [1.0 / 3, 2.5 / 3, 2.5 / 3]),
+        ([4, 2, 1], [3.0 / 3, 2.0 / 3, 1.0 / 3]),
+        ([1, 1, 5, 5, 3], [1.5 / 5, 1.5 / 5, 4.5 / 5, 4.5 / 5, 3.0 / 5]),
+        ([1, 1, 3, 3, 5, 5], [1.5 / 6, 1.5 / 6, 3.5 / 6, 3.5 / 6, 5.5 / 6, 5.5 / 6]),
+        ([-5, -4, -3, -2, -1], [1.0 / 5, 2.0 / 5, 3.0 / 5, 4.0 / 5, 5.0 / 5]),
+    ],
+)
+def test_rank_average_pct(dtype, ser, exp):
+    s = Series(ser).astype(dtype)
+    result = s.rank(method="average", pct=True)
+    expected = Series(exp).astype(result.dtype)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ser, exp",
+    [
+        ([1], [1.0]),
+        ([1, 2], [1.0 / 2, 2.0 / 2]),
+        ([2, 2], [1.0 / 2, 2.0 / 2.0]),
+        ([1, 2, 3], [1.0 / 3, 2.0 / 3, 3.0 / 3]),
+        ([1, 2, 2], [1.0 / 3, 2.0 / 3, 3.0 / 3]),
+        ([4, 2, 1], [3.0 / 3, 2.0 / 3, 1.0 / 3]),
+        ([1, 1, 5, 5, 3], [1.0 / 5, 2.0 / 5, 4.0 / 5, 5.0 / 5, 3.0 / 5]),
+        ([1, 1, 3, 3, 5, 5], [1.0 / 6, 2.0 / 6, 3.0 / 6, 4.0 / 6, 5.0 / 6, 6.0 / 6]),
+        ([-5, -4, -3, -2, -1], [1.0 / 5, 2.0 / 5, 3.0 / 5, 4.0 / 5, 5.0 / 5]),
+    ],
+)
+def test_rank_first_pct(dtype, ser, exp):
+    s = Series(ser).astype(dtype)
+    result = s.rank(method="first", pct=True)
+    expected = Series(exp).astype(result.dtype)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.single_cpu
+def test_pct_max_many_rows():
+    # GH 18271
+    s = Series(np.arange(2**24 + 1))
+    result = s.rank(pct=True).max()
+    assert result == 1

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_reindex_like.py

@@ -0,0 +1,41 @@
+from datetime import datetime
+
+import numpy as np
+
+from pandas import Series
+import pandas._testing as tm
+
+
+def test_reindex_like(datetime_series):
+    other = datetime_series[::2]
+    tm.assert_series_equal(
+        datetime_series.reindex(other.index), datetime_series.reindex_like(other)
+    )
+
+    # GH#7179
+    day1 = datetime(2013, 3, 5)
+    day2 = datetime(2013, 5, 5)
+    day3 = datetime(2014, 3, 5)
+
+    series1 = Series([5, None, None], [day1, day2, day3])
+    series2 = Series([None, None], [day1, day3])
+
+    result = series1.reindex_like(series2, method="pad")
+    expected = Series([5, np.nan], index=[day1, day3])
+    tm.assert_series_equal(result, expected)
+
+
+def test_reindex_like_nearest():
+    ser = Series(np.arange(10, dtype="int64"))
+
+    target = [0.1, 0.9, 1.5, 2.0]
+    other = ser.reindex(target, method="nearest")
+    expected = Series(np.around(target).astype("int64"), target)
+
+    result = ser.reindex_like(other, method="nearest")
+    tm.assert_series_equal(expected, result)
+
+    result = ser.reindex_like(other, method="nearest", tolerance=1)
+    tm.assert_series_equal(expected, result)
+    result = ser.reindex_like(other, method="nearest", tolerance=[1, 2, 3, 4])
+    tm.assert_series_equal(expected, result)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_rename_axis.py

@@ -0,0 +1,47 @@
+import pytest
+
+from pandas import (
+    Index,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestSeriesRenameAxis:
+    def test_rename_axis_mapper(self):
+        # GH 19978
+        mi = MultiIndex.from_product([["a", "b", "c"], [1, 2]], names=["ll", "nn"])
+        ser = Series(list(range(len(mi))), index=mi)
+
+        result = ser.rename_axis(index={"ll": "foo"})
+        assert result.index.names == ["foo", "nn"]
+
+        result = ser.rename_axis(index=str.upper, axis=0)
+        assert result.index.names == ["LL", "NN"]
+
+        result = ser.rename_axis(index=["foo", "goo"])
+        assert result.index.names == ["foo", "goo"]
+
+        with pytest.raises(TypeError, match="unexpected"):
+            ser.rename_axis(columns="wrong")
+
+    def test_rename_axis_inplace(self, datetime_series):
+        # GH 15704
+        expected = datetime_series.rename_axis("foo")
+        result = datetime_series
+        no_return = result.rename_axis("foo", inplace=True)
+
+        assert no_return is None
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("kwargs", [{"mapper": None}, {"index": None}, {}])
+    def test_rename_axis_none(self, kwargs):
+        # GH 25034
+        index = Index(list("abc"), name="foo")
+        ser = Series([1, 2, 3], index=index)
+
+        result = ser.rename_axis(**kwargs)
+        expected_index = index.rename(None) if kwargs else index
+        expected = Series([1, 2, 3], index=expected_index)
+        tm.assert_series_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_replace.py

@@ -0,0 +1,813 @@
+import re
+
+import numpy as np
+import pytest
+
+from pandas._config import using_pyarrow_string_dtype
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.arrays import IntervalArray
+
+
+class TestSeriesReplace:
+    def test_replace_explicit_none(self):
+        # GH#36984 if the user explicitly passes value=None, give it to them
+        ser = pd.Series([0, 0, ""], dtype=object)
+        result = ser.replace("", None)
+        expected = pd.Series([0, 0, None], dtype=object)
+        tm.assert_series_equal(result, expected)
+
+        # Cast column 2 to object to avoid implicit cast when setting entry to ""
+        df = pd.DataFrame(np.zeros((3, 3))).astype({2: object})
+        df.iloc[2, 2] = ""
+        result = df.replace("", None)
+        expected = pd.DataFrame(
+            {
+                0: np.zeros(3),
+                1: np.zeros(3),
+                2: np.array([0.0, 0.0, None], dtype=object),
+            }
+        )
+        assert expected.iloc[2, 2] is None
+        tm.assert_frame_equal(result, expected)
+
+        # GH#19998 same thing with object dtype
+        ser = pd.Series([10, 20, 30, "a", "a", "b", "a"])
+        result = ser.replace("a", None)
+        expected = pd.Series([10, 20, 30, None, None, "b", None])
+        assert expected.iloc[-1] is None
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_noop_doesnt_downcast(self):
+        # GH#44498
+        ser = pd.Series([None, None, pd.Timestamp("2021-12-16 17:31")], dtype=object)
+        res = ser.replace({np.nan: None})  # should be a no-op
+        tm.assert_series_equal(res, ser)
+        assert res.dtype == object
+
+        # same thing but different calling convention
+        res = ser.replace(np.nan, None)
+        tm.assert_series_equal(res, ser)
+        assert res.dtype == object
+
+    def test_replace(self):
+        N = 50
+        ser = pd.Series(np.random.default_rng(2).standard_normal(N))
+        ser[0:4] = np.nan
+        ser[6:10] = 0
+
+        # replace list with a single value
+        return_value = ser.replace([np.nan], -1, inplace=True)
+        assert return_value is None
+
+        exp = ser.fillna(-1)
+        tm.assert_series_equal(ser, exp)
+
+        rs = ser.replace(0.0, np.nan)
+        ser[ser == 0.0] = np.nan
+        tm.assert_series_equal(rs, ser)
+
+        ser = pd.Series(
+            np.fabs(np.random.default_rng(2).standard_normal(N)),
+            pd.date_range("2020-01-01", periods=N),
+            dtype=object,
+        )
+        ser[:5] = np.nan
+        ser[6:10] = "foo"
+        ser[20:30] = "bar"
+
+        # replace list with a single value
+        msg = "Downcasting behavior in `replace`"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs = ser.replace([np.nan, "foo", "bar"], -1)
+
+        assert (rs[:5] == -1).all()
+        assert (rs[6:10] == -1).all()
+        assert (rs[20:30] == -1).all()
+        assert (pd.isna(ser[:5])).all()
+
+        # replace with different values
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs = ser.replace({np.nan: -1, "foo": -2, "bar": -3})
+
+        assert (rs[:5] == -1).all()
+        assert (rs[6:10] == -2).all()
+        assert (rs[20:30] == -3).all()
+        assert (pd.isna(ser[:5])).all()
+
+        # replace with different values with 2 lists
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs2 = ser.replace([np.nan, "foo", "bar"], [-1, -2, -3])
+        tm.assert_series_equal(rs, rs2)
+
+        # replace inplace
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            return_value = ser.replace([np.nan, "foo", "bar"], -1, inplace=True)
+        assert return_value is None
+
+        assert (ser[:5] == -1).all()
+        assert (ser[6:10] == -1).all()
+        assert (ser[20:30] == -1).all()
+
+    def test_replace_nan_with_inf(self):
+        ser = pd.Series([np.nan, 0, np.inf])
+        tm.assert_series_equal(ser.replace(np.nan, 0), ser.fillna(0))
+
+        ser = pd.Series([np.nan, 0, "foo", "bar", np.inf, None, pd.NaT])
+        tm.assert_series_equal(ser.replace(np.nan, 0), ser.fillna(0))
+        filled = ser.copy()
+        filled[4] = 0
+        tm.assert_series_equal(ser.replace(np.inf, 0), filled)
+
+    def test_replace_listlike_value_listlike_target(self, datetime_series):
+        ser = pd.Series(datetime_series.index)
+        tm.assert_series_equal(ser.replace(np.nan, 0), ser.fillna(0))
+
+        # malformed
+        msg = r"Replacement lists must match in length\. Expecting 3 got 2"
+        with pytest.raises(ValueError, match=msg):
+            ser.replace([1, 2, 3], [np.nan, 0])
+
+        # ser is dt64 so can't hold 1 or 2, so this replace is a no-op
+        result = ser.replace([1, 2], [np.nan, 0])
+        tm.assert_series_equal(result, ser)
+
+        ser = pd.Series([0, 1, 2, 3, 4])
+        result = ser.replace([0, 1, 2, 3, 4], [4, 3, 2, 1, 0])
+        tm.assert_series_equal(result, pd.Series([4, 3, 2, 1, 0]))
+
+    def test_replace_gh5319(self):
+        # API change from 0.12?
+        # GH 5319
+        ser = pd.Series([0, np.nan, 2, 3, 4])
+        expected = ser.ffill()
+        msg = (
+            "Series.replace without 'value' and with non-dict-like "
+            "'to_replace' is deprecated"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = ser.replace([np.nan])
+        tm.assert_series_equal(result, expected)
+
+        ser = pd.Series([0, np.nan, 2, 3, 4])
+        expected = ser.ffill()
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = ser.replace(np.nan)
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_datetime64(self):
+        # GH 5797
+        ser = pd.Series(pd.date_range("20130101", periods=5))
+        expected = ser.copy()
+        expected.loc[2] = pd.Timestamp("20120101")
+        result = ser.replace({pd.Timestamp("20130103"): pd.Timestamp("20120101")})
+        tm.assert_series_equal(result, expected)
+        result = ser.replace(pd.Timestamp("20130103"), pd.Timestamp("20120101"))
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_nat_with_tz(self):
+        # GH 11792: Test with replacing NaT in a list with tz data
+        ts = pd.Timestamp("2015/01/01", tz="UTC")
+        s = pd.Series([pd.NaT, pd.Timestamp("2015/01/01", tz="UTC")])
+        result = s.replace([np.nan, pd.NaT], pd.Timestamp.min)
+        expected = pd.Series([pd.Timestamp.min, ts], dtype=object)
+        tm.assert_series_equal(expected, result)
+
+    def test_replace_timedelta_td64(self):
+        tdi = pd.timedelta_range(0, periods=5)
+        ser = pd.Series(tdi)
+
+        # Using a single dict argument means we go through replace_list
+        result = ser.replace({ser[1]: ser[3]})
+
+        expected = pd.Series([ser[0], ser[3], ser[2], ser[3], ser[4]])
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_with_single_list(self):
+        ser = pd.Series([0, 1, 2, 3, 4])
+        msg2 = (
+            "Series.replace without 'value' and with non-dict-like "
+            "'to_replace' is deprecated"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg2):
+            result = ser.replace([1, 2, 3])
+        tm.assert_series_equal(result, pd.Series([0, 0, 0, 0, 4]))
+
+        s = ser.copy()
+        with tm.assert_produces_warning(FutureWarning, match=msg2):
+            return_value = s.replace([1, 2, 3], inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(s, pd.Series([0, 0, 0, 0, 4]))
+
+        # make sure things don't get corrupted when fillna call fails
+        s = ser.copy()
+        msg = (
+            r"Invalid fill method\. Expecting pad \(ffill\) or backfill "
+            r"\(bfill\)\. Got crash_cymbal"
+        )
+        msg3 = "The 'method' keyword in Series.replace is deprecated"
+        with pytest.raises(ValueError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=msg3):
+                return_value = s.replace([1, 2, 3], inplace=True, method="crash_cymbal")
+            assert return_value is None
+        tm.assert_series_equal(s, ser)
+
+    def test_replace_mixed_types(self):
+        ser = pd.Series(np.arange(5), dtype="int64")
+
+        def check_replace(to_rep, val, expected):
+            sc = ser.copy()
+            result = ser.replace(to_rep, val)
+            return_value = sc.replace(to_rep, val, inplace=True)
+            assert return_value is None
+            tm.assert_series_equal(expected, result)
+            tm.assert_series_equal(expected, sc)
+
+        # 3.0 can still be held in our int64 series, so we do not upcast GH#44940
+        tr, v = [3], [3.0]
+        check_replace(tr, v, ser)
+        # Note this matches what we get with the scalars 3 and 3.0
+        check_replace(tr[0], v[0], ser)
+
+        # MUST upcast to float
+        e = pd.Series([0, 1, 2, 3.5, 4])
+        tr, v = [3], [3.5]
+        check_replace(tr, v, e)
+
+        # casts to object
+        e = pd.Series([0, 1, 2, 3.5, "a"])
+        tr, v = [3, 4], [3.5, "a"]
+        check_replace(tr, v, e)
+
+        # again casts to object
+        e = pd.Series([0, 1, 2, 3.5, pd.Timestamp("20130101")])
+        tr, v = [3, 4], [3.5, pd.Timestamp("20130101")]
+        check_replace(tr, v, e)
+
+        # casts to object
+        e = pd.Series([0, 1, 2, 3.5, True], dtype="object")
+        tr, v = [3, 4], [3.5, True]
+        check_replace(tr, v, e)
+
+        # test an object with dates + floats + integers + strings
+        dr = pd.Series(pd.date_range("1/1/2001", "1/10/2001", freq="D"))
+        result = dr.astype(object).replace([dr[0], dr[1], dr[2]], [1.0, 2, "a"])
+        expected = pd.Series([1.0, 2, "a"] + dr[3:].tolist(), dtype=object)
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_bool_with_string_no_op(self):
+        s = pd.Series([True, False, True])
+        result = s.replace("fun", "in-the-sun")
+        tm.assert_series_equal(s, result)
+
+    def test_replace_bool_with_string(self):
+        # nonexistent elements
+        s = pd.Series([True, False, True])
+        result = s.replace(True, "2u")
+        expected = pd.Series(["2u", False, "2u"])
+        tm.assert_series_equal(expected, result)
+
+    def test_replace_bool_with_bool(self):
+        s = pd.Series([True, False, True])
+        result = s.replace(True, False)
+        expected = pd.Series([False] * len(s))
+        tm.assert_series_equal(expected, result)
+
+    def test_replace_with_dict_with_bool_keys(self):
+        s = pd.Series([True, False, True])
+        result = s.replace({"asdf": "asdb", True: "yes"})
+        expected = pd.Series(["yes", False, "yes"])
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_Int_with_na(self, any_int_ea_dtype):
+        # GH 38267
+        result = pd.Series([0, None], dtype=any_int_ea_dtype).replace(0, pd.NA)
+        expected = pd.Series([pd.NA, pd.NA], dtype=any_int_ea_dtype)
+        tm.assert_series_equal(result, expected)
+        result = pd.Series([0, 1], dtype=any_int_ea_dtype).replace(0, pd.NA)
+        result.replace(1, pd.NA, inplace=True)
+        tm.assert_series_equal(result, expected)
+
+    def test_replace2(self):
+        N = 50
+        ser = pd.Series(
+            np.fabs(np.random.default_rng(2).standard_normal(N)),
+            pd.date_range("2020-01-01", periods=N),
+            dtype=object,
+        )
+        ser[:5] = np.nan
+        ser[6:10] = "foo"
+        ser[20:30] = "bar"
+
+        # replace list with a single value
+        msg = "Downcasting behavior in `replace`"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs = ser.replace([np.nan, "foo", "bar"], -1)
+
+        assert (rs[:5] == -1).all()
+        assert (rs[6:10] == -1).all()
+        assert (rs[20:30] == -1).all()
+        assert (pd.isna(ser[:5])).all()
+
+        # replace with different values
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs = ser.replace({np.nan: -1, "foo": -2, "bar": -3})
+
+        assert (rs[:5] == -1).all()
+        assert (rs[6:10] == -2).all()
+        assert (rs[20:30] == -3).all()
+        assert (pd.isna(ser[:5])).all()
+
+        # replace with different values with 2 lists
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs2 = ser.replace([np.nan, "foo", "bar"], [-1, -2, -3])
+        tm.assert_series_equal(rs, rs2)
+
+        # replace inplace
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            return_value = ser.replace([np.nan, "foo", "bar"], -1, inplace=True)
+        assert return_value is None
+        assert (ser[:5] == -1).all()
+        assert (ser[6:10] == -1).all()
+        assert (ser[20:30] == -1).all()
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    def test_replace_cascade(self, inplace):
+        # Test that replaced values are not replaced again
+        # GH #50778
+        ser = pd.Series([1, 2, 3])
+        expected = pd.Series([2, 3, 4])
+
+        res = ser.replace([1, 2, 3], [2, 3, 4], inplace=inplace)
+        if inplace:
+            tm.assert_series_equal(ser, expected)
+        else:
+            tm.assert_series_equal(res, expected)
+
+    def test_replace_with_dictlike_and_string_dtype(self, nullable_string_dtype):
+        # GH 32621, GH#44940
+        ser = pd.Series(["one", "two", np.nan], dtype=nullable_string_dtype)
+        expected = pd.Series(["1", "2", np.nan], dtype=nullable_string_dtype)
+        result = ser.replace({"one": "1", "two": "2"})
+        tm.assert_series_equal(expected, result)
+
+    def test_replace_with_empty_dictlike(self):
+        # GH 15289
+        s = pd.Series(list("abcd"))
+        tm.assert_series_equal(s, s.replace({}))
+
+        empty_series = pd.Series([])
+        tm.assert_series_equal(s, s.replace(empty_series))
+
+    def test_replace_string_with_number(self):
+        # GH 15743
+        s = pd.Series([1, 2, 3])
+        result = s.replace("2", np.nan)
+        expected = pd.Series([1, 2, 3])
+        tm.assert_series_equal(expected, result)
+
+    def test_replace_replacer_equals_replacement(self):
+        # GH 20656
+        # make sure all replacers are matching against original values
+        s = pd.Series(["a", "b"])
+        expected = pd.Series(["b", "a"])
+        result = s.replace({"a": "b", "b": "a"})
+        tm.assert_series_equal(expected, result)
+
+    def test_replace_unicode_with_number(self):
+        # GH 15743
+        s = pd.Series([1, 2, 3])
+        result = s.replace("2", np.nan)
+        expected = pd.Series([1, 2, 3])
+        tm.assert_series_equal(expected, result)
+
+    def test_replace_mixed_types_with_string(self):
+        # Testing mixed
+        s = pd.Series([1, 2, 3, "4", 4, 5])
+        msg = "Downcasting behavior in `replace`"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = s.replace([2, "4"], np.nan)
+        expected = pd.Series([1, np.nan, 3, np.nan, 4, 5])
+        tm.assert_series_equal(expected, result)
+
+    @pytest.mark.xfail(using_pyarrow_string_dtype(), reason="can't fill 0 in string")
+    @pytest.mark.parametrize(
+        "categorical, numeric",
+        [
+            (pd.Categorical(["A"], categories=["A", "B"]), [1]),
+            (pd.Categorical(["A", "B"], categories=["A", "B"]), [1, 2]),
+        ],
+    )
+    def test_replace_categorical(self, categorical, numeric):
+        # GH 24971, GH#23305
+        ser = pd.Series(categorical)
+        msg = "Downcasting behavior in `replace`"
+        msg = "with CategoricalDtype is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = ser.replace({"A": 1, "B": 2})
+        expected = pd.Series(numeric).astype("category")
+        if 2 not in expected.cat.categories:
+            # i.e. categories should be [1, 2] even if there are no "B"s present
+            # GH#44940
+            expected = expected.cat.add_categories(2)
+        tm.assert_series_equal(expected, result)
+
+    @pytest.mark.parametrize(
+        "data, data_exp", [(["a", "b", "c"], ["b", "b", "c"]), (["a"], ["b"])]
+    )
+    def test_replace_categorical_inplace(self, data, data_exp):
+        # GH 53358
+        result = pd.Series(data, dtype="category")
+        msg = "with CategoricalDtype is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result.replace(to_replace="a", value="b", inplace=True)
+        expected = pd.Series(data_exp, dtype="category")
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_categorical_single(self):
+        # GH 26988
+        dti = pd.date_range("2016-01-01", periods=3, tz="US/Pacific")
+        s = pd.Series(dti)
+        c = s.astype("category")
+
+        expected = c.copy()
+        expected = expected.cat.add_categories("foo")
+        expected[2] = "foo"
+        expected = expected.cat.remove_unused_categories()
+        assert c[2] != "foo"
+
+        msg = "with CategoricalDtype is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = c.replace(c[2], "foo")
+        tm.assert_series_equal(expected, result)
+        assert c[2] != "foo"  # ensure non-inplace call does not alter original
+
+        msg = "with CategoricalDtype is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            return_value = c.replace(c[2], "foo", inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(expected, c)
+
+        first_value = c[0]
+        msg = "with CategoricalDtype is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            return_value = c.replace(c[1], c[0], inplace=True)
+        assert return_value is None
+        assert c[0] == c[1] == first_value  # test replacing with existing value
+
+    def test_replace_with_no_overflowerror(self):
+        # GH 25616
+        # casts to object without Exception from OverflowError
+        s = pd.Series([0, 1, 2, 3, 4])
+        result = s.replace([3], ["100000000000000000000"])
+        expected = pd.Series([0, 1, 2, "100000000000000000000", 4])
+        tm.assert_series_equal(result, expected)
+
+        s = pd.Series([0, "100000000000000000000", "100000000000000000001"])
+        result = s.replace(["100000000000000000000"], [1])
+        expected = pd.Series([0, 1, "100000000000000000001"])
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "ser, to_replace, exp",
+        [
+            ([1, 2, 3], {1: 2, 2: 3, 3: 4}, [2, 3, 4]),
+            (["1", "2", "3"], {"1": "2", "2": "3", "3": "4"}, ["2", "3", "4"]),
+        ],
+    )
+    def test_replace_commutative(self, ser, to_replace, exp):
+        # GH 16051
+        # DataFrame.replace() overwrites when values are non-numeric
+
+        series = pd.Series(ser)
+
+        expected = pd.Series(exp)
+        result = series.replace(to_replace)
+
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "ser, exp", [([1, 2, 3], [1, True, 3]), (["x", 2, 3], ["x", True, 3])]
+    )
+    def test_replace_no_cast(self, ser, exp):
+        # GH 9113
+        # BUG: replace int64 dtype with bool coerces to int64
+
+        series = pd.Series(ser)
+        result = series.replace(2, True)
+        expected = pd.Series(exp)
+
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_invalid_to_replace(self):
+        # GH 18634
+        # API: replace() should raise an exception if invalid argument is given
+        series = pd.Series(["a", "b", "c "])
+        msg = (
+            r"Expecting 'to_replace' to be either a scalar, array-like, "
+            r"dict or None, got invalid type.*"
+        )
+        msg2 = (
+            "Series.replace without 'value' and with non-dict-like "
+            "'to_replace' is deprecated"
+        )
+        with pytest.raises(TypeError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=msg2):
+                series.replace(lambda x: x.strip())
+
+    @pytest.mark.parametrize("frame", [False, True])
+    def test_replace_nonbool_regex(self, frame):
+        obj = pd.Series(["a", "b", "c "])
+        if frame:
+            obj = obj.to_frame()
+
+        msg = "'to_replace' must be 'None' if 'regex' is not a bool"
+        with pytest.raises(ValueError, match=msg):
+            obj.replace(to_replace=["a"], regex="foo")
+
+    @pytest.mark.parametrize("frame", [False, True])
+    def test_replace_empty_copy(self, frame):
+        obj = pd.Series([], dtype=np.float64)
+        if frame:
+            obj = obj.to_frame()
+
+        res = obj.replace(4, 5, inplace=True)
+        assert res is None
+
+        res = obj.replace(4, 5, inplace=False)
+        tm.assert_equal(res, obj)
+        assert res is not obj
+
+    def test_replace_only_one_dictlike_arg(self, fixed_now_ts):
+        # GH#33340
+
+        ser = pd.Series([1, 2, "A", fixed_now_ts, True])
+        to_replace = {0: 1, 2: "A"}
+        value = "foo"
+        msg = "Series.replace cannot use dict-like to_replace and non-None value"
+        with pytest.raises(ValueError, match=msg):
+            ser.replace(to_replace, value)
+
+        to_replace = 1
+        value = {0: "foo", 2: "bar"}
+        msg = "Series.replace cannot use dict-value and non-None to_replace"
+        with pytest.raises(ValueError, match=msg):
+            ser.replace(to_replace, value)
+
+    def test_replace_extension_other(self, frame_or_series):
+        # https://github.com/pandas-dev/pandas/issues/34530
+        obj = frame_or_series(pd.array([1, 2, 3], dtype="Int64"))
+        result = obj.replace("", "")  # no exception
+        # should not have changed dtype
+        tm.assert_equal(obj, result)
+
+    def _check_replace_with_method(self, ser: pd.Series):
+        df = ser.to_frame()
+
+        msg1 = "The 'method' keyword in Series.replace is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg1):
+            res = ser.replace(ser[1], method="pad")
+        expected = pd.Series([ser[0], ser[0]] + list(ser[2:]), dtype=ser.dtype)
+        tm.assert_series_equal(res, expected)
+
+        msg2 = "The 'method' keyword in DataFrame.replace is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg2):
+            res_df = df.replace(ser[1], method="pad")
+        tm.assert_frame_equal(res_df, expected.to_frame())
+
+        ser2 = ser.copy()
+        with tm.assert_produces_warning(FutureWarning, match=msg1):
+            res2 = ser2.replace(ser[1], method="pad", inplace=True)
+        assert res2 is None
+        tm.assert_series_equal(ser2, expected)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg2):
+            res_df2 = df.replace(ser[1], method="pad", inplace=True)
+        assert res_df2 is None
+        tm.assert_frame_equal(df, expected.to_frame())
+
+    def test_replace_ea_dtype_with_method(self, any_numeric_ea_dtype):
+        arr = pd.array([1, 2, pd.NA, 4], dtype=any_numeric_ea_dtype)
+        ser = pd.Series(arr)
+
+        self._check_replace_with_method(ser)
+
+    @pytest.mark.parametrize("as_categorical", [True, False])
+    def test_replace_interval_with_method(self, as_categorical):
+        # in particular interval that can't hold NA
+
+        idx = pd.IntervalIndex.from_breaks(range(4))
+        ser = pd.Series(idx)
+        if as_categorical:
+            ser = ser.astype("category")
+
+        self._check_replace_with_method(ser)
+
+    @pytest.mark.parametrize("as_period", [True, False])
+    @pytest.mark.parametrize("as_categorical", [True, False])
+    def test_replace_datetimelike_with_method(self, as_period, as_categorical):
+        idx = pd.date_range("2016-01-01", periods=5, tz="US/Pacific")
+        if as_period:
+            idx = idx.tz_localize(None).to_period("D")
+
+        ser = pd.Series(idx)
+        ser.iloc[-2] = pd.NaT
+        if as_categorical:
+            ser = ser.astype("category")
+
+        self._check_replace_with_method(ser)
+
+    def test_replace_with_compiled_regex(self):
+        # https://github.com/pandas-dev/pandas/issues/35680
+        s = pd.Series(["a", "b", "c"])
+        regex = re.compile("^a$")
+        result = s.replace({regex: "z"}, regex=True)
+        expected = pd.Series(["z", "b", "c"])
+        tm.assert_series_equal(result, expected)
+
+    def test_pandas_replace_na(self):
+        # GH#43344
+        ser = pd.Series(["AA", "BB", "CC", "DD", "EE", "", pd.NA], dtype="string")
+        regex_mapping = {
+            "AA": "CC",
+            "BB": "CC",
+            "EE": "CC",
+            "CC": "CC-REPL",
+        }
+        result = ser.replace(regex_mapping, regex=True)
+        exp = pd.Series(["CC", "CC", "CC-REPL", "DD", "CC", "", pd.NA], dtype="string")
+        tm.assert_series_equal(result, exp)
+
+    @pytest.mark.parametrize(
+        "dtype, input_data, to_replace, expected_data",
+        [
+            ("bool", [True, False], {True: False}, [False, False]),
+            ("int64", [1, 2], {1: 10, 2: 20}, [10, 20]),
+            ("Int64", [1, 2], {1: 10, 2: 20}, [10, 20]),
+            ("float64", [1.1, 2.2], {1.1: 10.1, 2.2: 20.5}, [10.1, 20.5]),
+            ("Float64", [1.1, 2.2], {1.1: 10.1, 2.2: 20.5}, [10.1, 20.5]),
+            ("string", ["one", "two"], {"one": "1", "two": "2"}, ["1", "2"]),
+            (
+                pd.IntervalDtype("int64"),
+                IntervalArray([pd.Interval(1, 2), pd.Interval(2, 3)]),
+                {pd.Interval(1, 2): pd.Interval(10, 20)},
+                IntervalArray([pd.Interval(10, 20), pd.Interval(2, 3)]),
+            ),
+            (
+                pd.IntervalDtype("float64"),
+                IntervalArray([pd.Interval(1.0, 2.7), pd.Interval(2.8, 3.1)]),
+                {pd.Interval(1.0, 2.7): pd.Interval(10.6, 20.8)},
+                IntervalArray([pd.Interval(10.6, 20.8), pd.Interval(2.8, 3.1)]),
+            ),
+            (
+                pd.PeriodDtype("M"),
+                [pd.Period("2020-05", freq="M")],
+                {pd.Period("2020-05", freq="M"): pd.Period("2020-06", freq="M")},
+                [pd.Period("2020-06", freq="M")],
+            ),
+        ],
+    )
+    def test_replace_dtype(self, dtype, input_data, to_replace, expected_data):
+        # GH#33484
+        ser = pd.Series(input_data, dtype=dtype)
+        result = ser.replace(to_replace)
+        expected = pd.Series(expected_data, dtype=dtype)
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_string_dtype(self):
+        # GH#40732, GH#44940
+        ser = pd.Series(["one", "two", np.nan], dtype="string")
+        res = ser.replace({"one": "1", "two": "2"})
+        expected = pd.Series(["1", "2", np.nan], dtype="string")
+        tm.assert_series_equal(res, expected)
+
+        # GH#31644
+        ser2 = pd.Series(["A", np.nan], dtype="string")
+        res2 = ser2.replace("A", "B")
+        expected2 = pd.Series(["B", np.nan], dtype="string")
+        tm.assert_series_equal(res2, expected2)
+
+        ser3 = pd.Series(["A", "B"], dtype="string")
+        res3 = ser3.replace("A", pd.NA)
+        expected3 = pd.Series([pd.NA, "B"], dtype="string")
+        tm.assert_series_equal(res3, expected3)
+
+    def test_replace_string_dtype_list_to_replace(self):
+        # GH#41215, GH#44940
+        ser = pd.Series(["abc", "def"], dtype="string")
+        res = ser.replace(["abc", "any other string"], "xyz")
+        expected = pd.Series(["xyz", "def"], dtype="string")
+        tm.assert_series_equal(res, expected)
+
+    def test_replace_string_dtype_regex(self):
+        # GH#31644
+        ser = pd.Series(["A", "B"], dtype="string")
+        res = ser.replace(r".", "C", regex=True)
+        expected = pd.Series(["C", "C"], dtype="string")
+        tm.assert_series_equal(res, expected)
+
+    def test_replace_nullable_numeric(self):
+        # GH#40732, GH#44940
+
+        floats = pd.Series([1.0, 2.0, 3.999, 4.4], dtype=pd.Float64Dtype())
+        assert floats.replace({1.0: 9}).dtype == floats.dtype
+        assert floats.replace(1.0, 9).dtype == floats.dtype
+        assert floats.replace({1.0: 9.0}).dtype == floats.dtype
+        assert floats.replace(1.0, 9.0).dtype == floats.dtype
+
+        res = floats.replace(to_replace=[1.0, 2.0], value=[9.0, 10.0])
+        assert res.dtype == floats.dtype
+
+        ints = pd.Series([1, 2, 3, 4], dtype=pd.Int64Dtype())
+        assert ints.replace({1: 9}).dtype == ints.dtype
+        assert ints.replace(1, 9).dtype == ints.dtype
+        assert ints.replace({1: 9.0}).dtype == ints.dtype
+        assert ints.replace(1, 9.0).dtype == ints.dtype
+
+        # nullable (for now) raises instead of casting
+        with pytest.raises(TypeError, match="Invalid value"):
+            ints.replace({1: 9.5})
+        with pytest.raises(TypeError, match="Invalid value"):
+            ints.replace(1, 9.5)
+
+    @pytest.mark.xfail(using_pyarrow_string_dtype(), reason="can't fill 1 in string")
+    @pytest.mark.parametrize("regex", [False, True])
+    def test_replace_regex_dtype_series(self, regex):
+        # GH-48644
+        series = pd.Series(["0"])
+        expected = pd.Series([1])
+        msg = "Downcasting behavior in `replace`"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = series.replace(to_replace="0", value=1, regex=regex)
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_different_int_types(self, any_int_numpy_dtype):
+        # GH#45311
+        labs = pd.Series([1, 1, 1, 0, 0, 2, 2, 2], dtype=any_int_numpy_dtype)
+
+        maps = pd.Series([0, 2, 1], dtype=any_int_numpy_dtype)
+        map_dict = dict(zip(maps.values, maps.index))
+
+        result = labs.replace(map_dict)
+        expected = labs.replace({0: 0, 2: 1, 1: 2})
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("val", [2, np.nan, 2.0])
+    def test_replace_value_none_dtype_numeric(self, val):
+        # GH#48231
+        ser = pd.Series([1, val])
+        result = ser.replace(val, None)
+        expected = pd.Series([1, None], dtype=object)
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_change_dtype_series(self, using_infer_string):
+        # GH#25797
+        df = pd.DataFrame.from_dict({"Test": ["0.5", True, "0.6"]})
+        warn = FutureWarning if using_infer_string else None
+        with tm.assert_produces_warning(warn, match="Downcasting"):
+            df["Test"] = df["Test"].replace([True], [np.nan])
+        expected = pd.DataFrame.from_dict({"Test": ["0.5", np.nan, "0.6"]})
+        tm.assert_frame_equal(df, expected)
+
+        df = pd.DataFrame.from_dict({"Test": ["0.5", None, "0.6"]})
+        df["Test"] = df["Test"].replace([None], [np.nan])
+        tm.assert_frame_equal(df, expected)
+
+        df = pd.DataFrame.from_dict({"Test": ["0.5", None, "0.6"]})
+        df["Test"] = df["Test"].fillna(np.nan)
+        tm.assert_frame_equal(df, expected)
+
+    @pytest.mark.parametrize("dtype", ["object", "Int64"])
+    def test_replace_na_in_obj_column(self, dtype):
+        # GH#47480
+        ser = pd.Series([0, 1, pd.NA], dtype=dtype)
+        expected = pd.Series([0, 2, pd.NA], dtype=dtype)
+        result = ser.replace(to_replace=1, value=2)
+        tm.assert_series_equal(result, expected)
+
+        ser.replace(to_replace=1, value=2, inplace=True)
+        tm.assert_series_equal(ser, expected)
+
+    @pytest.mark.parametrize("val", [0, 0.5])
+    def test_replace_numeric_column_with_na(self, val):
+        # GH#50758
+        ser = pd.Series([val, 1])
+        expected = pd.Series([val, pd.NA])
+        result = ser.replace(to_replace=1, value=pd.NA)
+        tm.assert_series_equal(result, expected)
+
+        ser.replace(to_replace=1, value=pd.NA, inplace=True)
+        tm.assert_series_equal(ser, expected)
+
+    def test_replace_ea_float_with_bool(self):
+        # GH#55398
+        ser = pd.Series([0.0], dtype="Float64")
+        expected = ser.copy()
+        result = ser.replace(False, 1.0)
+        tm.assert_series_equal(result, expected)
+
+        ser = pd.Series([False], dtype="boolean")
+        expected = ser.copy()
+        result = ser.replace(0.0, True)
+        tm.assert_series_equal(result, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_reset_index.py

@@ -0,0 +1,225 @@
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    RangeIndex,
+    Series,
+    date_range,
+    option_context,
+)
+import pandas._testing as tm
+
+
+class TestResetIndex:
+    def test_reset_index_dti_round_trip(self):
+        dti = date_range(start="1/1/2001", end="6/1/2001", freq="D")._with_freq(None)
+        d1 = DataFrame({"v": np.random.default_rng(2).random(len(dti))}, index=dti)
+        d2 = d1.reset_index()
+        assert d2.dtypes.iloc[0] == np.dtype("M8[ns]")
+        d3 = d2.set_index("index")
+        tm.assert_frame_equal(d1, d3, check_names=False)
+
+        # GH#2329
+        stamp = datetime(2012, 11, 22)
+        df = DataFrame([[stamp, 12.1]], columns=["Date", "Value"])
+        df = df.set_index("Date")
+
+        assert df.index[0] == stamp
+        assert df.reset_index()["Date"].iloc[0] == stamp
+
+    def test_reset_index(self):
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )[:5]
+        ser = df.stack(future_stack=True)
+        ser.index.names = ["hash", "category"]
+
+        ser.name = "value"
+        df = ser.reset_index()
+        assert "value" in df
+
+        df = ser.reset_index(name="value2")
+        assert "value2" in df
+
+        # check inplace
+        s = ser.reset_index(drop=True)
+        s2 = ser
+        return_value = s2.reset_index(drop=True, inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(s, s2)
+
+        # level
+        index = MultiIndex(
+            levels=[["bar"], ["one", "two", "three"], [0, 1]],
+            codes=[[0, 0, 0, 0, 0, 0], [0, 1, 2, 0, 1, 2], [0, 1, 0, 1, 0, 1]],
+        )
+        s = Series(np.random.default_rng(2).standard_normal(6), index=index)
+        rs = s.reset_index(level=1)
+        assert len(rs.columns) == 2
+
+        rs = s.reset_index(level=[0, 2], drop=True)
+        tm.assert_index_equal(rs.index, Index(index.get_level_values(1)))
+        assert isinstance(rs, Series)
+
+    def test_reset_index_name(self):
+        s = Series([1, 2, 3], index=Index(range(3), name="x"))
+        assert s.reset_index().index.name is None
+        assert s.reset_index(drop=True).index.name is None
+
+    def test_reset_index_level(self):
+        df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=["A", "B", "C"])
+
+        for levels in ["A", "B"], [0, 1]:
+            # With MultiIndex
+            s = df.set_index(["A", "B"])["C"]
+
+            result = s.reset_index(level=levels[0])
+            tm.assert_frame_equal(result, df.set_index("B"))
+
+            result = s.reset_index(level=levels[:1])
+            tm.assert_frame_equal(result, df.set_index("B"))
+
+            result = s.reset_index(level=levels)
+            tm.assert_frame_equal(result, df)
+
+            result = df.set_index(["A", "B"]).reset_index(level=levels, drop=True)
+            tm.assert_frame_equal(result, df[["C"]])
+
+            with pytest.raises(KeyError, match="Level E "):
+                s.reset_index(level=["A", "E"])
+
+            # With single-level Index
+            s = df.set_index("A")["B"]
+
+            result = s.reset_index(level=levels[0])
+            tm.assert_frame_equal(result, df[["A", "B"]])
+
+            result = s.reset_index(level=levels[:1])
+            tm.assert_frame_equal(result, df[["A", "B"]])
+
+            result = s.reset_index(level=levels[0], drop=True)
+            tm.assert_series_equal(result, df["B"])
+
+            with pytest.raises(IndexError, match="Too many levels"):
+                s.reset_index(level=[0, 1, 2])
+
+        # Check that .reset_index([],drop=True) doesn't fail
+        result = Series(range(4)).reset_index([], drop=True)
+        expected = Series(range(4))
+        tm.assert_series_equal(result, expected)
+
+    def test_reset_index_range(self):
+        # GH 12071
+        s = Series(range(2), name="A", dtype="int64")
+        series_result = s.reset_index()
+        assert isinstance(series_result.index, RangeIndex)
+        series_expected = DataFrame(
+            [[0, 0], [1, 1]], columns=["index", "A"], index=RangeIndex(stop=2)
+        )
+        tm.assert_frame_equal(series_result, series_expected)
+
+    def test_reset_index_drop_errors(self):
+        #  GH 20925
+
+        # KeyError raised for series index when passed level name is missing
+        s = Series(range(4))
+        with pytest.raises(KeyError, match="does not match index name"):
+            s.reset_index("wrong", drop=True)
+        with pytest.raises(KeyError, match="does not match index name"):
+            s.reset_index("wrong")
+
+        # KeyError raised for series when level to be dropped is missing
+        s = Series(range(4), index=MultiIndex.from_product([[1, 2]] * 2))
+        with pytest.raises(KeyError, match="not found"):
+            s.reset_index("wrong", drop=True)
+
+    def test_reset_index_with_drop(self):
+        arrays = [
+            ["bar", "bar", "baz", "baz", "qux", "qux", "foo", "foo"],
+            ["one", "two", "one", "two", "one", "two", "one", "two"],
+        ]
+        tuples = zip(*arrays)
+        index = MultiIndex.from_tuples(tuples)
+        data = np.random.default_rng(2).standard_normal(8)
+        ser = Series(data, index=index)
+        ser.iloc[3] = np.nan
+
+        deleveled = ser.reset_index()
+        assert isinstance(deleveled, DataFrame)
+        assert len(deleveled.columns) == len(ser.index.levels) + 1
+        assert deleveled.index.name == ser.index.name
+
+        deleveled = ser.reset_index(drop=True)
+        assert isinstance(deleveled, Series)
+        assert deleveled.index.name == ser.index.name
+
+    def test_reset_index_inplace_and_drop_ignore_name(self):
+        # GH#44575
+        ser = Series(range(2), name="old")
+        ser.reset_index(name="new", drop=True, inplace=True)
+        expected = Series(range(2), name="old")
+        tm.assert_series_equal(ser, expected)
+
+    def test_reset_index_drop_infer_string(self):
+        # GH#56160
+        pytest.importorskip("pyarrow")
+        ser = Series(["a", "b", "c"], dtype=object)
+        with option_context("future.infer_string", True):
+            result = ser.reset_index(drop=True)
+        tm.assert_series_equal(result, ser)
+
+
+@pytest.mark.parametrize(
+    "array, dtype",
+    [
+        (["a", "b"], object),
+        (
+            pd.period_range("12-1-2000", periods=2, freq="Q-DEC"),
+            pd.PeriodDtype(freq="Q-DEC"),
+        ),
+    ],
+)
+def test_reset_index_dtypes_on_empty_series_with_multiindex(
+    array, dtype, using_infer_string
+):
+    # GH 19602 - Preserve dtype on empty Series with MultiIndex
+    idx = MultiIndex.from_product([[0, 1], [0.5, 1.0], array])
+    result = Series(dtype=object, index=idx)[:0].reset_index().dtypes
+    exp = "string" if using_infer_string else object
+    expected = Series(
+        {
+            "level_0": np.int64,
+            "level_1": np.float64,
+            "level_2": exp if dtype == object else dtype,
+            0: object,
+        }
+    )
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "names, expected_names",
+    [
+        (["A", "A"], ["A", "A"]),
+        (["level_1", None], ["level_1", "level_1"]),
+    ],
+)
+@pytest.mark.parametrize("allow_duplicates", [False, True])
+def test_column_name_duplicates(names, expected_names, allow_duplicates):
+    # GH#44755 reset_index with duplicate column labels
+    s = Series([1], index=MultiIndex.from_arrays([[1], [1]], names=names))
+    if allow_duplicates:
+        result = s.reset_index(allow_duplicates=True)
+        expected = DataFrame([[1, 1, 1]], columns=expected_names + [0])
+        tm.assert_frame_equal(result, expected)
+    else:
+        with pytest.raises(ValueError, match="cannot insert"):
+            s.reset_index()

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_round.py

@@ -0,0 +1,74 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import Series
+import pandas._testing as tm
+
+
+class TestSeriesRound:
+    def test_round(self, datetime_series):
+        datetime_series.index.name = "index_name"
+        result = datetime_series.round(2)
+        expected = Series(
+            np.round(datetime_series.values, 2), index=datetime_series.index, name="ts"
+        )
+        tm.assert_series_equal(result, expected)
+        assert result.name == datetime_series.name
+
+    def test_round_numpy(self, any_float_dtype):
+        # See GH#12600
+        ser = Series([1.53, 1.36, 0.06], dtype=any_float_dtype)
+        out = np.round(ser, decimals=0)
+        expected = Series([2.0, 1.0, 0.0], dtype=any_float_dtype)
+        tm.assert_series_equal(out, expected)
+
+        msg = "the 'out' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.round(ser, decimals=0, out=ser)
+
+    def test_round_numpy_with_nan(self, any_float_dtype):
+        # See GH#14197
+        ser = Series([1.53, np.nan, 0.06], dtype=any_float_dtype)
+        with tm.assert_produces_warning(None):
+            result = ser.round()
+        expected = Series([2.0, np.nan, 0.0], dtype=any_float_dtype)
+        tm.assert_series_equal(result, expected)
+
+    def test_round_builtin(self, any_float_dtype):
+        ser = Series(
+            [1.123, 2.123, 3.123],
+            index=range(3),
+            dtype=any_float_dtype,
+        )
+        result = round(ser)
+        expected_rounded0 = Series(
+            [1.0, 2.0, 3.0], index=range(3), dtype=any_float_dtype
+        )
+        tm.assert_series_equal(result, expected_rounded0)
+
+        decimals = 2
+        expected_rounded = Series(
+            [1.12, 2.12, 3.12], index=range(3), dtype=any_float_dtype
+        )
+        result = round(ser, decimals)
+        tm.assert_series_equal(result, expected_rounded)
+
+    @pytest.mark.parametrize("method", ["round", "floor", "ceil"])
+    @pytest.mark.parametrize("freq", ["s", "5s", "min", "5min", "h", "5h"])
+    def test_round_nat(self, method, freq, unit):
+        # GH14940, GH#56158
+        ser = Series([pd.NaT], dtype=f"M8[{unit}]")
+        expected = Series(pd.NaT, dtype=f"M8[{unit}]")
+        round_method = getattr(ser.dt, method)
+        result = round_method(freq)
+        tm.assert_series_equal(result, expected)
+
+    def test_round_ea_boolean(self):
+        # GH#55936
+        ser = Series([True, False], dtype="boolean")
+        expected = ser.copy()
+        result = ser.round(2)
+        tm.assert_series_equal(result, expected)
+        result.iloc[0] = False
+        tm.assert_series_equal(ser, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_searchsorted.py

@@ -0,0 +1,77 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Series,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+from pandas.api.types import is_scalar
+
+
+class TestSeriesSearchSorted:
+    def test_searchsorted(self):
+        ser = Series([1, 2, 3])
+
+        result = ser.searchsorted(1, side="left")
+        assert is_scalar(result)
+        assert result == 0
+
+        result = ser.searchsorted(1, side="right")
+        assert is_scalar(result)
+        assert result == 1
+
+    def test_searchsorted_numeric_dtypes_scalar(self):
+        ser = Series([1, 2, 90, 1000, 3e9])
+        res = ser.searchsorted(30)
+        assert is_scalar(res)
+        assert res == 2
+
+        res = ser.searchsorted([30])
+        exp = np.array([2], dtype=np.intp)
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_searchsorted_numeric_dtypes_vector(self):
+        ser = Series([1, 2, 90, 1000, 3e9])
+        res = ser.searchsorted([91, 2e6])
+        exp = np.array([3, 4], dtype=np.intp)
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_searchsorted_datetime64_scalar(self):
+        ser = Series(date_range("20120101", periods=10, freq="2D"))
+        val = Timestamp("20120102")
+        res = ser.searchsorted(val)
+        assert is_scalar(res)
+        assert res == 1
+
+    def test_searchsorted_datetime64_scalar_mixed_timezones(self):
+        # GH 30086
+        ser = Series(date_range("20120101", periods=10, freq="2D", tz="UTC"))
+        val = Timestamp("20120102", tz="America/New_York")
+        res = ser.searchsorted(val)
+        assert is_scalar(res)
+        assert res == 1
+
+    def test_searchsorted_datetime64_list(self):
+        ser = Series(date_range("20120101", periods=10, freq="2D"))
+        vals = [Timestamp("20120102"), Timestamp("20120104")]
+        res = ser.searchsorted(vals)
+        exp = np.array([1, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_searchsorted_sorter(self):
+        # GH8490
+        ser = Series([3, 1, 2])
+        res = ser.searchsorted([0, 3], sorter=np.argsort(ser))
+        exp = np.array([0, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_searchsorted_dataframe_fail(self):
+        # GH#49620
+        ser = Series([1, 2, 3, 4, 5])
+        vals = pd.DataFrame([[1, 2], [3, 4]])
+        msg = "Value must be 1-D array-like or scalar, DataFrame is not supported"
+        with pytest.raises(ValueError, match=msg):
+            ser.searchsorted(vals)

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_set_name.py

@@ -0,0 +1,21 @@
+from datetime import datetime
+
+from pandas import Series
+
+
+class TestSetName:
+    def test_set_name(self):
+        ser = Series([1, 2, 3])
+        ser2 = ser._set_name("foo")
+        assert ser2.name == "foo"
+        assert ser.name is None
+        assert ser is not ser2
+
+    def test_set_name_attribute(self):
+        ser = Series([1, 2, 3])
+        ser2 = Series([1, 2, 3], name="bar")
+        for name in [7, 7.0, "name", datetime(2001, 1, 1), (1,), "\u05D0"]:
+            ser.name = name
+            assert ser.name == name
+            ser2.name = name
+            assert ser2.name == name

env-llmeval/lib/python3.10/site-packages/pandas/tests/series/methods/test_size.py

@@ -0,0 +1,22 @@
+import pytest
+
+from pandas import Series
+
+
+@pytest.mark.parametrize(
+    "data, index, expected",
+    [
+        ([1, 2, 3], None, 3),
+        ({"a": 1, "b": 2, "c": 3}, None, 3),
+        ([1, 2, 3], ["x", "y", "z"], 3),
+        ([1, 2, 3, 4, 5], ["x", "y", "z", "w", "n"], 5),
+        ([1, 2, 3], None, 3),
+        ([1, 2, 3], ["x", "y", "z"], 3),
+        ([1, 2, 3, 4], ["x", "y", "z", "w"], 4),
+    ],
+)
+def test_series(data, index, expected):
+    # GH#52897
+    ser = Series(data, index=index)
+    assert ser.size == expected
+    assert isinstance(ser.size, int)