Add files using upload-large-folder tool

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

@@ -0,0 +1,179 @@
+from datetime import datetime
+import sys
+
+import numpy as np
+import pytest
+
+from pandas.compat import PYPY
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+)
+import pandas._testing as tm
+from pandas.core.accessor import PandasDelegate
+from pandas.core.base import (
+    NoNewAttributesMixin,
+    PandasObject,
+)
+
+
+def series_via_frame_from_dict(x, **kwargs):
+    return DataFrame({"a": x}, **kwargs)["a"]
+
+
+def series_via_frame_from_scalar(x, **kwargs):
+    return DataFrame(x, **kwargs)[0]
+
+
+@pytest.fixture(
+    params=[
+        Series,
+        series_via_frame_from_dict,
+        series_via_frame_from_scalar,
+        Index,
+    ],
+    ids=["Series", "DataFrame-dict", "DataFrame-array", "Index"],
+)
+def constructor(request):
+    return request.param
+
+
+class TestPandasDelegate:
+    class Delegator:
+        _properties = ["prop"]
+        _methods = ["test_method"]
+
+        def _set_prop(self, value):
+            self.prop = value
+
+        def _get_prop(self):
+            return self.prop
+
+        prop = property(_get_prop, _set_prop, doc="foo property")
+
+        def test_method(self, *args, **kwargs):
+            """a test method"""
+
+    class Delegate(PandasDelegate, PandasObject):
+        def __init__(self, obj) -> None:
+            self.obj = obj
+
+    def test_invalid_delegation(self):
+        # these show that in order for the delegation to work
+        # the _delegate_* methods need to be overridden to not raise
+        # a TypeError
+
+        self.Delegate._add_delegate_accessors(
+            delegate=self.Delegator,
+            accessors=self.Delegator._properties,
+            typ="property",
+        )
+        self.Delegate._add_delegate_accessors(
+            delegate=self.Delegator, accessors=self.Delegator._methods, typ="method"
+        )
+
+        delegate = self.Delegate(self.Delegator())
+
+        msg = "You cannot access the property prop"
+        with pytest.raises(TypeError, match=msg):
+            delegate.prop
+
+        msg = "The property prop cannot be set"
+        with pytest.raises(TypeError, match=msg):
+            delegate.prop = 5
+
+        msg = "You cannot access the property prop"
+        with pytest.raises(TypeError, match=msg):
+            delegate.prop
+
+    @pytest.mark.skipif(PYPY, reason="not relevant for PyPy")
+    def test_memory_usage(self):
+        # Delegate does not implement memory_usage.
+        # Check that we fall back to in-built `__sizeof__`
+        # GH 12924
+        delegate = self.Delegate(self.Delegator())
+        sys.getsizeof(delegate)
+
+
+class TestNoNewAttributesMixin:
+    def test_mixin(self):
+        class T(NoNewAttributesMixin):
+            pass
+
+        t = T()
+        assert not hasattr(t, "__frozen")
+
+        t.a = "test"
+        assert t.a == "test"
+
+        t._freeze()
+        assert "__frozen" in dir(t)
+        assert getattr(t, "__frozen")
+        msg = "You cannot add any new attribute"
+        with pytest.raises(AttributeError, match=msg):
+            t.b = "test"
+
+        assert not hasattr(t, "b")
+
+
+class TestConstruction:
+    # test certain constructor behaviours on dtype inference across Series,
+    # Index and DataFrame
+
+    @pytest.mark.parametrize(
+        "a",
+        [
+            np.array(["2263-01-01"], dtype="datetime64[D]"),
+            np.array([datetime(2263, 1, 1)], dtype=object),
+            np.array([np.datetime64("2263-01-01", "D")], dtype=object),
+            np.array(["2263-01-01"], dtype=object),
+        ],
+        ids=[
+            "datetime64[D]",
+            "object-datetime.datetime",
+            "object-numpy-scalar",
+            "object-string",
+        ],
+    )
+    def test_constructor_datetime_outofbound(
+        self, a, constructor, request, using_infer_string
+    ):
+        # GH-26853 (+ bug GH-26206 out of bound non-ns unit)
+
+        # No dtype specified (dtype inference)
+        # datetime64[non-ns] raise error, other cases result in object dtype
+        # and preserve original data
+        if a.dtype.kind == "M":
+            # Can't fit in nanosecond bounds -> get the nearest supported unit
+            result = constructor(a)
+            assert result.dtype == "M8[s]"
+        else:
+            result = constructor(a)
+            if using_infer_string and "object-string" in request.node.callspec.id:
+                assert result.dtype == "string"
+            else:
+                assert result.dtype == "object"
+            tm.assert_numpy_array_equal(result.to_numpy(), a)
+
+        # Explicit dtype specified
+        # Forced conversion fails for all -> all cases raise error
+        msg = "Out of bounds|Out of bounds .* present at position 0"
+        with pytest.raises(pd.errors.OutOfBoundsDatetime, match=msg):
+            constructor(a, dtype="datetime64[ns]")
+
+    def test_constructor_datetime_nonns(self, constructor):
+        arr = np.array(["2020-01-01T00:00:00.000000"], dtype="datetime64[us]")
+        dta = pd.core.arrays.DatetimeArray._simple_new(arr, dtype=arr.dtype)
+        expected = constructor(dta)
+        assert expected.dtype == arr.dtype
+
+        result = constructor(arr)
+        tm.assert_equal(result, expected)
+
+        # https://github.com/pandas-dev/pandas/issues/34843
+        arr.flags.writeable = False
+        result = constructor(arr)
+        tm.assert_equal(result, expected)

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

@@ -0,0 +1,56 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    CategoricalDtype,
+    DataFrame,
+)
+import pandas._testing as tm
+
+
+def test_transpose(index_or_series_obj):
+    obj = index_or_series_obj
+    tm.assert_equal(obj.transpose(), obj)
+
+
+def test_transpose_non_default_axes(index_or_series_obj):
+    msg = "the 'axes' parameter is not supported"
+    obj = index_or_series_obj
+    with pytest.raises(ValueError, match=msg):
+        obj.transpose(1)
+    with pytest.raises(ValueError, match=msg):
+        obj.transpose(axes=1)
+
+
+def test_numpy_transpose(index_or_series_obj):
+    msg = "the 'axes' parameter is not supported"
+    obj = index_or_series_obj
+    tm.assert_equal(np.transpose(obj), obj)
+
+    with pytest.raises(ValueError, match=msg):
+        np.transpose(obj, axes=1)
+
+
+@pytest.mark.parametrize(
+    "data, transposed_data, index, columns, dtype",
+    [
+        ([[1], [2]], [[1, 2]], ["a", "a"], ["b"], int),
+        ([[1], [2]], [[1, 2]], ["a", "a"], ["b"], CategoricalDtype([1, 2])),
+        ([[1, 2]], [[1], [2]], ["b"], ["a", "a"], int),
+        ([[1, 2]], [[1], [2]], ["b"], ["a", "a"], CategoricalDtype([1, 2])),
+        ([[1, 2], [3, 4]], [[1, 3], [2, 4]], ["a", "a"], ["b", "b"], int),
+        (
+            [[1, 2], [3, 4]],
+            [[1, 3], [2, 4]],
+            ["a", "a"],
+            ["b", "b"],
+            CategoricalDtype([1, 2, 3, 4]),
+        ),
+    ],
+)
+def test_duplicate_labels(data, transposed_data, index, columns, dtype):
+    # GH 42380
+    df = DataFrame(data, index=index, columns=columns, dtype=dtype)
+    result = df.T
+    expected = DataFrame(transposed_data, index=columns, columns=index, dtype=dtype)
+    tm.assert_frame_equal(result, expected)

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

@@ -0,0 +1,124 @@
+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.tests.base.common import allow_na_ops
+
+
+@pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
+def test_unique(index_or_series_obj):
+    obj = index_or_series_obj
+    obj = np.repeat(obj, range(1, len(obj) + 1))
+    result = obj.unique()
+
+    # dict.fromkeys preserves the order
+    unique_values = list(dict.fromkeys(obj.values))
+    if isinstance(obj, pd.MultiIndex):
+        expected = pd.MultiIndex.from_tuples(unique_values)
+        expected.names = obj.names
+        tm.assert_index_equal(result, expected, exact=True)
+    elif isinstance(obj, pd.Index):
+        expected = pd.Index(unique_values, dtype=obj.dtype)
+        if isinstance(obj.dtype, pd.DatetimeTZDtype):
+            expected = expected.normalize()
+        tm.assert_index_equal(result, expected, exact=True)
+    else:
+        expected = np.array(unique_values)
+        tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
+@pytest.mark.parametrize("null_obj", [np.nan, None])
+def test_unique_null(null_obj, index_or_series_obj):
+    obj = index_or_series_obj
+
+    if not allow_na_ops(obj):
+        pytest.skip("type doesn't allow for NA operations")
+    elif len(obj) < 1:
+        pytest.skip("Test doesn't make sense on empty data")
+    elif isinstance(obj, pd.MultiIndex):
+        pytest.skip(f"MultiIndex can't hold '{null_obj}'")
+
+    values = obj._values
+    values[0:2] = null_obj
+
+    klass = type(obj)
+    repeated_values = np.repeat(values, range(1, len(values) + 1))
+    obj = klass(repeated_values, dtype=obj.dtype)
+    result = obj.unique()
+
+    unique_values_raw = dict.fromkeys(obj.values)
+    # because np.nan == np.nan is False, but None == None is True
+    # np.nan would be duplicated, whereas None wouldn't
+    unique_values_not_null = [val for val in unique_values_raw if not pd.isnull(val)]
+    unique_values = [null_obj] + unique_values_not_null
+
+    if isinstance(obj, pd.Index):
+        expected = pd.Index(unique_values, dtype=obj.dtype)
+        if isinstance(obj.dtype, pd.DatetimeTZDtype):
+            result = result.normalize()
+            expected = expected.normalize()
+        tm.assert_index_equal(result, expected, exact=True)
+    else:
+        expected = np.array(unique_values, dtype=obj.dtype)
+        tm.assert_numpy_array_equal(result, expected)
+
+
+def test_nunique(index_or_series_obj):
+    obj = index_or_series_obj
+    obj = np.repeat(obj, range(1, len(obj) + 1))
+    expected = len(obj.unique())
+    assert obj.nunique(dropna=False) == expected
+
+
+@pytest.mark.parametrize("null_obj", [np.nan, None])
+def test_nunique_null(null_obj, index_or_series_obj):
+    obj = index_or_series_obj
+
+    if not allow_na_ops(obj):
+        pytest.skip("type doesn't allow for NA operations")
+    elif isinstance(obj, pd.MultiIndex):
+        pytest.skip(f"MultiIndex can't hold '{null_obj}'")
+
+    values = obj._values
+    values[0:2] = null_obj
+
+    klass = type(obj)
+    repeated_values = np.repeat(values, range(1, len(values) + 1))
+    obj = klass(repeated_values, dtype=obj.dtype)
+
+    if isinstance(obj, pd.CategoricalIndex):
+        assert obj.nunique() == len(obj.categories)
+        assert obj.nunique(dropna=False) == len(obj.categories) + 1
+    else:
+        num_unique_values = len(obj.unique())
+        assert obj.nunique() == max(0, num_unique_values - 1)
+        assert obj.nunique(dropna=False) == max(0, num_unique_values)
+
+
+@pytest.mark.single_cpu
+@pytest.mark.xfail(using_pyarrow_string_dtype(), reason="decoding fails")
+def test_unique_bad_unicode(index_or_series):
+    # regression test for #34550
+    uval = "\ud83d"  # smiley emoji
+
+    obj = index_or_series([uval] * 2)
+    result = obj.unique()
+
+    if isinstance(obj, pd.Index):
+        expected = pd.Index(["\ud83d"], dtype=object)
+        tm.assert_index_equal(result, expected, exact=True)
+    else:
+        expected = np.array(["\ud83d"], dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("dropna", [True, False])
+def test_nunique_dropna(dropna):
+    # GH37566
+    ser = pd.Series(["yes", "yes", pd.NA, np.nan, None, pd.NaT])
+    res = ser.nunique(dropna)
+    assert res == 1 if dropna else 5

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

@@ -0,0 +1,356 @@
+import collections
+from datetime import timedelta
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DatetimeIndex,
+    Index,
+    Interval,
+    IntervalIndex,
+    MultiIndex,
+    Series,
+    Timedelta,
+    TimedeltaIndex,
+    array,
+)
+import pandas._testing as tm
+from pandas.tests.base.common import allow_na_ops
+
+
+@pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
+def test_value_counts(index_or_series_obj):
+    obj = index_or_series_obj
+    obj = np.repeat(obj, range(1, len(obj) + 1))
+    result = obj.value_counts()
+
+    counter = collections.Counter(obj)
+    expected = Series(dict(counter.most_common()), dtype=np.int64, name="count")
+
+    if obj.dtype != np.float16:
+        expected.index = expected.index.astype(obj.dtype)
+    else:
+        with pytest.raises(NotImplementedError, match="float16 indexes are not "):
+            expected.index.astype(obj.dtype)
+        return
+    if isinstance(expected.index, MultiIndex):
+        expected.index.names = obj.names
+    else:
+        expected.index.name = obj.name
+
+    if not isinstance(result.dtype, np.dtype):
+        if getattr(obj.dtype, "storage", "") == "pyarrow":
+            expected = expected.astype("int64[pyarrow]")
+        else:
+            # i.e IntegerDtype
+            expected = expected.astype("Int64")
+
+    # TODO(GH#32514): Order of entries with the same count is inconsistent
+    #  on CI (gh-32449)
+    if obj.duplicated().any():
+        result = result.sort_index()
+        expected = expected.sort_index()
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("null_obj", [np.nan, None])
+@pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
+def test_value_counts_null(null_obj, index_or_series_obj):
+    orig = index_or_series_obj
+    obj = orig.copy()
+
+    if not allow_na_ops(obj):
+        pytest.skip("type doesn't allow for NA operations")
+    elif len(obj) < 1:
+        pytest.skip("Test doesn't make sense on empty data")
+    elif isinstance(orig, MultiIndex):
+        pytest.skip(f"MultiIndex can't hold '{null_obj}'")
+
+    values = obj._values
+    values[0:2] = null_obj
+
+    klass = type(obj)
+    repeated_values = np.repeat(values, range(1, len(values) + 1))
+    obj = klass(repeated_values, dtype=obj.dtype)
+
+    # because np.nan == np.nan is False, but None == None is True
+    # np.nan would be duplicated, whereas None wouldn't
+    counter = collections.Counter(obj.dropna())
+    expected = Series(dict(counter.most_common()), dtype=np.int64, name="count")
+
+    if obj.dtype != np.float16:
+        expected.index = expected.index.astype(obj.dtype)
+    else:
+        with pytest.raises(NotImplementedError, match="float16 indexes are not "):
+            expected.index.astype(obj.dtype)
+        return
+    expected.index.name = obj.name
+
+    result = obj.value_counts()
+    if obj.duplicated().any():
+        # TODO(GH#32514):
+        #  Order of entries with the same count is inconsistent on CI (gh-32449)
+        expected = expected.sort_index()
+        result = result.sort_index()
+
+    if not isinstance(result.dtype, np.dtype):
+        if getattr(obj.dtype, "storage", "") == "pyarrow":
+            expected = expected.astype("int64[pyarrow]")
+        else:
+            # i.e IntegerDtype
+            expected = expected.astype("Int64")
+    tm.assert_series_equal(result, expected)
+
+    expected[null_obj] = 3
+
+    result = obj.value_counts(dropna=False)
+    if obj.duplicated().any():
+        # TODO(GH#32514):
+        #  Order of entries with the same count is inconsistent on CI (gh-32449)
+        expected = expected.sort_index()
+        result = result.sort_index()
+    tm.assert_series_equal(result, expected)
+
+
+def test_value_counts_inferred(index_or_series, using_infer_string):
+    klass = index_or_series
+    s_values = ["a", "b", "b", "b", "b", "c", "d", "d", "a", "a"]
+    s = klass(s_values)
+    expected = Series([4, 3, 2, 1], index=["b", "a", "d", "c"], name="count")
+    tm.assert_series_equal(s.value_counts(), expected)
+
+    if isinstance(s, Index):
+        exp = Index(np.unique(np.array(s_values, dtype=np.object_)))
+        tm.assert_index_equal(s.unique(), exp)
+    else:
+        exp = np.unique(np.array(s_values, dtype=np.object_))
+        if using_infer_string:
+            exp = array(exp)
+        tm.assert_equal(s.unique(), exp)
+
+    assert s.nunique() == 4
+    # don't sort, have to sort after the fact as not sorting is
+    # platform-dep
+    hist = s.value_counts(sort=False).sort_values()
+    expected = Series([3, 1, 4, 2], index=list("acbd"), name="count").sort_values()
+    tm.assert_series_equal(hist, expected)
+
+    # sort ascending
+    hist = s.value_counts(ascending=True)
+    expected = Series([1, 2, 3, 4], index=list("cdab"), name="count")
+    tm.assert_series_equal(hist, expected)
+
+    # relative histogram.
+    hist = s.value_counts(normalize=True)
+    expected = Series(
+        [0.4, 0.3, 0.2, 0.1], index=["b", "a", "d", "c"], name="proportion"
+    )
+    tm.assert_series_equal(hist, expected)
+
+
+def test_value_counts_bins(index_or_series, using_infer_string):
+    klass = index_or_series
+    s_values = ["a", "b", "b", "b", "b", "c", "d", "d", "a", "a"]
+    s = klass(s_values)
+
+    # bins
+    msg = "bins argument only works with numeric data"
+    with pytest.raises(TypeError, match=msg):
+        s.value_counts(bins=1)
+
+    s1 = Series([1, 1, 2, 3])
+    res1 = s1.value_counts(bins=1)
+    exp1 = Series({Interval(0.997, 3.0): 4}, name="count")
+    tm.assert_series_equal(res1, exp1)
+    res1n = s1.value_counts(bins=1, normalize=True)
+    exp1n = Series({Interval(0.997, 3.0): 1.0}, name="proportion")
+    tm.assert_series_equal(res1n, exp1n)
+
+    if isinstance(s1, Index):
+        tm.assert_index_equal(s1.unique(), Index([1, 2, 3]))
+    else:
+        exp = np.array([1, 2, 3], dtype=np.int64)
+        tm.assert_numpy_array_equal(s1.unique(), exp)
+
+    assert s1.nunique() == 3
+
+    # these return the same
+    res4 = s1.value_counts(bins=4, dropna=True)
+    intervals = IntervalIndex.from_breaks([0.997, 1.5, 2.0, 2.5, 3.0])
+    exp4 = Series([2, 1, 1, 0], index=intervals.take([0, 1, 3, 2]), name="count")
+    tm.assert_series_equal(res4, exp4)
+
+    res4 = s1.value_counts(bins=4, dropna=False)
+    intervals = IntervalIndex.from_breaks([0.997, 1.5, 2.0, 2.5, 3.0])
+    exp4 = Series([2, 1, 1, 0], index=intervals.take([0, 1, 3, 2]), name="count")
+    tm.assert_series_equal(res4, exp4)
+
+    res4n = s1.value_counts(bins=4, normalize=True)
+    exp4n = Series(
+        [0.5, 0.25, 0.25, 0], index=intervals.take([0, 1, 3, 2]), name="proportion"
+    )
+    tm.assert_series_equal(res4n, exp4n)
+
+    # handle NA's properly
+    s_values = ["a", "b", "b", "b", np.nan, np.nan, "d", "d", "a", "a", "b"]
+    s = klass(s_values)
+    expected = Series([4, 3, 2], index=["b", "a", "d"], name="count")
+    tm.assert_series_equal(s.value_counts(), expected)
+
+    if isinstance(s, Index):
+        exp = Index(["a", "b", np.nan, "d"])
+        tm.assert_index_equal(s.unique(), exp)
+    else:
+        exp = np.array(["a", "b", np.nan, "d"], dtype=object)
+        if using_infer_string:
+            exp = array(exp)
+        tm.assert_equal(s.unique(), exp)
+    assert s.nunique() == 3
+
+    s = klass({}) if klass is dict else klass({}, dtype=object)
+    expected = Series([], dtype=np.int64, name="count")
+    tm.assert_series_equal(s.value_counts(), expected, check_index_type=False)
+    # returned dtype differs depending on original
+    if isinstance(s, Index):
+        tm.assert_index_equal(s.unique(), Index([]), exact=False)
+    else:
+        tm.assert_numpy_array_equal(s.unique(), np.array([]), check_dtype=False)
+
+    assert s.nunique() == 0
+
+
+def test_value_counts_datetime64(index_or_series, unit):
+    klass = index_or_series
+
+    # GH 3002, datetime64[ns]
+    # don't test names though
+    df = pd.DataFrame(
+        {
+            "person_id": ["xxyyzz", "xxyyzz", "xxyyzz", "xxyyww", "foofoo", "foofoo"],
+            "dt": pd.to_datetime(
+                [
+                    "2010-01-01",
+                    "2010-01-01",
+                    "2010-01-01",
+                    "2009-01-01",
+                    "2008-09-09",
+                    "2008-09-09",
+                ]
+            ).as_unit(unit),
+            "food": ["PIE", "GUM", "EGG", "EGG", "PIE", "GUM"],
+        }
+    )
+
+    s = klass(df["dt"].copy())
+    s.name = None
+    idx = pd.to_datetime(
+        ["2010-01-01 00:00:00", "2008-09-09 00:00:00", "2009-01-01 00:00:00"]
+    ).as_unit(unit)
+    expected_s = Series([3, 2, 1], index=idx, name="count")
+    tm.assert_series_equal(s.value_counts(), expected_s)
+
+    expected = array(
+        np.array(
+            ["2010-01-01 00:00:00", "2009-01-01 00:00:00", "2008-09-09 00:00:00"],
+            dtype=f"datetime64[{unit}]",
+        )
+    )
+    result = s.unique()
+    if isinstance(s, Index):
+        tm.assert_index_equal(result, DatetimeIndex(expected))
+    else:
+        tm.assert_extension_array_equal(result, expected)
+
+    assert s.nunique() == 3
+
+    # with NaT
+    s = df["dt"].copy()
+    s = klass(list(s.values) + [pd.NaT] * 4)
+    if klass is Series:
+        s = s.dt.as_unit(unit)
+    else:
+        s = s.as_unit(unit)
+
+    result = s.value_counts()
+    assert result.index.dtype == f"datetime64[{unit}]"
+    tm.assert_series_equal(result, expected_s)
+
+    result = s.value_counts(dropna=False)
+    expected_s = pd.concat(
+        [
+            Series([4], index=DatetimeIndex([pd.NaT]).as_unit(unit), name="count"),
+            expected_s,
+        ]
+    )
+    tm.assert_series_equal(result, expected_s)
+
+    assert s.dtype == f"datetime64[{unit}]"
+    unique = s.unique()
+    assert unique.dtype == f"datetime64[{unit}]"
+
+    # numpy_array_equal cannot compare pd.NaT
+    if isinstance(s, Index):
+        exp_idx = DatetimeIndex(expected.tolist() + [pd.NaT]).as_unit(unit)
+        tm.assert_index_equal(unique, exp_idx)
+    else:
+        tm.assert_extension_array_equal(unique[:3], expected)
+        assert pd.isna(unique[3])
+
+    assert s.nunique() == 3
+    assert s.nunique(dropna=False) == 4
+
+
+def test_value_counts_timedelta64(index_or_series, unit):
+    # timedelta64[ns]
+    klass = index_or_series
+
+    day = Timedelta(timedelta(1)).as_unit(unit)
+    tdi = TimedeltaIndex([day], name="dt").as_unit(unit)
+
+    tdvals = np.zeros(6, dtype=f"m8[{unit}]") + day
+    td = klass(tdvals, name="dt")
+
+    result = td.value_counts()
+    expected_s = Series([6], index=tdi, name="count")
+    tm.assert_series_equal(result, expected_s)
+
+    expected = tdi
+    result = td.unique()
+    if isinstance(td, Index):
+        tm.assert_index_equal(result, expected)
+    else:
+        tm.assert_extension_array_equal(result, expected._values)
+
+    td2 = day + np.zeros(6, dtype=f"m8[{unit}]")
+    td2 = klass(td2, name="dt")
+    result2 = td2.value_counts()
+    tm.assert_series_equal(result2, expected_s)
+
+
+@pytest.mark.parametrize("dropna", [True, False])
+def test_value_counts_with_nan(dropna, index_or_series):
+    # GH31944
+    klass = index_or_series
+    values = [True, pd.NA, np.nan]
+    obj = klass(values)
+    res = obj.value_counts(dropna=dropna)
+    if dropna is True:
+        expected = Series([1], index=Index([True], dtype=obj.dtype), name="count")
+    else:
+        expected = Series([1, 1, 1], index=[True, pd.NA, np.nan], name="count")
+    tm.assert_series_equal(res, expected)
+
+
+def test_value_counts_object_inference_deprecated():
+    # GH#56161
+    dti = pd.date_range("2016-01-01", periods=3, tz="UTC")
+
+    idx = dti.astype(object)
+    msg = "The behavior of value_counts with object-dtype is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        res = idx.value_counts()
+
+    exp = dti.value_counts()
+    tm.assert_series_equal(res, exp)

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

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

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

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

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

@@ -0,0 +1,209 @@
+from copy import deepcopy
+from operator import methodcaller
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestDataFrame:
+    @pytest.mark.parametrize("func", ["_set_axis_name", "rename_axis"])
+    def test_set_axis_name(self, func):
+        df = DataFrame([[1, 2], [3, 4]])
+
+        result = methodcaller(func, "foo")(df)
+        assert df.index.name is None
+        assert result.index.name == "foo"
+
+        result = methodcaller(func, "cols", axis=1)(df)
+        assert df.columns.name is None
+        assert result.columns.name == "cols"
+
+    @pytest.mark.parametrize("func", ["_set_axis_name", "rename_axis"])
+    def test_set_axis_name_mi(self, func):
+        df = DataFrame(
+            np.empty((3, 3)),
+            index=MultiIndex.from_tuples([("A", x) for x in list("aBc")]),
+            columns=MultiIndex.from_tuples([("C", x) for x in list("xyz")]),
+        )
+
+        level_names = ["L1", "L2"]
+
+        result = methodcaller(func, level_names)(df)
+        assert result.index.names == level_names
+        assert result.columns.names == [None, None]
+
+        result = methodcaller(func, level_names, axis=1)(df)
+        assert result.columns.names == ["L1", "L2"]
+        assert result.index.names == [None, None]
+
+    def test_nonzero_single_element(self):
+        # allow single item via bool method
+        msg_warn = (
+            "DataFrame.bool is now deprecated and will be removed "
+            "in future version of pandas"
+        )
+        df = DataFrame([[True]])
+        df1 = DataFrame([[False]])
+        with tm.assert_produces_warning(FutureWarning, match=msg_warn):
+            assert df.bool()
+
+        with tm.assert_produces_warning(FutureWarning, match=msg_warn):
+            assert not df1.bool()
+
+        df = DataFrame([[False, False]])
+        msg_err = "The truth value of a DataFrame is ambiguous"
+        with pytest.raises(ValueError, match=msg_err):
+            bool(df)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg_warn):
+            with pytest.raises(ValueError, match=msg_err):
+                df.bool()
+
+    def test_metadata_propagation_indiv_groupby(self):
+        # groupby
+        df = DataFrame(
+            {
+                "A": ["foo", "bar", "foo", "bar", "foo", "bar", "foo", "foo"],
+                "B": ["one", "one", "two", "three", "two", "two", "one", "three"],
+                "C": np.random.default_rng(2).standard_normal(8),
+                "D": np.random.default_rng(2).standard_normal(8),
+            }
+        )
+        result = df.groupby("A").sum()
+        tm.assert_metadata_equivalent(df, result)
+
+    def test_metadata_propagation_indiv_resample(self):
+        # resample
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((1000, 2)),
+            index=date_range("20130101", periods=1000, freq="s"),
+        )
+        result = df.resample("1min")
+        tm.assert_metadata_equivalent(df, result)
+
+    def test_metadata_propagation_indiv(self, monkeypatch):
+        # merging with override
+        # GH 6923
+
+        def finalize(self, other, method=None, **kwargs):
+            for name in self._metadata:
+                if method == "merge":
+                    left, right = other.left, other.right
+                    value = getattr(left, name, "") + "|" + getattr(right, name, "")
+                    object.__setattr__(self, name, value)
+                elif method == "concat":
+                    value = "+".join(
+                        [getattr(o, name) for o in other.objs if getattr(o, name, None)]
+                    )
+                    object.__setattr__(self, name, value)
+                else:
+                    object.__setattr__(self, name, getattr(other, name, ""))
+
+            return self
+
+        with monkeypatch.context() as m:
+            m.setattr(DataFrame, "_metadata", ["filename"])
+            m.setattr(DataFrame, "__finalize__", finalize)
+
+            df1 = DataFrame(
+                np.random.default_rng(2).integers(0, 4, (3, 2)), columns=["a", "b"]
+            )
+            df2 = DataFrame(
+                np.random.default_rng(2).integers(0, 4, (3, 2)), columns=["c", "d"]
+            )
+            DataFrame._metadata = ["filename"]
+            df1.filename = "fname1.csv"
+            df2.filename = "fname2.csv"
+
+            result = df1.merge(df2, left_on=["a"], right_on=["c"], how="inner")
+            assert result.filename == "fname1.csv|fname2.csv"
+
+            # concat
+            # GH#6927
+            df1 = DataFrame(
+                np.random.default_rng(2).integers(0, 4, (3, 2)), columns=list("ab")
+            )
+            df1.filename = "foo"
+
+            result = pd.concat([df1, df1])
+            assert result.filename == "foo+foo"
+
+    def test_set_attribute(self):
+        # Test for consistent setattr behavior when an attribute and a column
+        # have the same name (Issue #8994)
+        df = DataFrame({"x": [1, 2, 3]})
+
+        df.y = 2
+        df["y"] = [2, 4, 6]
+        df.y = 5
+
+        assert df.y == 5
+        tm.assert_series_equal(df["y"], Series([2, 4, 6], name="y"))
+
+    def test_deepcopy_empty(self):
+        # This test covers empty frame copying with non-empty column sets
+        # as reported in issue GH15370
+        empty_frame = DataFrame(data=[], index=[], columns=["A"])
+        empty_frame_copy = deepcopy(empty_frame)
+
+        tm.assert_frame_equal(empty_frame_copy, empty_frame)
+
+
+# formerly in Generic but only test DataFrame
+class TestDataFrame2:
+    @pytest.mark.parametrize("value", [1, "True", [1, 2, 3], 5.0])
+    def test_validate_bool_args(self, value):
+        df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+
+        msg = 'For argument "inplace" expected type bool, received type'
+        with pytest.raises(ValueError, match=msg):
+            df.copy().rename_axis(mapper={"a": "x", "b": "y"}, axis=1, inplace=value)
+
+        with pytest.raises(ValueError, match=msg):
+            df.copy().drop("a", axis=1, inplace=value)
+
+        with pytest.raises(ValueError, match=msg):
+            df.copy().fillna(value=0, inplace=value)
+
+        with pytest.raises(ValueError, match=msg):
+            df.copy().replace(to_replace=1, value=7, inplace=value)
+
+        with pytest.raises(ValueError, match=msg):
+            df.copy().interpolate(inplace=value)
+
+        with pytest.raises(ValueError, match=msg):
+            df.copy()._where(cond=df.a > 2, inplace=value)
+
+        with pytest.raises(ValueError, match=msg):
+            df.copy().mask(cond=df.a > 2, inplace=value)
+
+    def test_unexpected_keyword(self):
+        # GH8597
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((5, 2)), columns=["jim", "joe"]
+        )
+        ca = pd.Categorical([0, 0, 2, 2, 3, np.nan])
+        ts = df["joe"].copy()
+        ts[2] = np.nan
+
+        msg = "unexpected keyword"
+        with pytest.raises(TypeError, match=msg):
+            df.drop("joe", axis=1, in_place=True)
+
+        with pytest.raises(TypeError, match=msg):
+            df.reindex([1, 0], inplace=True)
+
+        with pytest.raises(TypeError, match=msg):
+            ca.fillna(0, inplace=True)
+
+        with pytest.raises(TypeError, match=msg):
+            ts.fillna(0, in_place=True)

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

@@ -0,0 +1,504 @@
+from copy import (
+    copy,
+    deepcopy,
+)
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import is_scalar
+
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+# ----------------------------------------------------------------------
+# Generic types test cases
+
+
+def construct(box, shape, value=None, dtype=None, **kwargs):
+    """
+    construct an object for the given shape
+    if value is specified use that if its a scalar
+    if value is an array, repeat it as needed
+    """
+    if isinstance(shape, int):
+        shape = tuple([shape] * box._AXIS_LEN)
+    if value is not None:
+        if is_scalar(value):
+            if value == "empty":
+                arr = None
+                dtype = np.float64
+
+                # remove the info axis
+                kwargs.pop(box._info_axis_name, None)
+            else:
+                arr = np.empty(shape, dtype=dtype)
+                arr.fill(value)
+        else:
+            fshape = np.prod(shape)
+            arr = value.ravel()
+            new_shape = fshape / arr.shape[0]
+            if fshape % arr.shape[0] != 0:
+                raise Exception("invalid value passed in construct")
+
+            arr = np.repeat(arr, new_shape).reshape(shape)
+    else:
+        arr = np.random.default_rng(2).standard_normal(shape)
+    return box(arr, dtype=dtype, **kwargs)
+
+
+class TestGeneric:
+    @pytest.mark.parametrize(
+        "func",
+        [
+            str.lower,
+            {x: x.lower() for x in list("ABCD")},
+            Series({x: x.lower() for x in list("ABCD")}),
+        ],
+    )
+    def test_rename(self, frame_or_series, func):
+        # single axis
+        idx = list("ABCD")
+
+        for axis in frame_or_series._AXIS_ORDERS:
+            kwargs = {axis: idx}
+            obj = construct(frame_or_series, 4, **kwargs)
+
+            # rename a single axis
+            result = obj.rename(**{axis: func})
+            expected = obj.copy()
+            setattr(expected, axis, list("abcd"))
+            tm.assert_equal(result, expected)
+
+    def test_get_numeric_data(self, frame_or_series):
+        n = 4
+        kwargs = {
+            frame_or_series._get_axis_name(i): list(range(n))
+            for i in range(frame_or_series._AXIS_LEN)
+        }
+
+        # get the numeric data
+        o = construct(frame_or_series, n, **kwargs)
+        result = o._get_numeric_data()
+        tm.assert_equal(result, o)
+
+        # non-inclusion
+        result = o._get_bool_data()
+        expected = construct(frame_or_series, n, value="empty", **kwargs)
+        if isinstance(o, DataFrame):
+            # preserve columns dtype
+            expected.columns = o.columns[:0]
+        # https://github.com/pandas-dev/pandas/issues/50862
+        tm.assert_equal(result.reset_index(drop=True), expected)
+
+        # get the bool data
+        arr = np.array([True, True, False, True])
+        o = construct(frame_or_series, n, value=arr, **kwargs)
+        result = o._get_numeric_data()
+        tm.assert_equal(result, o)
+
+    def test_nonzero(self, frame_or_series):
+        # GH 4633
+        # look at the boolean/nonzero behavior for objects
+        obj = construct(frame_or_series, shape=4)
+        msg = f"The truth value of a {frame_or_series.__name__} is ambiguous"
+        with pytest.raises(ValueError, match=msg):
+            bool(obj == 0)
+        with pytest.raises(ValueError, match=msg):
+            bool(obj == 1)
+        with pytest.raises(ValueError, match=msg):
+            bool(obj)
+
+        obj = construct(frame_or_series, shape=4, value=1)
+        with pytest.raises(ValueError, match=msg):
+            bool(obj == 0)
+        with pytest.raises(ValueError, match=msg):
+            bool(obj == 1)
+        with pytest.raises(ValueError, match=msg):
+            bool(obj)
+
+        obj = construct(frame_or_series, shape=4, value=np.nan)
+        with pytest.raises(ValueError, match=msg):
+            bool(obj == 0)
+        with pytest.raises(ValueError, match=msg):
+            bool(obj == 1)
+        with pytest.raises(ValueError, match=msg):
+            bool(obj)
+
+        # empty
+        obj = construct(frame_or_series, shape=0)
+        with pytest.raises(ValueError, match=msg):
+            bool(obj)
+
+        # invalid behaviors
+
+        obj1 = construct(frame_or_series, shape=4, value=1)
+        obj2 = construct(frame_or_series, shape=4, value=1)
+
+        with pytest.raises(ValueError, match=msg):
+            if obj1:
+                pass
+
+        with pytest.raises(ValueError, match=msg):
+            obj1 and obj2
+        with pytest.raises(ValueError, match=msg):
+            obj1 or obj2
+        with pytest.raises(ValueError, match=msg):
+            not obj1
+
+    def test_frame_or_series_compound_dtypes(self, frame_or_series):
+        # see gh-5191
+        # Compound dtypes should raise NotImplementedError.
+
+        def f(dtype):
+            return construct(frame_or_series, shape=3, value=1, dtype=dtype)
+
+        msg = (
+            "compound dtypes are not implemented "
+            f"in the {frame_or_series.__name__} constructor"
+        )
+
+        with pytest.raises(NotImplementedError, match=msg):
+            f([("A", "datetime64[h]"), ("B", "str"), ("C", "int32")])
+
+        # these work (though results may be unexpected)
+        f("int64")
+        f("float64")
+        f("M8[ns]")
+
+    def test_metadata_propagation(self, frame_or_series):
+        # check that the metadata matches up on the resulting ops
+
+        o = construct(frame_or_series, shape=3)
+        o.name = "foo"
+        o2 = construct(frame_or_series, shape=3)
+        o2.name = "bar"
+
+        # ----------
+        # preserving
+        # ----------
+
+        # simple ops with scalars
+        for op in ["__add__", "__sub__", "__truediv__", "__mul__"]:
+            result = getattr(o, op)(1)
+            tm.assert_metadata_equivalent(o, result)
+
+        # ops with like
+        for op in ["__add__", "__sub__", "__truediv__", "__mul__"]:
+            result = getattr(o, op)(o)
+            tm.assert_metadata_equivalent(o, result)
+
+        # simple boolean
+        for op in ["__eq__", "__le__", "__ge__"]:
+            v1 = getattr(o, op)(o)
+            tm.assert_metadata_equivalent(o, v1)
+            tm.assert_metadata_equivalent(o, v1 & v1)
+            tm.assert_metadata_equivalent(o, v1 | v1)
+
+        # combine_first
+        result = o.combine_first(o2)
+        tm.assert_metadata_equivalent(o, result)
+
+        # ---------------------------
+        # non-preserving (by default)
+        # ---------------------------
+
+        # add non-like
+        result = o + o2
+        tm.assert_metadata_equivalent(result)
+
+        # simple boolean
+        for op in ["__eq__", "__le__", "__ge__"]:
+            # this is a name matching op
+            v1 = getattr(o, op)(o)
+            v2 = getattr(o, op)(o2)
+            tm.assert_metadata_equivalent(v2)
+            tm.assert_metadata_equivalent(v1 & v2)
+            tm.assert_metadata_equivalent(v1 | v2)
+
+    def test_size_compat(self, frame_or_series):
+        # GH8846
+        # size property should be defined
+
+        o = construct(frame_or_series, shape=10)
+        assert o.size == np.prod(o.shape)
+        assert o.size == 10 ** len(o.axes)
+
+    def test_split_compat(self, frame_or_series):
+        # xref GH8846
+        o = construct(frame_or_series, shape=10)
+        with tm.assert_produces_warning(
+            FutureWarning, match=".swapaxes' is deprecated", check_stacklevel=False
+        ):
+            assert len(np.array_split(o, 5)) == 5
+            assert len(np.array_split(o, 2)) == 2
+
+    # See gh-12301
+    def test_stat_unexpected_keyword(self, frame_or_series):
+        obj = construct(frame_or_series, 5)
+        starwars = "Star Wars"
+        errmsg = "unexpected keyword"
+
+        with pytest.raises(TypeError, match=errmsg):
+            obj.max(epic=starwars)  # stat_function
+        with pytest.raises(TypeError, match=errmsg):
+            obj.var(epic=starwars)  # stat_function_ddof
+        with pytest.raises(TypeError, match=errmsg):
+            obj.sum(epic=starwars)  # cum_function
+        with pytest.raises(TypeError, match=errmsg):
+            obj.any(epic=starwars)  # logical_function
+
+    @pytest.mark.parametrize("func", ["sum", "cumsum", "any", "var"])
+    def test_api_compat(self, func, frame_or_series):
+        # GH 12021
+        # compat for __name__, __qualname__
+
+        obj = construct(frame_or_series, 5)
+        f = getattr(obj, func)
+        assert f.__name__ == func
+        assert f.__qualname__.endswith(func)
+
+    def test_stat_non_defaults_args(self, frame_or_series):
+        obj = construct(frame_or_series, 5)
+        out = np.array([0])
+        errmsg = "the 'out' parameter is not supported"
+
+        with pytest.raises(ValueError, match=errmsg):
+            obj.max(out=out)  # stat_function
+        with pytest.raises(ValueError, match=errmsg):
+            obj.var(out=out)  # stat_function_ddof
+        with pytest.raises(ValueError, match=errmsg):
+            obj.sum(out=out)  # cum_function
+        with pytest.raises(ValueError, match=errmsg):
+            obj.any(out=out)  # logical_function
+
+    def test_truncate_out_of_bounds(self, frame_or_series):
+        # GH11382
+
+        # small
+        shape = [2000] + ([1] * (frame_or_series._AXIS_LEN - 1))
+        small = construct(frame_or_series, shape, dtype="int8", value=1)
+        tm.assert_equal(small.truncate(), small)
+        tm.assert_equal(small.truncate(before=0, after=3e3), small)
+        tm.assert_equal(small.truncate(before=-1, after=2e3), small)
+
+        # big
+        shape = [2_000_000] + ([1] * (frame_or_series._AXIS_LEN - 1))
+        big = construct(frame_or_series, shape, dtype="int8", value=1)
+        tm.assert_equal(big.truncate(), big)
+        tm.assert_equal(big.truncate(before=0, after=3e6), big)
+        tm.assert_equal(big.truncate(before=-1, after=2e6), big)
+
+    @pytest.mark.parametrize(
+        "func",
+        [copy, deepcopy, lambda x: x.copy(deep=False), lambda x: x.copy(deep=True)],
+    )
+    @pytest.mark.parametrize("shape", [0, 1, 2])
+    def test_copy_and_deepcopy(self, frame_or_series, shape, func):
+        # GH 15444
+        obj = construct(frame_or_series, shape)
+        obj_copy = func(obj)
+        assert obj_copy is not obj
+        tm.assert_equal(obj_copy, obj)
+
+    def test_data_deprecated(self, frame_or_series):
+        obj = frame_or_series()
+        msg = "(Series|DataFrame)._data is deprecated"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            mgr = obj._data
+        assert mgr is obj._mgr
+
+
+class TestNDFrame:
+    # tests that don't fit elsewhere
+
+    @pytest.mark.parametrize(
+        "ser",
+        [
+            Series(range(10), dtype=np.float64),
+            Series([str(i) for i in range(10)], dtype=object),
+        ],
+    )
+    def test_squeeze_series_noop(self, ser):
+        # noop
+        tm.assert_series_equal(ser.squeeze(), ser)
+
+    def test_squeeze_frame_noop(self):
+        # noop
+        df = DataFrame(np.eye(2))
+        tm.assert_frame_equal(df.squeeze(), df)
+
+    def test_squeeze_frame_reindex(self):
+        # squeezing
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=date_range("2000-01-01", periods=10, freq="B"),
+        ).reindex(columns=["A"])
+        tm.assert_series_equal(df.squeeze(), df["A"])
+
+    def test_squeeze_0_len_dim(self):
+        # don't fail with 0 length dimensions GH11229 & GH8999
+        empty_series = Series([], name="five", dtype=np.float64)
+        empty_frame = DataFrame([empty_series])
+        tm.assert_series_equal(empty_series, empty_series.squeeze())
+        tm.assert_series_equal(empty_series, empty_frame.squeeze())
+
+    def test_squeeze_axis(self):
+        # axis argument
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((1, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=date_range("2000-01-01", periods=1, freq="B"),
+        ).iloc[:, :1]
+        assert df.shape == (1, 1)
+        tm.assert_series_equal(df.squeeze(axis=0), df.iloc[0])
+        tm.assert_series_equal(df.squeeze(axis="index"), df.iloc[0])
+        tm.assert_series_equal(df.squeeze(axis=1), df.iloc[:, 0])
+        tm.assert_series_equal(df.squeeze(axis="columns"), df.iloc[:, 0])
+        assert df.squeeze() == df.iloc[0, 0]
+        msg = "No axis named 2 for object type DataFrame"
+        with pytest.raises(ValueError, match=msg):
+            df.squeeze(axis=2)
+        msg = "No axis named x for object type DataFrame"
+        with pytest.raises(ValueError, match=msg):
+            df.squeeze(axis="x")
+
+    def test_squeeze_axis_len_3(self):
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=date_range("2000-01-01", periods=3, freq="B"),
+        )
+        tm.assert_frame_equal(df.squeeze(axis=0), df)
+
+    def test_numpy_squeeze(self):
+        s = Series(range(2), dtype=np.float64)
+        tm.assert_series_equal(np.squeeze(s), s)
+
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=date_range("2000-01-01", periods=10, freq="B"),
+        ).reindex(columns=["A"])
+        tm.assert_series_equal(np.squeeze(df), df["A"])
+
+    @pytest.mark.parametrize(
+        "ser",
+        [
+            Series(range(10), dtype=np.float64),
+            Series([str(i) for i in range(10)], dtype=object),
+        ],
+    )
+    def test_transpose_series(self, ser):
+        # calls implementation in pandas/core/base.py
+        tm.assert_series_equal(ser.transpose(), ser)
+
+    def test_transpose_frame(self):
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=date_range("2000-01-01", periods=10, freq="B"),
+        )
+        tm.assert_frame_equal(df.transpose().transpose(), df)
+
+    def test_numpy_transpose(self, frame_or_series):
+        obj = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=date_range("2000-01-01", periods=10, freq="B"),
+        )
+        obj = tm.get_obj(obj, frame_or_series)
+
+        if frame_or_series is Series:
+            # 1D -> np.transpose is no-op
+            tm.assert_series_equal(np.transpose(obj), obj)
+
+        # round-trip preserved
+        tm.assert_equal(np.transpose(np.transpose(obj)), obj)
+
+        msg = "the 'axes' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.transpose(obj, axes=1)
+
+    @pytest.mark.parametrize(
+        "ser",
+        [
+            Series(range(10), dtype=np.float64),
+            Series([str(i) for i in range(10)], dtype=object),
+        ],
+    )
+    def test_take_series(self, ser):
+        indices = [1, 5, -2, 6, 3, -1]
+        out = ser.take(indices)
+        expected = Series(
+            data=ser.values.take(indices),
+            index=ser.index.take(indices),
+            dtype=ser.dtype,
+        )
+        tm.assert_series_equal(out, expected)
+
+    def test_take_frame(self):
+        indices = [1, 5, -2, 6, 3, -1]
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=date_range("2000-01-01", periods=10, freq="B"),
+        )
+        out = df.take(indices)
+        expected = DataFrame(
+            data=df.values.take(indices, axis=0),
+            index=df.index.take(indices),
+            columns=df.columns,
+        )
+        tm.assert_frame_equal(out, expected)
+
+    def test_take_invalid_kwargs(self, frame_or_series):
+        indices = [-3, 2, 0, 1]
+
+        obj = DataFrame(range(5))
+        obj = tm.get_obj(obj, frame_or_series)
+
+        msg = r"take\(\) got an unexpected keyword argument 'foo'"
+        with pytest.raises(TypeError, match=msg):
+            obj.take(indices, foo=2)
+
+        msg = "the 'out' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            obj.take(indices, out=indices)
+
+        msg = "the 'mode' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            obj.take(indices, mode="clip")
+
+    def test_axis_classmethods(self, frame_or_series):
+        box = frame_or_series
+        obj = box(dtype=object)
+        values = box._AXIS_TO_AXIS_NUMBER.keys()
+        for v in values:
+            assert obj._get_axis_number(v) == box._get_axis_number(v)
+            assert obj._get_axis_name(v) == box._get_axis_name(v)
+            assert obj._get_block_manager_axis(v) == box._get_block_manager_axis(v)
+
+    def test_flags_identity(self, frame_or_series):
+        obj = Series([1, 2])
+        if frame_or_series is DataFrame:
+            obj = obj.to_frame()
+
+        assert obj.flags is obj.flags
+        obj2 = obj.copy()
+        assert obj2.flags is not obj.flags
+
+    def test_bool_dep(self) -> None:
+        # GH-51749
+        msg_warn = (
+            "DataFrame.bool is now deprecated and will be removed "
+            "in future version of pandas"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg_warn):
+            DataFrame({"col": [False]}).bool()

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

@@ -0,0 +1,336 @@
+import pytest
+
+from pandas.core.dtypes.missing import array_equivalent
+
+import pandas as pd
+
+
+# Fixtures
+# ========
+@pytest.fixture
+def df():
+    """DataFrame with columns 'L1', 'L2', and 'L3'"""
+    return pd.DataFrame({"L1": [1, 2, 3], "L2": [11, 12, 13], "L3": ["A", "B", "C"]})
+
+
+@pytest.fixture(params=[[], ["L1"], ["L1", "L2"], ["L1", "L2", "L3"]])
+def df_levels(request, df):
+    """DataFrame with columns or index levels 'L1', 'L2', and 'L3'"""
+    levels = request.param
+
+    if levels:
+        df = df.set_index(levels)
+
+    return df
+
+
+@pytest.fixture
+def df_ambig(df):
+    """DataFrame with levels 'L1' and 'L2' and labels 'L1' and 'L3'"""
+    df = df.set_index(["L1", "L2"])
+
+    df["L1"] = df["L3"]
+
+    return df
+
+
+@pytest.fixture
+def df_duplabels(df):
+    """DataFrame with level 'L1' and labels 'L2', 'L3', and 'L2'"""
+    df = df.set_index(["L1"])
+    df = pd.concat([df, df["L2"]], axis=1)
+
+    return df
+
+
+# Test is label/level reference
+# =============================
+def get_labels_levels(df_levels):
+    expected_labels = list(df_levels.columns)
+    expected_levels = [name for name in df_levels.index.names if name is not None]
+    return expected_labels, expected_levels
+
+
+def assert_label_reference(frame, labels, axis):
+    for label in labels:
+        assert frame._is_label_reference(label, axis=axis)
+        assert not frame._is_level_reference(label, axis=axis)
+        assert frame._is_label_or_level_reference(label, axis=axis)
+
+
+def assert_level_reference(frame, levels, axis):
+    for level in levels:
+        assert frame._is_level_reference(level, axis=axis)
+        assert not frame._is_label_reference(level, axis=axis)
+        assert frame._is_label_or_level_reference(level, axis=axis)
+
+
+# DataFrame
+# ---------
+def test_is_level_or_label_reference_df_simple(df_levels, axis):
+    axis = df_levels._get_axis_number(axis)
+    # Compute expected labels and levels
+    expected_labels, expected_levels = get_labels_levels(df_levels)
+
+    # Transpose frame if axis == 1
+    if axis == 1:
+        df_levels = df_levels.T
+
+    # Perform checks
+    assert_level_reference(df_levels, expected_levels, axis=axis)
+    assert_label_reference(df_levels, expected_labels, axis=axis)
+
+
+def test_is_level_reference_df_ambig(df_ambig, axis):
+    axis = df_ambig._get_axis_number(axis)
+
+    # Transpose frame if axis == 1
+    if axis == 1:
+        df_ambig = df_ambig.T
+
+    # df has both an on-axis level and off-axis label named L1
+    # Therefore L1 should reference the label, not the level
+    assert_label_reference(df_ambig, ["L1"], axis=axis)
+
+    # df has an on-axis level named L2 and it is not ambiguous
+    # Therefore L2 is an level reference
+    assert_level_reference(df_ambig, ["L2"], axis=axis)
+
+    # df has a column named L3 and it not an level reference
+    assert_label_reference(df_ambig, ["L3"], axis=axis)
+
+
+# Series
+# ------
+def test_is_level_reference_series_simple_axis0(df):
+    # Make series with L1 as index
+    s = df.set_index("L1").L2
+    assert_level_reference(s, ["L1"], axis=0)
+    assert not s._is_level_reference("L2")
+
+    # Make series with L1 and L2 as index
+    s = df.set_index(["L1", "L2"]).L3
+    assert_level_reference(s, ["L1", "L2"], axis=0)
+    assert not s._is_level_reference("L3")
+
+
+def test_is_level_reference_series_axis1_error(df):
+    # Make series with L1 as index
+    s = df.set_index("L1").L2
+
+    with pytest.raises(ValueError, match="No axis named 1"):
+        s._is_level_reference("L1", axis=1)
+
+
+# Test _check_label_or_level_ambiguity_df
+# =======================================
+
+
+# DataFrame
+# ---------
+def test_check_label_or_level_ambiguity_df(df_ambig, axis):
+    axis = df_ambig._get_axis_number(axis)
+    # Transpose frame if axis == 1
+    if axis == 1:
+        df_ambig = df_ambig.T
+        msg = "'L1' is both a column level and an index label"
+
+    else:
+        msg = "'L1' is both an index level and a column label"
+    # df_ambig has both an on-axis level and off-axis label named L1
+    # Therefore, L1 is ambiguous.
+    with pytest.raises(ValueError, match=msg):
+        df_ambig._check_label_or_level_ambiguity("L1", axis=axis)
+
+    # df_ambig has an on-axis level named L2,, and it is not ambiguous.
+    df_ambig._check_label_or_level_ambiguity("L2", axis=axis)
+
+    # df_ambig has an off-axis label named L3, and it is not ambiguous
+    assert not df_ambig._check_label_or_level_ambiguity("L3", axis=axis)
+
+
+# Series
+# ------
+def test_check_label_or_level_ambiguity_series(df):
+    # A series has no columns and therefore references are never ambiguous
+
+    # Make series with L1 as index
+    s = df.set_index("L1").L2
+    s._check_label_or_level_ambiguity("L1", axis=0)
+    s._check_label_or_level_ambiguity("L2", axis=0)
+
+    # Make series with L1 and L2 as index
+    s = df.set_index(["L1", "L2"]).L3
+    s._check_label_or_level_ambiguity("L1", axis=0)
+    s._check_label_or_level_ambiguity("L2", axis=0)
+    s._check_label_or_level_ambiguity("L3", axis=0)
+
+
+def test_check_label_or_level_ambiguity_series_axis1_error(df):
+    # Make series with L1 as index
+    s = df.set_index("L1").L2
+
+    with pytest.raises(ValueError, match="No axis named 1"):
+        s._check_label_or_level_ambiguity("L1", axis=1)
+
+
+# Test _get_label_or_level_values
+# ===============================
+def assert_label_values(frame, labels, axis):
+    axis = frame._get_axis_number(axis)
+    for label in labels:
+        if axis == 0:
+            expected = frame[label]._values
+        else:
+            expected = frame.loc[label]._values
+
+        result = frame._get_label_or_level_values(label, axis=axis)
+        assert array_equivalent(expected, result)
+
+
+def assert_level_values(frame, levels, axis):
+    axis = frame._get_axis_number(axis)
+    for level in levels:
+        if axis == 0:
+            expected = frame.index.get_level_values(level=level)._values
+        else:
+            expected = frame.columns.get_level_values(level=level)._values
+
+        result = frame._get_label_or_level_values(level, axis=axis)
+        assert array_equivalent(expected, result)
+
+
+# DataFrame
+# ---------
+def test_get_label_or_level_values_df_simple(df_levels, axis):
+    # Compute expected labels and levels
+    expected_labels, expected_levels = get_labels_levels(df_levels)
+
+    axis = df_levels._get_axis_number(axis)
+    # Transpose frame if axis == 1
+    if axis == 1:
+        df_levels = df_levels.T
+
+    # Perform checks
+    assert_label_values(df_levels, expected_labels, axis=axis)
+    assert_level_values(df_levels, expected_levels, axis=axis)
+
+
+def test_get_label_or_level_values_df_ambig(df_ambig, axis):
+    axis = df_ambig._get_axis_number(axis)
+    # Transpose frame if axis == 1
+    if axis == 1:
+        df_ambig = df_ambig.T
+
+    # df has an on-axis level named L2, and it is not ambiguous.
+    assert_level_values(df_ambig, ["L2"], axis=axis)
+
+    # df has an off-axis label named L3, and it is not ambiguous.
+    assert_label_values(df_ambig, ["L3"], axis=axis)
+
+
+def test_get_label_or_level_values_df_duplabels(df_duplabels, axis):
+    axis = df_duplabels._get_axis_number(axis)
+    # Transpose frame if axis == 1
+    if axis == 1:
+        df_duplabels = df_duplabels.T
+
+    # df has unambiguous level 'L1'
+    assert_level_values(df_duplabels, ["L1"], axis=axis)
+
+    # df has unique label 'L3'
+    assert_label_values(df_duplabels, ["L3"], axis=axis)
+
+    # df has duplicate labels 'L2'
+    if axis == 0:
+        expected_msg = "The column label 'L2' is not unique"
+    else:
+        expected_msg = "The index label 'L2' is not unique"
+
+    with pytest.raises(ValueError, match=expected_msg):
+        assert_label_values(df_duplabels, ["L2"], axis=axis)
+
+
+# Series
+# ------
+def test_get_label_or_level_values_series_axis0(df):
+    # Make series with L1 as index
+    s = df.set_index("L1").L2
+    assert_level_values(s, ["L1"], axis=0)
+
+    # Make series with L1 and L2 as index
+    s = df.set_index(["L1", "L2"]).L3
+    assert_level_values(s, ["L1", "L2"], axis=0)
+
+
+def test_get_label_or_level_values_series_axis1_error(df):
+    # Make series with L1 as index
+    s = df.set_index("L1").L2
+
+    with pytest.raises(ValueError, match="No axis named 1"):
+        s._get_label_or_level_values("L1", axis=1)
+
+
+# Test _drop_labels_or_levels
+# ===========================
+def assert_labels_dropped(frame, labels, axis):
+    axis = frame._get_axis_number(axis)
+    for label in labels:
+        df_dropped = frame._drop_labels_or_levels(label, axis=axis)
+
+        if axis == 0:
+            assert label in frame.columns
+            assert label not in df_dropped.columns
+        else:
+            assert label in frame.index
+            assert label not in df_dropped.index
+
+
+def assert_levels_dropped(frame, levels, axis):
+    axis = frame._get_axis_number(axis)
+    for level in levels:
+        df_dropped = frame._drop_labels_or_levels(level, axis=axis)
+
+        if axis == 0:
+            assert level in frame.index.names
+            assert level not in df_dropped.index.names
+        else:
+            assert level in frame.columns.names
+            assert level not in df_dropped.columns.names
+
+
+# DataFrame
+# ---------
+def test_drop_labels_or_levels_df(df_levels, axis):
+    # Compute expected labels and levels
+    expected_labels, expected_levels = get_labels_levels(df_levels)
+
+    axis = df_levels._get_axis_number(axis)
+    # Transpose frame if axis == 1
+    if axis == 1:
+        df_levels = df_levels.T
+
+    # Perform checks
+    assert_labels_dropped(df_levels, expected_labels, axis=axis)
+    assert_levels_dropped(df_levels, expected_levels, axis=axis)
+
+    with pytest.raises(ValueError, match="not valid labels or levels"):
+        df_levels._drop_labels_or_levels("L4", axis=axis)
+
+
+# Series
+# ------
+def test_drop_labels_or_levels_series(df):
+    # Make series with L1 as index
+    s = df.set_index("L1").L2
+    assert_levels_dropped(s, ["L1"], axis=0)
+
+    with pytest.raises(ValueError, match="not valid labels or levels"):
+        s._drop_labels_or_levels("L4", axis=0)
+
+    # Make series with L1 and L2 as index
+    s = df.set_index(["L1", "L2"]).L3
+    assert_levels_dropped(s, ["L1", "L2"], axis=0)
+
+    with pytest.raises(ValueError, match="not valid labels or levels"):
+        s._drop_labels_or_levels("L4", axis=0)

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

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

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

@@ -0,0 +1,130 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Categorical,
+    DataFrame,
+    MultiIndex,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+pytest.importorskip("xarray")
+
+
+class TestDataFrameToXArray:
+    @pytest.fixture
+    def df(self):
+        return DataFrame(
+            {
+                "a": list("abcd"),
+                "b": list(range(1, 5)),
+                "c": np.arange(3, 7).astype("u1"),
+                "d": np.arange(4.0, 8.0, dtype="float64"),
+                "e": [True, False, True, False],
+                "f": Categorical(list("abcd")),
+                "g": date_range("20130101", periods=4),
+                "h": date_range("20130101", periods=4, tz="US/Eastern"),
+            }
+        )
+
+    def test_to_xarray_index_types(self, index_flat, df, using_infer_string):
+        index = index_flat
+        # MultiIndex is tested in test_to_xarray_with_multiindex
+        if len(index) == 0:
+            pytest.skip("Test doesn't make sense for empty index")
+
+        from xarray import Dataset
+
+        df.index = index[:4]
+        df.index.name = "foo"
+        df.columns.name = "bar"
+        result = df.to_xarray()
+        assert result.sizes["foo"] == 4
+        assert len(result.coords) == 1
+        assert len(result.data_vars) == 8
+        tm.assert_almost_equal(list(result.coords.keys()), ["foo"])
+        assert isinstance(result, Dataset)
+
+        # idempotency
+        # datetimes w/tz are preserved
+        # column names are lost
+        expected = df.copy()
+        expected["f"] = expected["f"].astype(
+            object if not using_infer_string else "string[pyarrow_numpy]"
+        )
+        expected.columns.name = None
+        tm.assert_frame_equal(result.to_dataframe(), expected)
+
+    def test_to_xarray_empty(self, df):
+        from xarray import Dataset
+
+        df.index.name = "foo"
+        result = df[0:0].to_xarray()
+        assert result.sizes["foo"] == 0
+        assert isinstance(result, Dataset)
+
+    def test_to_xarray_with_multiindex(self, df, using_infer_string):
+        from xarray import Dataset
+
+        # MultiIndex
+        df.index = MultiIndex.from_product([["a"], range(4)], names=["one", "two"])
+        result = df.to_xarray()
+        assert result.sizes["one"] == 1
+        assert result.sizes["two"] == 4
+        assert len(result.coords) == 2
+        assert len(result.data_vars) == 8
+        tm.assert_almost_equal(list(result.coords.keys()), ["one", "two"])
+        assert isinstance(result, Dataset)
+
+        result = result.to_dataframe()
+        expected = df.copy()
+        expected["f"] = expected["f"].astype(
+            object if not using_infer_string else "string[pyarrow_numpy]"
+        )
+        expected.columns.name = None
+        tm.assert_frame_equal(result, expected)
+
+
+class TestSeriesToXArray:
+    def test_to_xarray_index_types(self, index_flat):
+        index = index_flat
+        # MultiIndex is tested in test_to_xarray_with_multiindex
+
+        from xarray import DataArray
+
+        ser = Series(range(len(index)), index=index, dtype="int64")
+        ser.index.name = "foo"
+        result = ser.to_xarray()
+        repr(result)
+        assert len(result) == len(index)
+        assert len(result.coords) == 1
+        tm.assert_almost_equal(list(result.coords.keys()), ["foo"])
+        assert isinstance(result, DataArray)
+
+        # idempotency
+        tm.assert_series_equal(result.to_series(), ser)
+
+    def test_to_xarray_empty(self):
+        from xarray import DataArray
+
+        ser = Series([], dtype=object)
+        ser.index.name = "foo"
+        result = ser.to_xarray()
+        assert len(result) == 0
+        assert len(result.coords) == 1
+        tm.assert_almost_equal(list(result.coords.keys()), ["foo"])
+        assert isinstance(result, DataArray)
+
+    def test_to_xarray_with_multiindex(self):
+        from xarray import DataArray
+
+        mi = MultiIndex.from_product([["a", "b"], range(3)], names=["one", "two"])
+        ser = Series(range(6), dtype="int64", index=mi)
+        result = ser.to_xarray()
+        assert len(result) == 2
+        tm.assert_almost_equal(list(result.coords.keys()), ["one", "two"])
+        assert isinstance(result, DataArray)
+        res = result.to_series()
+        tm.assert_series_equal(res, ser)

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

@@ -0,0 +1,563 @@
+"""
+Module consolidating common testing functions for checking plotting.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from pandas.core.dtypes.api import is_list_like
+
+import pandas as pd
+from pandas import Series
+import pandas._testing as tm
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from matplotlib.axes import Axes
+
+
+def _check_legend_labels(axes, labels=None, visible=True):
+    """
+    Check each axes has expected legend labels
+
+    Parameters
+    ----------
+    axes : matplotlib Axes object, or its list-like
+    labels : list-like
+        expected legend labels
+    visible : bool
+        expected legend visibility. labels are checked only when visible is
+        True
+    """
+    if visible and (labels is None):
+        raise ValueError("labels must be specified when visible is True")
+    axes = _flatten_visible(axes)
+    for ax in axes:
+        if visible:
+            assert ax.get_legend() is not None
+            _check_text_labels(ax.get_legend().get_texts(), labels)
+        else:
+            assert ax.get_legend() is None
+
+
+def _check_legend_marker(ax, expected_markers=None, visible=True):
+    """
+    Check ax has expected legend markers
+
+    Parameters
+    ----------
+    ax : matplotlib Axes object
+    expected_markers : list-like
+        expected legend markers
+    visible : bool
+        expected legend visibility. labels are checked only when visible is
+        True
+    """
+    if visible and (expected_markers is None):
+        raise ValueError("Markers must be specified when visible is True")
+    if visible:
+        handles, _ = ax.get_legend_handles_labels()
+        markers = [handle.get_marker() for handle in handles]
+        assert markers == expected_markers
+    else:
+        assert ax.get_legend() is None
+
+
+def _check_data(xp, rs):
+    """
+    Check each axes has identical lines
+
+    Parameters
+    ----------
+    xp : matplotlib Axes object
+    rs : matplotlib Axes object
+    """
+    import matplotlib.pyplot as plt
+
+    xp_lines = xp.get_lines()
+    rs_lines = rs.get_lines()
+
+    assert len(xp_lines) == len(rs_lines)
+    for xpl, rsl in zip(xp_lines, rs_lines):
+        xpdata = xpl.get_xydata()
+        rsdata = rsl.get_xydata()
+        tm.assert_almost_equal(xpdata, rsdata)
+
+    plt.close("all")
+
+
+def _check_visible(collections, visible=True):
+    """
+    Check each artist is visible or not
+
+    Parameters
+    ----------
+    collections : matplotlib Artist or its list-like
+        target Artist or its list or collection
+    visible : bool
+        expected visibility
+    """
+    from matplotlib.collections import Collection
+
+    if not isinstance(collections, Collection) and not is_list_like(collections):
+        collections = [collections]
+
+    for patch in collections:
+        assert patch.get_visible() == visible
+
+
+def _check_patches_all_filled(axes: Axes | Sequence[Axes], filled: bool = True) -> None:
+    """
+    Check for each artist whether it is filled or not
+
+    Parameters
+    ----------
+    axes : matplotlib Axes object, or its list-like
+    filled : bool
+        expected filling
+    """
+
+    axes = _flatten_visible(axes)
+    for ax in axes:
+        for patch in ax.patches:
+            assert patch.fill == filled
+
+
+def _get_colors_mapped(series, colors):
+    unique = series.unique()
+    # unique and colors length can be differed
+    # depending on slice value
+    mapped = dict(zip(unique, colors))
+    return [mapped[v] for v in series.values]
+
+
+def _check_colors(collections, linecolors=None, facecolors=None, mapping=None):
+    """
+    Check each artist has expected line colors and face colors
+
+    Parameters
+    ----------
+    collections : list-like
+        list or collection of target artist
+    linecolors : list-like which has the same length as collections
+        list of expected line colors
+    facecolors : list-like which has the same length as collections
+        list of expected face colors
+    mapping : Series
+        Series used for color grouping key
+        used for andrew_curves, parallel_coordinates, radviz test
+    """
+    from matplotlib import colors
+    from matplotlib.collections import (
+        Collection,
+        LineCollection,
+        PolyCollection,
+    )
+    from matplotlib.lines import Line2D
+
+    conv = colors.ColorConverter
+    if linecolors is not None:
+        if mapping is not None:
+            linecolors = _get_colors_mapped(mapping, linecolors)
+            linecolors = linecolors[: len(collections)]
+
+        assert len(collections) == len(linecolors)
+        for patch, color in zip(collections, linecolors):
+            if isinstance(patch, Line2D):
+                result = patch.get_color()
+                # Line2D may contains string color expression
+                result = conv.to_rgba(result)
+            elif isinstance(patch, (PolyCollection, LineCollection)):
+                result = tuple(patch.get_edgecolor()[0])
+            else:
+                result = patch.get_edgecolor()
+
+            expected = conv.to_rgba(color)
+            assert result == expected
+
+    if facecolors is not None:
+        if mapping is not None:
+            facecolors = _get_colors_mapped(mapping, facecolors)
+            facecolors = facecolors[: len(collections)]
+
+        assert len(collections) == len(facecolors)
+        for patch, color in zip(collections, facecolors):
+            if isinstance(patch, Collection):
+                # returned as list of np.array
+                result = patch.get_facecolor()[0]
+            else:
+                result = patch.get_facecolor()
+
+            if isinstance(result, np.ndarray):
+                result = tuple(result)
+
+            expected = conv.to_rgba(color)
+            assert result == expected
+
+
+def _check_text_labels(texts, expected):
+    """
+    Check each text has expected labels
+
+    Parameters
+    ----------
+    texts : matplotlib Text object, or its list-like
+        target text, or its list
+    expected : str or list-like which has the same length as texts
+        expected text label, or its list
+    """
+    if not is_list_like(texts):
+        assert texts.get_text() == expected
+    else:
+        labels = [t.get_text() for t in texts]
+        assert len(labels) == len(expected)
+        for label, e in zip(labels, expected):
+            assert label == e
+
+
+def _check_ticks_props(axes, xlabelsize=None, xrot=None, ylabelsize=None, yrot=None):
+    """
+    Check each axes has expected tick properties
+
+    Parameters
+    ----------
+    axes : matplotlib Axes object, or its list-like
+    xlabelsize : number
+        expected xticks font size
+    xrot : number
+        expected xticks rotation
+    ylabelsize : number
+        expected yticks font size
+    yrot : number
+        expected yticks rotation
+    """
+    from matplotlib.ticker import NullFormatter
+
+    axes = _flatten_visible(axes)
+    for ax in axes:
+        if xlabelsize is not None or xrot is not None:
+            if isinstance(ax.xaxis.get_minor_formatter(), NullFormatter):
+                # If minor ticks has NullFormatter, rot / fontsize are not
+                # retained
+                labels = ax.get_xticklabels()
+            else:
+                labels = ax.get_xticklabels() + ax.get_xticklabels(minor=True)
+
+            for label in labels:
+                if xlabelsize is not None:
+                    tm.assert_almost_equal(label.get_fontsize(), xlabelsize)
+                if xrot is not None:
+                    tm.assert_almost_equal(label.get_rotation(), xrot)
+
+        if ylabelsize is not None or yrot is not None:
+            if isinstance(ax.yaxis.get_minor_formatter(), NullFormatter):
+                labels = ax.get_yticklabels()
+            else:
+                labels = ax.get_yticklabels() + ax.get_yticklabels(minor=True)
+
+            for label in labels:
+                if ylabelsize is not None:
+                    tm.assert_almost_equal(label.get_fontsize(), ylabelsize)
+                if yrot is not None:
+                    tm.assert_almost_equal(label.get_rotation(), yrot)
+
+
+def _check_ax_scales(axes, xaxis="linear", yaxis="linear"):
+    """
+    Check each axes has expected scales
+
+    Parameters
+    ----------
+    axes : matplotlib Axes object, or its list-like
+    xaxis : {'linear', 'log'}
+        expected xaxis scale
+    yaxis : {'linear', 'log'}
+        expected yaxis scale
+    """
+    axes = _flatten_visible(axes)
+    for ax in axes:
+        assert ax.xaxis.get_scale() == xaxis
+        assert ax.yaxis.get_scale() == yaxis
+
+
+def _check_axes_shape(axes, axes_num=None, layout=None, figsize=None):
+    """
+    Check expected number of axes is drawn in expected layout
+
+    Parameters
+    ----------
+    axes : matplotlib Axes object, or its list-like
+    axes_num : number
+        expected number of axes. Unnecessary axes should be set to
+        invisible.
+    layout : tuple
+        expected layout, (expected number of rows , columns)
+    figsize : tuple
+        expected figsize. default is matplotlib default
+    """
+    from pandas.plotting._matplotlib.tools import flatten_axes
+
+    if figsize is None:
+        figsize = (6.4, 4.8)
+    visible_axes = _flatten_visible(axes)
+
+    if axes_num is not None:
+        assert len(visible_axes) == axes_num
+        for ax in visible_axes:
+            # check something drawn on visible axes
+            assert len(ax.get_children()) > 0
+
+    if layout is not None:
+        x_set = set()
+        y_set = set()
+        for ax in flatten_axes(axes):
+            # check axes coordinates to estimate layout
+            points = ax.get_position().get_points()
+            x_set.add(points[0][0])
+            y_set.add(points[0][1])
+        result = (len(y_set), len(x_set))
+        assert result == layout
+
+    tm.assert_numpy_array_equal(
+        visible_axes[0].figure.get_size_inches(),
+        np.array(figsize, dtype=np.float64),
+    )
+
+
+def _flatten_visible(axes: Axes | Sequence[Axes]) -> Sequence[Axes]:
+    """
+    Flatten axes, and filter only visible
+
+    Parameters
+    ----------
+    axes : matplotlib Axes object, or its list-like
+
+    """
+    from pandas.plotting._matplotlib.tools import flatten_axes
+
+    axes_ndarray = flatten_axes(axes)
+    axes = [ax for ax in axes_ndarray if ax.get_visible()]
+    return axes
+
+
+def _check_has_errorbars(axes, xerr=0, yerr=0):
+    """
+    Check axes has expected number of errorbars
+
+    Parameters
+    ----------
+    axes : matplotlib Axes object, or its list-like
+    xerr : number
+        expected number of x errorbar
+    yerr : number
+        expected number of y errorbar
+    """
+    axes = _flatten_visible(axes)
+    for ax in axes:
+        containers = ax.containers
+        xerr_count = 0
+        yerr_count = 0
+        for c in containers:
+            has_xerr = getattr(c, "has_xerr", False)
+            has_yerr = getattr(c, "has_yerr", False)
+            if has_xerr:
+                xerr_count += 1
+            if has_yerr:
+                yerr_count += 1
+        assert xerr == xerr_count
+        assert yerr == yerr_count
+
+
+def _check_box_return_type(
+    returned, return_type, expected_keys=None, check_ax_title=True
+):
+    """
+    Check box returned type is correct
+
+    Parameters
+    ----------
+    returned : object to be tested, returned from boxplot
+    return_type : str
+        return_type passed to boxplot
+    expected_keys : list-like, optional
+        group labels in subplot case. If not passed,
+        the function checks assuming boxplot uses single ax
+    check_ax_title : bool
+        Whether to check the ax.title is the same as expected_key
+        Intended to be checked by calling from ``boxplot``.
+        Normal ``plot`` doesn't attach ``ax.title``, it must be disabled.
+    """
+    from matplotlib.axes import Axes
+
+    types = {"dict": dict, "axes": Axes, "both": tuple}
+    if expected_keys is None:
+        # should be fixed when the returning default is changed
+        if return_type is None:
+            return_type = "dict"
+
+        assert isinstance(returned, types[return_type])
+        if return_type == "both":
+            assert isinstance(returned.ax, Axes)
+            assert isinstance(returned.lines, dict)
+    else:
+        # should be fixed when the returning default is changed
+        if return_type is None:
+            for r in _flatten_visible(returned):
+                assert isinstance(r, Axes)
+            return
+
+        assert isinstance(returned, Series)
+
+        assert sorted(returned.keys()) == sorted(expected_keys)
+        for key, value in returned.items():
+            assert isinstance(value, types[return_type])
+            # check returned dict has correct mapping
+            if return_type == "axes":
+                if check_ax_title:
+                    assert value.get_title() == key
+            elif return_type == "both":
+                if check_ax_title:
+                    assert value.ax.get_title() == key
+                assert isinstance(value.ax, Axes)
+                assert isinstance(value.lines, dict)
+            elif return_type == "dict":
+                line = value["medians"][0]
+                axes = line.axes
+                if check_ax_title:
+                    assert axes.get_title() == key
+            else:
+                raise AssertionError
+
+
+def _check_grid_settings(obj, kinds, kws={}):
+    # Make sure plot defaults to rcParams['axes.grid'] setting, GH 9792
+
+    import matplotlib as mpl
+
+    def is_grid_on():
+        xticks = mpl.pyplot.gca().xaxis.get_major_ticks()
+        yticks = mpl.pyplot.gca().yaxis.get_major_ticks()
+        xoff = all(not g.gridline.get_visible() for g in xticks)
+        yoff = all(not g.gridline.get_visible() for g in yticks)
+
+        return not (xoff and yoff)
+
+    spndx = 1
+    for kind in kinds:
+        mpl.pyplot.subplot(1, 4 * len(kinds), spndx)
+        spndx += 1
+        mpl.rc("axes", grid=False)
+        obj.plot(kind=kind, **kws)
+        assert not is_grid_on()
+        mpl.pyplot.clf()
+
+        mpl.pyplot.subplot(1, 4 * len(kinds), spndx)
+        spndx += 1
+        mpl.rc("axes", grid=True)
+        obj.plot(kind=kind, grid=False, **kws)
+        assert not is_grid_on()
+        mpl.pyplot.clf()
+
+        if kind not in ["pie", "hexbin", "scatter"]:
+            mpl.pyplot.subplot(1, 4 * len(kinds), spndx)
+            spndx += 1
+            mpl.rc("axes", grid=True)
+            obj.plot(kind=kind, **kws)
+            assert is_grid_on()
+            mpl.pyplot.clf()
+
+            mpl.pyplot.subplot(1, 4 * len(kinds), spndx)
+            spndx += 1
+            mpl.rc("axes", grid=False)
+            obj.plot(kind=kind, grid=True, **kws)
+            assert is_grid_on()
+            mpl.pyplot.clf()
+
+
+def _unpack_cycler(rcParams, field="color"):
+    """
+    Auxiliary function for correctly unpacking cycler after MPL >= 1.5
+    """
+    return [v[field] for v in rcParams["axes.prop_cycle"]]
+
+
+def get_x_axis(ax):
+    return ax._shared_axes["x"]
+
+
+def get_y_axis(ax):
+    return ax._shared_axes["y"]
+
+
+def _check_plot_works(f, default_axes=False, **kwargs):
+    """
+    Create plot and ensure that plot return object is valid.
+
+    Parameters
+    ----------
+    f : func
+        Plotting function.
+    default_axes : bool, optional
+        If False (default):
+            - If `ax` not in `kwargs`, then create subplot(211) and plot there
+            - Create new subplot(212) and plot there as well
+            - Mind special corner case for bootstrap_plot (see `_gen_two_subplots`)
+        If True:
+            - Simply run plotting function with kwargs provided
+            - All required axes instances will be created automatically
+            - It is recommended to use it when the plotting function
+            creates multiple axes itself. It helps avoid warnings like
+            'UserWarning: To output multiple subplots,
+            the figure containing the passed axes is being cleared'
+    **kwargs
+        Keyword arguments passed to the plotting function.
+
+    Returns
+    -------
+    Plot object returned by the last plotting.
+    """
+    import matplotlib.pyplot as plt
+
+    if default_axes:
+        gen_plots = _gen_default_plot
+    else:
+        gen_plots = _gen_two_subplots
+
+    ret = None
+    try:
+        fig = kwargs.get("figure", plt.gcf())
+        plt.clf()
+
+        for ret in gen_plots(f, fig, **kwargs):
+            tm.assert_is_valid_plot_return_object(ret)
+
+    finally:
+        plt.close(fig)
+
+    return ret
+
+
+def _gen_default_plot(f, fig, **kwargs):
+    """
+    Create plot in a default way.
+    """
+    yield f(**kwargs)
+
+
+def _gen_two_subplots(f, fig, **kwargs):
+    """
+    Create plot on two subplots forcefully created.
+    """
+    if "ax" not in kwargs:
+        fig.add_subplot(211)
+    yield f(**kwargs)
+
+    if f is pd.plotting.bootstrap_plot:
+        assert "ax" not in kwargs
+    else:
+        kwargs["ax"] = fig.add_subplot(212)
+    yield f(**kwargs)

env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/conftest.py

@@ -0,0 +1,56 @@
+import gc
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    to_datetime,
+)
+
+
+@pytest.fixture(autouse=True)
+def mpl_cleanup():
+    # matplotlib/testing/decorators.py#L24
+    # 1) Resets units registry
+    # 2) Resets rc_context
+    # 3) Closes all figures
+    mpl = pytest.importorskip("matplotlib")
+    mpl_units = pytest.importorskip("matplotlib.units")
+    plt = pytest.importorskip("matplotlib.pyplot")
+    orig_units_registry = mpl_units.registry.copy()
+    with mpl.rc_context():
+        mpl.use("template")
+        yield
+    mpl_units.registry.clear()
+    mpl_units.registry.update(orig_units_registry)
+    plt.close("all")
+    # https://matplotlib.org/stable/users/prev_whats_new/whats_new_3.6.0.html#garbage-collection-is-no-longer-run-on-figure-close  # noqa: E501
+    gc.collect(1)
+
+
+@pytest.fixture
+def hist_df():
+    n = 50
+    rng = np.random.default_rng(10)
+    gender = rng.choice(["Male", "Female"], size=n)
+    classroom = rng.choice(["A", "B", "C"], size=n)
+
+    hist_df = DataFrame(
+        {
+            "gender": gender,
+            "classroom": classroom,
+            "height": rng.normal(66, 4, size=n),
+            "weight": rng.normal(161, 32, size=n),
+            "category": rng.integers(4, size=n),
+            "datetime": to_datetime(
+                rng.integers(
+                    812419200000000000,
+                    819331200000000000,
+                    size=n,
+                    dtype=np.int64,
+                )
+            ),
+        }
+    )
+    return hist_df

env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/frame/test_frame_color.py

@@ -0,0 +1,670 @@
+""" Test cases for DataFrame.plot """
+import re
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import DataFrame
+import pandas._testing as tm
+from pandas.tests.plotting.common import (
+    _check_colors,
+    _check_plot_works,
+    _unpack_cycler,
+)
+from pandas.util.version import Version
+
+mpl = pytest.importorskip("matplotlib")
+plt = pytest.importorskip("matplotlib.pyplot")
+cm = pytest.importorskip("matplotlib.cm")
+
+
+def _check_colors_box(bp, box_c, whiskers_c, medians_c, caps_c="k", fliers_c=None):
+    if fliers_c is None:
+        fliers_c = "k"
+    _check_colors(bp["boxes"], linecolors=[box_c] * len(bp["boxes"]))
+    _check_colors(bp["whiskers"], linecolors=[whiskers_c] * len(bp["whiskers"]))
+    _check_colors(bp["medians"], linecolors=[medians_c] * len(bp["medians"]))
+    _check_colors(bp["fliers"], linecolors=[fliers_c] * len(bp["fliers"]))
+    _check_colors(bp["caps"], linecolors=[caps_c] * len(bp["caps"]))
+
+
+class TestDataFrameColor:
+    @pytest.mark.parametrize(
+        "color", ["C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9"]
+    )
+    def test_mpl2_color_cycle_str(self, color):
+        # GH 15516
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 3)), columns=["a", "b", "c"]
+        )
+        _check_plot_works(df.plot, color=color)
+
+    def test_color_single_series_list(self):
+        # GH 3486
+        df = DataFrame({"A": [1, 2, 3]})
+        _check_plot_works(df.plot, color=["red"])
+
+    @pytest.mark.parametrize("color", [(1, 0, 0), (1, 0, 0, 0.5)])
+    def test_rgb_tuple_color(self, color):
+        # GH 16695
+        df = DataFrame({"x": [1, 2], "y": [3, 4]})
+        _check_plot_works(df.plot, x="x", y="y", color=color)
+
+    def test_color_empty_string(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 2)))
+        with pytest.raises(ValueError, match="Invalid color argument:"):
+            df.plot(color="")
+
+    def test_color_and_style_arguments(self):
+        df = DataFrame({"x": [1, 2], "y": [3, 4]})
+        # passing both 'color' and 'style' arguments should be allowed
+        # if there is no color symbol in the style strings:
+        ax = df.plot(color=["red", "black"], style=["-", "--"])
+        # check that the linestyles are correctly set:
+        linestyle = [line.get_linestyle() for line in ax.lines]
+        assert linestyle == ["-", "--"]
+        # check that the colors are correctly set:
+        color = [line.get_color() for line in ax.lines]
+        assert color == ["red", "black"]
+        # passing both 'color' and 'style' arguments should not be allowed
+        # if there is a color symbol in the style strings:
+        msg = (
+            "Cannot pass 'style' string with a color symbol and 'color' keyword "
+            "argument. Please use one or the other or pass 'style' without a color "
+            "symbol"
+        )
+        with pytest.raises(ValueError, match=msg):
+            df.plot(color=["red", "black"], style=["k-", "r--"])
+
+    @pytest.mark.parametrize(
+        "color, expected",
+        [
+            ("green", ["green"] * 4),
+            (["yellow", "red", "green", "blue"], ["yellow", "red", "green", "blue"]),
+        ],
+    )
+    def test_color_and_marker(self, color, expected):
+        # GH 21003
+        df = DataFrame(np.random.default_rng(2).random((7, 4)))
+        ax = df.plot(color=color, style="d--")
+        # check colors
+        result = [i.get_color() for i in ax.lines]
+        assert result == expected
+        # check markers and linestyles
+        assert all(i.get_linestyle() == "--" for i in ax.lines)
+        assert all(i.get_marker() == "d" for i in ax.lines)
+
+    def test_bar_colors(self):
+        default_colors = _unpack_cycler(plt.rcParams)
+
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        ax = df.plot.bar()
+        _check_colors(ax.patches[::5], facecolors=default_colors[:5])
+
+    def test_bar_colors_custom(self):
+        custom_colors = "rgcby"
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        ax = df.plot.bar(color=custom_colors)
+        _check_colors(ax.patches[::5], facecolors=custom_colors)
+
+    @pytest.mark.parametrize("colormap", ["jet", cm.jet])
+    def test_bar_colors_cmap(self, colormap):
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+
+        ax = df.plot.bar(colormap=colormap)
+        rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, 5)]
+        _check_colors(ax.patches[::5], facecolors=rgba_colors)
+
+    def test_bar_colors_single_col(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        ax = df.loc[:, [0]].plot.bar(color="DodgerBlue")
+        _check_colors([ax.patches[0]], facecolors=["DodgerBlue"])
+
+    def test_bar_colors_green(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        ax = df.plot(kind="bar", color="green")
+        _check_colors(ax.patches[::5], facecolors=["green"] * 5)
+
+    def test_bar_user_colors(self):
+        df = DataFrame(
+            {"A": range(4), "B": range(1, 5), "color": ["red", "blue", "blue", "red"]}
+        )
+        # This should *only* work when `y` is specified, else
+        # we use one color per column
+        ax = df.plot.bar(y="A", color=df["color"])
+        result = [p.get_facecolor() for p in ax.patches]
+        expected = [
+            (1.0, 0.0, 0.0, 1.0),
+            (0.0, 0.0, 1.0, 1.0),
+            (0.0, 0.0, 1.0, 1.0),
+            (1.0, 0.0, 0.0, 1.0),
+        ]
+        assert result == expected
+
+    def test_if_scatterplot_colorbar_affects_xaxis_visibility(self):
+        # addressing issue #10611, to ensure colobar does not
+        # interfere with x-axis label and ticklabels with
+        # ipython inline backend.
+        random_array = np.random.default_rng(2).random((10, 3))
+        df = DataFrame(random_array, columns=["A label", "B label", "C label"])
+
+        ax1 = df.plot.scatter(x="A label", y="B label")
+        ax2 = df.plot.scatter(x="A label", y="B label", c="C label")
+
+        vis1 = [vis.get_visible() for vis in ax1.xaxis.get_minorticklabels()]
+        vis2 = [vis.get_visible() for vis in ax2.xaxis.get_minorticklabels()]
+        assert vis1 == vis2
+
+        vis1 = [vis.get_visible() for vis in ax1.xaxis.get_majorticklabels()]
+        vis2 = [vis.get_visible() for vis in ax2.xaxis.get_majorticklabels()]
+        assert vis1 == vis2
+
+        assert (
+            ax1.xaxis.get_label().get_visible() == ax2.xaxis.get_label().get_visible()
+        )
+
+    def test_if_hexbin_xaxis_label_is_visible(self):
+        # addressing issue #10678, to ensure colobar does not
+        # interfere with x-axis label and ticklabels with
+        # ipython inline backend.
+        random_array = np.random.default_rng(2).random((10, 3))
+        df = DataFrame(random_array, columns=["A label", "B label", "C label"])
+
+        ax = df.plot.hexbin("A label", "B label", gridsize=12)
+        assert all(vis.get_visible() for vis in ax.xaxis.get_minorticklabels())
+        assert all(vis.get_visible() for vis in ax.xaxis.get_majorticklabels())
+        assert ax.xaxis.get_label().get_visible()
+
+    def test_if_scatterplot_colorbars_are_next_to_parent_axes(self):
+        random_array = np.random.default_rng(2).random((10, 3))
+        df = DataFrame(random_array, columns=["A label", "B label", "C label"])
+
+        fig, axes = plt.subplots(1, 2)
+        df.plot.scatter("A label", "B label", c="C label", ax=axes[0])
+        df.plot.scatter("A label", "B label", c="C label", ax=axes[1])
+        plt.tight_layout()
+
+        points = np.array([ax.get_position().get_points() for ax in fig.axes])
+        axes_x_coords = points[:, :, 0]
+        parent_distance = axes_x_coords[1, :] - axes_x_coords[0, :]
+        colorbar_distance = axes_x_coords[3, :] - axes_x_coords[2, :]
+        assert np.isclose(parent_distance, colorbar_distance, atol=1e-7).all()
+
+    @pytest.mark.parametrize("cmap", [None, "Greys"])
+    def test_scatter_with_c_column_name_with_colors(self, cmap):
+        # https://github.com/pandas-dev/pandas/issues/34316
+
+        df = DataFrame(
+            [[5.1, 3.5], [4.9, 3.0], [7.0, 3.2], [6.4, 3.2], [5.9, 3.0]],
+            columns=["length", "width"],
+        )
+        df["species"] = ["r", "r", "g", "g", "b"]
+        if cmap is not None:
+            with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
+                ax = df.plot.scatter(x=0, y=1, cmap=cmap, c="species")
+        else:
+            ax = df.plot.scatter(x=0, y=1, c="species", cmap=cmap)
+        assert ax.collections[0].colorbar is None
+
+    def test_scatter_colors(self):
+        df = DataFrame({"a": [1, 2, 3], "b": [1, 2, 3], "c": [1, 2, 3]})
+        with pytest.raises(TypeError, match="Specify exactly one of `c` and `color`"):
+            df.plot.scatter(x="a", y="b", c="c", color="green")
+
+    def test_scatter_colors_not_raising_warnings(self):
+        # GH-53908. Do not raise UserWarning: No data for colormapping
+        # provided via 'c'. Parameters 'cmap' will be ignored
+        df = DataFrame({"x": [1, 2, 3], "y": [1, 2, 3]})
+        with tm.assert_produces_warning(None):
+            df.plot.scatter(x="x", y="y", c="b")
+
+    def test_scatter_colors_default(self):
+        df = DataFrame({"a": [1, 2, 3], "b": [1, 2, 3], "c": [1, 2, 3]})
+        default_colors = _unpack_cycler(mpl.pyplot.rcParams)
+
+        ax = df.plot.scatter(x="a", y="b", c="c")
+        tm.assert_numpy_array_equal(
+            ax.collections[0].get_facecolor()[0],
+            np.array(mpl.colors.ColorConverter.to_rgba(default_colors[0])),
+        )
+
+    def test_scatter_colors_white(self):
+        df = DataFrame({"a": [1, 2, 3], "b": [1, 2, 3], "c": [1, 2, 3]})
+        ax = df.plot.scatter(x="a", y="b", color="white")
+        tm.assert_numpy_array_equal(
+            ax.collections[0].get_facecolor()[0],
+            np.array([1, 1, 1, 1], dtype=np.float64),
+        )
+
+    def test_scatter_colorbar_different_cmap(self):
+        # GH 33389
+        df = DataFrame({"x": [1, 2, 3], "y": [1, 3, 2], "c": [1, 2, 3]})
+        df["x2"] = df["x"] + 1
+
+        _, ax = plt.subplots()
+        df.plot("x", "y", c="c", kind="scatter", cmap="cividis", ax=ax)
+        df.plot("x2", "y", c="c", kind="scatter", cmap="magma", ax=ax)
+
+        assert ax.collections[0].cmap.name == "cividis"
+        assert ax.collections[1].cmap.name == "magma"
+
+    def test_line_colors(self):
+        custom_colors = "rgcby"
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+
+        ax = df.plot(color=custom_colors)
+        _check_colors(ax.get_lines(), linecolors=custom_colors)
+
+        plt.close("all")
+
+        ax2 = df.plot(color=custom_colors)
+        lines2 = ax2.get_lines()
+
+        for l1, l2 in zip(ax.get_lines(), lines2):
+            assert l1.get_color() == l2.get_color()
+
+    @pytest.mark.parametrize("colormap", ["jet", cm.jet])
+    def test_line_colors_cmap(self, colormap):
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        ax = df.plot(colormap=colormap)
+        rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, len(df))]
+        _check_colors(ax.get_lines(), linecolors=rgba_colors)
+
+    def test_line_colors_single_col(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        # make color a list if plotting one column frame
+        # handles cases like df.plot(color='DodgerBlue')
+        ax = df.loc[:, [0]].plot(color="DodgerBlue")
+        _check_colors(ax.lines, linecolors=["DodgerBlue"])
+
+    def test_line_colors_single_color(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        ax = df.plot(color="red")
+        _check_colors(ax.get_lines(), linecolors=["red"] * 5)
+
+    def test_line_colors_hex(self):
+        # GH 10299
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        custom_colors = ["#FF0000", "#0000FF", "#FFFF00", "#000000", "#FFFFFF"]
+        ax = df.plot(color=custom_colors)
+        _check_colors(ax.get_lines(), linecolors=custom_colors)
+
+    def test_dont_modify_colors(self):
+        colors = ["r", "g", "b"]
+        DataFrame(np.random.default_rng(2).random((10, 2))).plot(color=colors)
+        assert len(colors) == 3
+
+    def test_line_colors_and_styles_subplots(self):
+        # GH 9894
+        default_colors = _unpack_cycler(mpl.pyplot.rcParams)
+
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+
+        axes = df.plot(subplots=True)
+        for ax, c in zip(axes, list(default_colors)):
+            _check_colors(ax.get_lines(), linecolors=[c])
+
+    @pytest.mark.parametrize("color", ["k", "green"])
+    def test_line_colors_and_styles_subplots_single_color_str(self, color):
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        axes = df.plot(subplots=True, color=color)
+        for ax in axes:
+            _check_colors(ax.get_lines(), linecolors=[color])
+
+    @pytest.mark.parametrize("color", ["rgcby", list("rgcby")])
+    def test_line_colors_and_styles_subplots_custom_colors(self, color):
+        # GH 9894
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        axes = df.plot(color=color, subplots=True)
+        for ax, c in zip(axes, list(color)):
+            _check_colors(ax.get_lines(), linecolors=[c])
+
+    def test_line_colors_and_styles_subplots_colormap_hex(self):
+        # GH 9894
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        # GH 10299
+        custom_colors = ["#FF0000", "#0000FF", "#FFFF00", "#000000", "#FFFFFF"]
+        axes = df.plot(color=custom_colors, subplots=True)
+        for ax, c in zip(axes, list(custom_colors)):
+            _check_colors(ax.get_lines(), linecolors=[c])
+
+    @pytest.mark.parametrize("cmap", ["jet", cm.jet])
+    def test_line_colors_and_styles_subplots_colormap_subplot(self, cmap):
+        # GH 9894
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, len(df))]
+        axes = df.plot(colormap=cmap, subplots=True)
+        for ax, c in zip(axes, rgba_colors):
+            _check_colors(ax.get_lines(), linecolors=[c])
+
+    def test_line_colors_and_styles_subplots_single_col(self):
+        # GH 9894
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        # make color a list if plotting one column frame
+        # handles cases like df.plot(color='DodgerBlue')
+        axes = df.loc[:, [0]].plot(color="DodgerBlue", subplots=True)
+        _check_colors(axes[0].lines, linecolors=["DodgerBlue"])
+
+    def test_line_colors_and_styles_subplots_single_char(self):
+        # GH 9894
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        # single character style
+        axes = df.plot(style="r", subplots=True)
+        for ax in axes:
+            _check_colors(ax.get_lines(), linecolors=["r"])
+
+    def test_line_colors_and_styles_subplots_list_styles(self):
+        # GH 9894
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        # list of styles
+        styles = list("rgcby")
+        axes = df.plot(style=styles, subplots=True)
+        for ax, c in zip(axes, styles):
+            _check_colors(ax.get_lines(), linecolors=[c])
+
+    def test_area_colors(self):
+        from matplotlib.collections import PolyCollection
+
+        custom_colors = "rgcby"
+        df = DataFrame(np.random.default_rng(2).random((5, 5)))
+
+        ax = df.plot.area(color=custom_colors)
+        _check_colors(ax.get_lines(), linecolors=custom_colors)
+        poly = [o for o in ax.get_children() if isinstance(o, PolyCollection)]
+        _check_colors(poly, facecolors=custom_colors)
+
+        handles, _ = ax.get_legend_handles_labels()
+        _check_colors(handles, facecolors=custom_colors)
+
+        for h in handles:
+            assert h.get_alpha() is None
+
+    def test_area_colors_poly(self):
+        from matplotlib import cm
+        from matplotlib.collections import PolyCollection
+
+        df = DataFrame(np.random.default_rng(2).random((5, 5)))
+        ax = df.plot.area(colormap="jet")
+        jet_colors = [cm.jet(n) for n in np.linspace(0, 1, len(df))]
+        _check_colors(ax.get_lines(), linecolors=jet_colors)
+        poly = [o for o in ax.get_children() if isinstance(o, PolyCollection)]
+        _check_colors(poly, facecolors=jet_colors)
+
+        handles, _ = ax.get_legend_handles_labels()
+        _check_colors(handles, facecolors=jet_colors)
+        for h in handles:
+            assert h.get_alpha() is None
+
+    def test_area_colors_stacked_false(self):
+        from matplotlib import cm
+        from matplotlib.collections import PolyCollection
+
+        df = DataFrame(np.random.default_rng(2).random((5, 5)))
+        jet_colors = [cm.jet(n) for n in np.linspace(0, 1, len(df))]
+        # When stacked=False, alpha is set to 0.5
+        ax = df.plot.area(colormap=cm.jet, stacked=False)
+        _check_colors(ax.get_lines(), linecolors=jet_colors)
+        poly = [o for o in ax.get_children() if isinstance(o, PolyCollection)]
+        jet_with_alpha = [(c[0], c[1], c[2], 0.5) for c in jet_colors]
+        _check_colors(poly, facecolors=jet_with_alpha)
+
+        handles, _ = ax.get_legend_handles_labels()
+        linecolors = jet_with_alpha
+        _check_colors(handles[: len(jet_colors)], linecolors=linecolors)
+        for h in handles:
+            assert h.get_alpha() == 0.5
+
+    def test_hist_colors(self):
+        default_colors = _unpack_cycler(mpl.pyplot.rcParams)
+
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        ax = df.plot.hist()
+        _check_colors(ax.patches[::10], facecolors=default_colors[:5])
+
+    def test_hist_colors_single_custom(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        custom_colors = "rgcby"
+        ax = df.plot.hist(color=custom_colors)
+        _check_colors(ax.patches[::10], facecolors=custom_colors)
+
+    @pytest.mark.parametrize("colormap", ["jet", cm.jet])
+    def test_hist_colors_cmap(self, colormap):
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        ax = df.plot.hist(colormap=colormap)
+        rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, 5)]
+        _check_colors(ax.patches[::10], facecolors=rgba_colors)
+
+    def test_hist_colors_single_col(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        ax = df.loc[:, [0]].plot.hist(color="DodgerBlue")
+        _check_colors([ax.patches[0]], facecolors=["DodgerBlue"])
+
+    def test_hist_colors_single_color(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        ax = df.plot(kind="hist", color="green")
+        _check_colors(ax.patches[::10], facecolors=["green"] * 5)
+
+    def test_kde_colors(self):
+        pytest.importorskip("scipy")
+        custom_colors = "rgcby"
+        df = DataFrame(np.random.default_rng(2).random((5, 5)))
+
+        ax = df.plot.kde(color=custom_colors)
+        _check_colors(ax.get_lines(), linecolors=custom_colors)
+
+    @pytest.mark.parametrize("colormap", ["jet", cm.jet])
+    def test_kde_colors_cmap(self, colormap):
+        pytest.importorskip("scipy")
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        ax = df.plot.kde(colormap=colormap)
+        rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, len(df))]
+        _check_colors(ax.get_lines(), linecolors=rgba_colors)
+
+    def test_kde_colors_and_styles_subplots(self):
+        pytest.importorskip("scipy")
+        default_colors = _unpack_cycler(mpl.pyplot.rcParams)
+
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+
+        axes = df.plot(kind="kde", subplots=True)
+        for ax, c in zip(axes, list(default_colors)):
+            _check_colors(ax.get_lines(), linecolors=[c])
+
+    @pytest.mark.parametrize("colormap", ["k", "red"])
+    def test_kde_colors_and_styles_subplots_single_col_str(self, colormap):
+        pytest.importorskip("scipy")
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        axes = df.plot(kind="kde", color=colormap, subplots=True)
+        for ax in axes:
+            _check_colors(ax.get_lines(), linecolors=[colormap])
+
+    def test_kde_colors_and_styles_subplots_custom_color(self):
+        pytest.importorskip("scipy")
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        custom_colors = "rgcby"
+        axes = df.plot(kind="kde", color=custom_colors, subplots=True)
+        for ax, c in zip(axes, list(custom_colors)):
+            _check_colors(ax.get_lines(), linecolors=[c])
+
+    @pytest.mark.parametrize("colormap", ["jet", cm.jet])
+    def test_kde_colors_and_styles_subplots_cmap(self, colormap):
+        pytest.importorskip("scipy")
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, len(df))]
+        axes = df.plot(kind="kde", colormap=colormap, subplots=True)
+        for ax, c in zip(axes, rgba_colors):
+            _check_colors(ax.get_lines(), linecolors=[c])
+
+    def test_kde_colors_and_styles_subplots_single_col(self):
+        pytest.importorskip("scipy")
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        # make color a list if plotting one column frame
+        # handles cases like df.plot(color='DodgerBlue')
+        axes = df.loc[:, [0]].plot(kind="kde", color="DodgerBlue", subplots=True)
+        _check_colors(axes[0].lines, linecolors=["DodgerBlue"])
+
+    def test_kde_colors_and_styles_subplots_single_char(self):
+        pytest.importorskip("scipy")
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        # list of styles
+        # single character style
+        axes = df.plot(kind="kde", style="r", subplots=True)
+        for ax in axes:
+            _check_colors(ax.get_lines(), linecolors=["r"])
+
+    def test_kde_colors_and_styles_subplots_list(self):
+        pytest.importorskip("scipy")
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        # list of styles
+        styles = list("rgcby")
+        axes = df.plot(kind="kde", style=styles, subplots=True)
+        for ax, c in zip(axes, styles):
+            _check_colors(ax.get_lines(), linecolors=[c])
+
+    def test_boxplot_colors(self):
+        default_colors = _unpack_cycler(mpl.pyplot.rcParams)
+
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        bp = df.plot.box(return_type="dict")
+        _check_colors_box(
+            bp,
+            default_colors[0],
+            default_colors[0],
+            default_colors[2],
+            default_colors[0],
+        )
+
+    def test_boxplot_colors_dict_colors(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        dict_colors = {
+            "boxes": "#572923",
+            "whiskers": "#982042",
+            "medians": "#804823",
+            "caps": "#123456",
+        }
+        bp = df.plot.box(color=dict_colors, sym="r+", return_type="dict")
+        _check_colors_box(
+            bp,
+            dict_colors["boxes"],
+            dict_colors["whiskers"],
+            dict_colors["medians"],
+            dict_colors["caps"],
+            "r",
+        )
+
+    def test_boxplot_colors_default_color(self):
+        default_colors = _unpack_cycler(mpl.pyplot.rcParams)
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        # partial colors
+        dict_colors = {"whiskers": "c", "medians": "m"}
+        bp = df.plot.box(color=dict_colors, return_type="dict")
+        _check_colors_box(bp, default_colors[0], "c", "m", default_colors[0])
+
+    @pytest.mark.parametrize("colormap", ["jet", cm.jet])
+    def test_boxplot_colors_cmap(self, colormap):
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        bp = df.plot.box(colormap=colormap, return_type="dict")
+        jet_colors = [cm.jet(n) for n in np.linspace(0, 1, 3)]
+        _check_colors_box(
+            bp, jet_colors[0], jet_colors[0], jet_colors[2], jet_colors[0]
+        )
+
+    def test_boxplot_colors_single(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        # string color is applied to all artists except fliers
+        bp = df.plot.box(color="DodgerBlue", return_type="dict")
+        _check_colors_box(bp, "DodgerBlue", "DodgerBlue", "DodgerBlue", "DodgerBlue")
+
+    def test_boxplot_colors_tuple(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        # tuple is also applied to all artists except fliers
+        bp = df.plot.box(color=(0, 1, 0), sym="#123456", return_type="dict")
+        _check_colors_box(bp, (0, 1, 0), (0, 1, 0), (0, 1, 0), (0, 1, 0), "#123456")
+
+    def test_boxplot_colors_invalid(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        msg = re.escape(
+            "color dict contains invalid key 'xxxx'. The key must be either "
+            "['boxes', 'whiskers', 'medians', 'caps']"
+        )
+        with pytest.raises(ValueError, match=msg):
+            # Color contains invalid key results in ValueError
+            df.plot.box(color={"boxes": "red", "xxxx": "blue"})
+
+    def test_default_color_cycle(self):
+        import cycler
+
+        colors = list("rgbk")
+        plt.rcParams["axes.prop_cycle"] = cycler.cycler("color", colors)
+
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 3)))
+        ax = df.plot()
+
+        expected = _unpack_cycler(plt.rcParams)[:3]
+        _check_colors(ax.get_lines(), linecolors=expected)
+
+    def test_no_color_bar(self):
+        df = DataFrame(
+            {
+                "A": np.random.default_rng(2).uniform(size=20),
+                "B": np.random.default_rng(2).uniform(size=20),
+                "C": np.arange(20) + np.random.default_rng(2).uniform(size=20),
+            }
+        )
+        ax = df.plot.hexbin(x="A", y="B", colorbar=None)
+        assert ax.collections[0].colorbar is None
+
+    def test_mixing_cmap_and_colormap_raises(self):
+        df = DataFrame(
+            {
+                "A": np.random.default_rng(2).uniform(size=20),
+                "B": np.random.default_rng(2).uniform(size=20),
+                "C": np.arange(20) + np.random.default_rng(2).uniform(size=20),
+            }
+        )
+        msg = "Only specify one of `cmap` and `colormap`"
+        with pytest.raises(TypeError, match=msg):
+            df.plot.hexbin(x="A", y="B", cmap="YlGn", colormap="BuGn")
+
+    def test_passed_bar_colors(self):
+        color_tuples = [(0.9, 0, 0, 1), (0, 0.9, 0, 1), (0, 0, 0.9, 1)]
+        colormap = mpl.colors.ListedColormap(color_tuples)
+        barplot = DataFrame([[1, 2, 3]]).plot(kind="bar", cmap=colormap)
+        assert color_tuples == [c.get_facecolor() for c in barplot.patches]
+
+    def test_rcParams_bar_colors(self):
+        color_tuples = [(0.9, 0, 0, 1), (0, 0.9, 0, 1), (0, 0, 0.9, 1)]
+        with mpl.rc_context(rc={"axes.prop_cycle": mpl.cycler("color", color_tuples)}):
+            barplot = DataFrame([[1, 2, 3]]).plot(kind="bar")
+        assert color_tuples == [c.get_facecolor() for c in barplot.patches]
+
+    def test_colors_of_columns_with_same_name(self):
+        # ISSUE 11136 -> https://github.com/pandas-dev/pandas/issues/11136
+        # Creating a DataFrame with duplicate column labels and testing colors of them.
+        df = DataFrame({"b": [0, 1, 0], "a": [1, 2, 3]})
+        df1 = DataFrame({"a": [2, 4, 6]})
+        df_concat = pd.concat([df, df1], axis=1)
+        result = df_concat.plot()
+        legend = result.get_legend()
+        if Version(mpl.__version__) < Version("3.7"):
+            handles = legend.legendHandles
+        else:
+            handles = legend.legend_handles
+        for legend, line in zip(handles, result.lines):
+            assert legend.get_color() == line.get_color()
+
+    def test_invalid_colormap(self):
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 2)), columns=["A", "B"]
+        )
+        msg = "(is not a valid value)|(is not a known colormap)"
+        with pytest.raises((ValueError, KeyError), match=msg):
+            df.plot(colormap="invalid_colormap")
+
+    def test_dataframe_none_color(self):
+        # GH51953
+        df = DataFrame([[1, 2, 3]])
+        ax = df.plot(color=None)
+        expected = _unpack_cycler(mpl.pyplot.rcParams)[:3]
+        _check_colors(ax.get_lines(), linecolors=expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/frame/test_frame_groupby.py

@@ -0,0 +1,72 @@
+""" Test cases for DataFrame.plot """
+
+import pytest
+
+from pandas import DataFrame
+from pandas.tests.plotting.common import _check_visible
+
+pytest.importorskip("matplotlib")
+
+
+class TestDataFramePlotsGroupby:
+    def _assert_ytickslabels_visibility(self, axes, expected):
+        for ax, exp in zip(axes, expected):
+            _check_visible(ax.get_yticklabels(), visible=exp)
+
+    def _assert_xtickslabels_visibility(self, axes, expected):
+        for ax, exp in zip(axes, expected):
+            _check_visible(ax.get_xticklabels(), visible=exp)
+
+    @pytest.mark.parametrize(
+        "kwargs, expected",
+        [
+            # behavior without keyword
+            ({}, [True, False, True, False]),
+            # set sharey=True should be identical
+            ({"sharey": True}, [True, False, True, False]),
+            # sharey=False, all yticklabels should be visible
+            ({"sharey": False}, [True, True, True, True]),
+        ],
+    )
+    def test_groupby_boxplot_sharey(self, kwargs, expected):
+        # https://github.com/pandas-dev/pandas/issues/20968
+        # sharey can now be switched check whether the right
+        # pair of axes is turned on or off
+        df = DataFrame(
+            {
+                "a": [-1.43, -0.15, -3.70, -1.43, -0.14],
+                "b": [0.56, 0.84, 0.29, 0.56, 0.85],
+                "c": [0, 1, 2, 3, 1],
+            },
+            index=[0, 1, 2, 3, 4],
+        )
+        axes = df.groupby("c").boxplot(**kwargs)
+        self._assert_ytickslabels_visibility(axes, expected)
+
+    @pytest.mark.parametrize(
+        "kwargs, expected",
+        [
+            # behavior without keyword
+            ({}, [True, True, True, True]),
+            # set sharex=False should be identical
+            ({"sharex": False}, [True, True, True, True]),
+            # sharex=True, xticklabels should be visible
+            # only for bottom plots
+            ({"sharex": True}, [False, False, True, True]),
+        ],
+    )
+    def test_groupby_boxplot_sharex(self, kwargs, expected):
+        # https://github.com/pandas-dev/pandas/issues/20968
+        # sharex can now be switched check whether the right
+        # pair of axes is turned on or off
+
+        df = DataFrame(
+            {
+                "a": [-1.43, -0.15, -3.70, -1.43, -0.14],
+                "b": [0.56, 0.84, 0.29, 0.56, 0.85],
+                "c": [0, 1, 2, 3, 1],
+            },
+            index=[0, 1, 2, 3, 4],
+        )
+        axes = df.groupby("c").boxplot(**kwargs)
+        self._assert_xtickslabels_visibility(axes, expected)

env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/frame/test_frame_legend.py

@@ -0,0 +1,272 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import (
+    DataFrame,
+    date_range,
+)
+from pandas.tests.plotting.common import (
+    _check_legend_labels,
+    _check_legend_marker,
+    _check_text_labels,
+)
+from pandas.util.version import Version
+
+mpl = pytest.importorskip("matplotlib")
+
+
+class TestFrameLegend:
+    @pytest.mark.xfail(
+        reason=(
+            "Open bug in matplotlib "
+            "https://github.com/matplotlib/matplotlib/issues/11357"
+        )
+    )
+    def test_mixed_yerr(self):
+        # https://github.com/pandas-dev/pandas/issues/39522
+        from matplotlib.collections import LineCollection
+        from matplotlib.lines import Line2D
+
+        df = DataFrame([{"x": 1, "a": 1, "b": 1}, {"x": 2, "a": 2, "b": 3}])
+
+        ax = df.plot("x", "a", c="orange", yerr=0.1, label="orange")
+        df.plot("x", "b", c="blue", yerr=None, ax=ax, label="blue")
+
+        legend = ax.get_legend()
+        if Version(mpl.__version__) < Version("3.7"):
+            result_handles = legend.legendHandles
+        else:
+            result_handles = legend.legend_handles
+
+        assert isinstance(result_handles[0], LineCollection)
+        assert isinstance(result_handles[1], Line2D)
+
+    def test_legend_false(self):
+        # https://github.com/pandas-dev/pandas/issues/40044
+        df = DataFrame({"a": [1, 1], "b": [2, 3]})
+        df2 = DataFrame({"d": [2.5, 2.5]})
+
+        ax = df.plot(legend=True, color={"a": "blue", "b": "green"}, secondary_y="b")
+        df2.plot(legend=True, color={"d": "red"}, ax=ax)
+        legend = ax.get_legend()
+        if Version(mpl.__version__) < Version("3.7"):
+            handles = legend.legendHandles
+        else:
+            handles = legend.legend_handles
+        result = [handle.get_color() for handle in handles]
+        expected = ["blue", "green", "red"]
+        assert result == expected
+
+    @pytest.mark.parametrize("kind", ["line", "bar", "barh", "kde", "area", "hist"])
+    def test_df_legend_labels(self, kind):
+        pytest.importorskip("scipy")
+        df = DataFrame(np.random.default_rng(2).random((3, 3)), columns=["a", "b", "c"])
+        df2 = DataFrame(
+            np.random.default_rng(2).random((3, 3)), columns=["d", "e", "f"]
+        )
+        df3 = DataFrame(
+            np.random.default_rng(2).random((3, 3)), columns=["g", "h", "i"]
+        )
+        df4 = DataFrame(
+            np.random.default_rng(2).random((3, 3)), columns=["j", "k", "l"]
+        )
+
+        ax = df.plot(kind=kind, legend=True)
+        _check_legend_labels(ax, labels=df.columns)
+
+        ax = df2.plot(kind=kind, legend=False, ax=ax)
+        _check_legend_labels(ax, labels=df.columns)
+
+        ax = df3.plot(kind=kind, legend=True, ax=ax)
+        _check_legend_labels(ax, labels=df.columns.union(df3.columns))
+
+        ax = df4.plot(kind=kind, legend="reverse", ax=ax)
+        expected = list(df.columns.union(df3.columns)) + list(reversed(df4.columns))
+        _check_legend_labels(ax, labels=expected)
+
+    def test_df_legend_labels_secondary_y(self):
+        pytest.importorskip("scipy")
+        df = DataFrame(np.random.default_rng(2).random((3, 3)), columns=["a", "b", "c"])
+        df2 = DataFrame(
+            np.random.default_rng(2).random((3, 3)), columns=["d", "e", "f"]
+        )
+        df3 = DataFrame(
+            np.random.default_rng(2).random((3, 3)), columns=["g", "h", "i"]
+        )
+        # Secondary Y
+        ax = df.plot(legend=True, secondary_y="b")
+        _check_legend_labels(ax, labels=["a", "b (right)", "c"])
+        ax = df2.plot(legend=False, ax=ax)
+        _check_legend_labels(ax, labels=["a", "b (right)", "c"])
+        ax = df3.plot(kind="bar", legend=True, secondary_y="h", ax=ax)
+        _check_legend_labels(ax, labels=["a", "b (right)", "c", "g", "h (right)", "i"])
+
+    def test_df_legend_labels_time_series(self):
+        # Time Series
+        pytest.importorskip("scipy")
+        ind = date_range("1/1/2014", periods=3)
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 3)),
+            columns=["a", "b", "c"],
+            index=ind,
+        )
+        df2 = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 3)),
+            columns=["d", "e", "f"],
+            index=ind,
+        )
+        df3 = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 3)),
+            columns=["g", "h", "i"],
+            index=ind,
+        )
+        ax = df.plot(legend=True, secondary_y="b")
+        _check_legend_labels(ax, labels=["a", "b (right)", "c"])
+        ax = df2.plot(legend=False, ax=ax)
+        _check_legend_labels(ax, labels=["a", "b (right)", "c"])
+        ax = df3.plot(legend=True, ax=ax)
+        _check_legend_labels(ax, labels=["a", "b (right)", "c", "g", "h", "i"])
+
+    def test_df_legend_labels_time_series_scatter(self):
+        # Time Series
+        pytest.importorskip("scipy")
+        ind = date_range("1/1/2014", periods=3)
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 3)),
+            columns=["a", "b", "c"],
+            index=ind,
+        )
+        df2 = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 3)),
+            columns=["d", "e", "f"],
+            index=ind,
+        )
+        df3 = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 3)),
+            columns=["g", "h", "i"],
+            index=ind,
+        )
+        # scatter
+        ax = df.plot.scatter(x="a", y="b", label="data1")
+        _check_legend_labels(ax, labels=["data1"])
+        ax = df2.plot.scatter(x="d", y="e", legend=False, label="data2", ax=ax)
+        _check_legend_labels(ax, labels=["data1"])
+        ax = df3.plot.scatter(x="g", y="h", label="data3", ax=ax)
+        _check_legend_labels(ax, labels=["data1", "data3"])
+
+    def test_df_legend_labels_time_series_no_mutate(self):
+        pytest.importorskip("scipy")
+        ind = date_range("1/1/2014", periods=3)
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 3)),
+            columns=["a", "b", "c"],
+            index=ind,
+        )
+        # ensure label args pass through and
+        # index name does not mutate
+        # column names don't mutate
+        df5 = df.set_index("a")
+        ax = df5.plot(y="b")
+        _check_legend_labels(ax, labels=["b"])
+        ax = df5.plot(y="b", label="LABEL_b")
+        _check_legend_labels(ax, labels=["LABEL_b"])
+        _check_text_labels(ax.xaxis.get_label(), "a")
+        ax = df5.plot(y="c", label="LABEL_c", ax=ax)
+        _check_legend_labels(ax, labels=["LABEL_b", "LABEL_c"])
+        assert df5.columns.tolist() == ["b", "c"]
+
+    def test_missing_marker_multi_plots_on_same_ax(self):
+        # GH 18222
+        df = DataFrame(data=[[1, 1, 1, 1], [2, 2, 4, 8]], columns=["x", "r", "g", "b"])
+        _, ax = mpl.pyplot.subplots(nrows=1, ncols=3)
+        # Left plot
+        df.plot(x="x", y="r", linewidth=0, marker="o", color="r", ax=ax[0])
+        df.plot(x="x", y="g", linewidth=1, marker="x", color="g", ax=ax[0])
+        df.plot(x="x", y="b", linewidth=1, marker="o", color="b", ax=ax[0])
+        _check_legend_labels(ax[0], labels=["r", "g", "b"])
+        _check_legend_marker(ax[0], expected_markers=["o", "x", "o"])
+        # Center plot
+        df.plot(x="x", y="b", linewidth=1, marker="o", color="b", ax=ax[1])
+        df.plot(x="x", y="r", linewidth=0, marker="o", color="r", ax=ax[1])
+        df.plot(x="x", y="g", linewidth=1, marker="x", color="g", ax=ax[1])
+        _check_legend_labels(ax[1], labels=["b", "r", "g"])
+        _check_legend_marker(ax[1], expected_markers=["o", "o", "x"])
+        # Right plot
+        df.plot(x="x", y="g", linewidth=1, marker="x", color="g", ax=ax[2])
+        df.plot(x="x", y="b", linewidth=1, marker="o", color="b", ax=ax[2])
+        df.plot(x="x", y="r", linewidth=0, marker="o", color="r", ax=ax[2])
+        _check_legend_labels(ax[2], labels=["g", "b", "r"])
+        _check_legend_marker(ax[2], expected_markers=["x", "o", "o"])
+
+    def test_legend_name(self):
+        multi = DataFrame(
+            np.random.default_rng(2).standard_normal((4, 4)),
+            columns=[np.array(["a", "a", "b", "b"]), np.array(["x", "y", "x", "y"])],
+        )
+        multi.columns.names = ["group", "individual"]
+
+        ax = multi.plot()
+        leg_title = ax.legend_.get_title()
+        _check_text_labels(leg_title, "group,individual")
+
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        ax = df.plot(legend=True, ax=ax)
+        leg_title = ax.legend_.get_title()
+        _check_text_labels(leg_title, "group,individual")
+
+        df.columns.name = "new"
+        ax = df.plot(legend=False, ax=ax)
+        leg_title = ax.legend_.get_title()
+        _check_text_labels(leg_title, "group,individual")
+
+        ax = df.plot(legend=True, ax=ax)
+        leg_title = ax.legend_.get_title()
+        _check_text_labels(leg_title, "new")
+
+    @pytest.mark.parametrize(
+        "kind",
+        [
+            "line",
+            "bar",
+            "barh",
+            pytest.param("kde", marks=td.skip_if_no("scipy")),
+            "area",
+            "hist",
+        ],
+    )
+    def test_no_legend(self, kind):
+        df = DataFrame(np.random.default_rng(2).random((3, 3)), columns=["a", "b", "c"])
+        ax = df.plot(kind=kind, legend=False)
+        _check_legend_labels(ax, visible=False)
+
+    def test_missing_markers_legend(self):
+        # 14958
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((8, 3)), columns=["A", "B", "C"]
+        )
+        ax = df.plot(y=["A"], marker="x", linestyle="solid")
+        df.plot(y=["B"], marker="o", linestyle="dotted", ax=ax)
+        df.plot(y=["C"], marker="<", linestyle="dotted", ax=ax)
+
+        _check_legend_labels(ax, labels=["A", "B", "C"])
+        _check_legend_marker(ax, expected_markers=["x", "o", "<"])
+
+    def test_missing_markers_legend_using_style(self):
+        # 14563
+        df = DataFrame(
+            {
+                "A": [1, 2, 3, 4, 5, 6],
+                "B": [2, 4, 1, 3, 2, 4],
+                "C": [3, 3, 2, 6, 4, 2],
+                "X": [1, 2, 3, 4, 5, 6],
+            }
+        )
+
+        _, ax = mpl.pyplot.subplots()
+        for kind in "ABC":
+            df.plot("X", kind, label=kind, ax=ax, style=".")
+
+        _check_legend_labels(ax, labels=["A", "B", "C"])
+        _check_legend_marker(ax, expected_markers=[".", ".", "."])

env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/frame/test_frame_subplots.py

@@ -0,0 +1,752 @@
+""" Test cases for DataFrame.plot """
+
+import string
+
+import numpy as np
+import pytest
+
+from pandas.compat import is_platform_linux
+from pandas.compat.numpy import np_version_gte1p24
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+from pandas.tests.plotting.common import (
+    _check_axes_shape,
+    _check_box_return_type,
+    _check_legend_labels,
+    _check_ticks_props,
+    _check_visible,
+    _flatten_visible,
+)
+
+from pandas.io.formats.printing import pprint_thing
+
+mpl = pytest.importorskip("matplotlib")
+plt = pytest.importorskip("matplotlib.pyplot")
+
+
+class TestDataFramePlotsSubplots:
+    @pytest.mark.slow
+    @pytest.mark.parametrize("kind", ["bar", "barh", "line", "area"])
+    def test_subplots(self, kind):
+        df = DataFrame(
+            np.random.default_rng(2).random((10, 3)),
+            index=list(string.ascii_letters[:10]),
+        )
+
+        axes = df.plot(kind=kind, subplots=True, sharex=True, legend=True)
+        _check_axes_shape(axes, axes_num=3, layout=(3, 1))
+        assert axes.shape == (3,)
+
+        for ax, column in zip(axes, df.columns):
+            _check_legend_labels(ax, labels=[pprint_thing(column)])
+
+        for ax in axes[:-2]:
+            _check_visible(ax.xaxis)  # xaxis must be visible for grid
+            _check_visible(ax.get_xticklabels(), visible=False)
+            if kind != "bar":
+                # change https://github.com/pandas-dev/pandas/issues/26714
+                _check_visible(ax.get_xticklabels(minor=True), visible=False)
+            _check_visible(ax.xaxis.get_label(), visible=False)
+            _check_visible(ax.get_yticklabels())
+
+        _check_visible(axes[-1].xaxis)
+        _check_visible(axes[-1].get_xticklabels())
+        _check_visible(axes[-1].get_xticklabels(minor=True))
+        _check_visible(axes[-1].xaxis.get_label())
+        _check_visible(axes[-1].get_yticklabels())
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("kind", ["bar", "barh", "line", "area"])
+    def test_subplots_no_share_x(self, kind):
+        df = DataFrame(
+            np.random.default_rng(2).random((10, 3)),
+            index=list(string.ascii_letters[:10]),
+        )
+        axes = df.plot(kind=kind, subplots=True, sharex=False)
+        for ax in axes:
+            _check_visible(ax.xaxis)
+            _check_visible(ax.get_xticklabels())
+            _check_visible(ax.get_xticklabels(minor=True))
+            _check_visible(ax.xaxis.get_label())
+            _check_visible(ax.get_yticklabels())
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("kind", ["bar", "barh", "line", "area"])
+    def test_subplots_no_legend(self, kind):
+        df = DataFrame(
+            np.random.default_rng(2).random((10, 3)),
+            index=list(string.ascii_letters[:10]),
+        )
+        axes = df.plot(kind=kind, subplots=True, legend=False)
+        for ax in axes:
+            assert ax.get_legend() is None
+
+    @pytest.mark.parametrize("kind", ["line", "area"])
+    def test_subplots_timeseries(self, kind):
+        idx = date_range(start="2014-07-01", freq="ME", periods=10)
+        df = DataFrame(np.random.default_rng(2).random((10, 3)), index=idx)
+
+        axes = df.plot(kind=kind, subplots=True, sharex=True)
+        _check_axes_shape(axes, axes_num=3, layout=(3, 1))
+
+        for ax in axes[:-2]:
+            # GH 7801
+            _check_visible(ax.xaxis)  # xaxis must be visible for grid
+            _check_visible(ax.get_xticklabels(), visible=False)
+            _check_visible(ax.get_xticklabels(minor=True), visible=False)
+            _check_visible(ax.xaxis.get_label(), visible=False)
+            _check_visible(ax.get_yticklabels())
+
+        _check_visible(axes[-1].xaxis)
+        _check_visible(axes[-1].get_xticklabels())
+        _check_visible(axes[-1].get_xticklabels(minor=True))
+        _check_visible(axes[-1].xaxis.get_label())
+        _check_visible(axes[-1].get_yticklabels())
+        _check_ticks_props(axes, xrot=0)
+
+    @pytest.mark.parametrize("kind", ["line", "area"])
+    def test_subplots_timeseries_rot(self, kind):
+        idx = date_range(start="2014-07-01", freq="ME", periods=10)
+        df = DataFrame(np.random.default_rng(2).random((10, 3)), index=idx)
+        axes = df.plot(kind=kind, subplots=True, sharex=False, rot=45, fontsize=7)
+        for ax in axes:
+            _check_visible(ax.xaxis)
+            _check_visible(ax.get_xticklabels())
+            _check_visible(ax.get_xticklabels(minor=True))
+            _check_visible(ax.xaxis.get_label())
+            _check_visible(ax.get_yticklabels())
+            _check_ticks_props(ax, xlabelsize=7, xrot=45, ylabelsize=7)
+
+    @pytest.mark.parametrize(
+        "col", ["numeric", "timedelta", "datetime_no_tz", "datetime_all_tz"]
+    )
+    def test_subplots_timeseries_y_axis(self, col):
+        # GH16953
+        data = {
+            "numeric": np.array([1, 2, 5]),
+            "timedelta": [
+                pd.Timedelta(-10, unit="s"),
+                pd.Timedelta(10, unit="m"),
+                pd.Timedelta(10, unit="h"),
+            ],
+            "datetime_no_tz": [
+                pd.to_datetime("2017-08-01 00:00:00"),
+                pd.to_datetime("2017-08-01 02:00:00"),
+                pd.to_datetime("2017-08-02 00:00:00"),
+            ],
+            "datetime_all_tz": [
+                pd.to_datetime("2017-08-01 00:00:00", utc=True),
+                pd.to_datetime("2017-08-01 02:00:00", utc=True),
+                pd.to_datetime("2017-08-02 00:00:00", utc=True),
+            ],
+            "text": ["This", "should", "fail"],
+        }
+        testdata = DataFrame(data)
+
+        ax = testdata.plot(y=col)
+        result = ax.get_lines()[0].get_data()[1]
+        expected = testdata[col].values
+        assert (result == expected).all()
+
+    def test_subplots_timeseries_y_text_error(self):
+        # GH16953
+        data = {
+            "numeric": np.array([1, 2, 5]),
+            "text": ["This", "should", "fail"],
+        }
+        testdata = DataFrame(data)
+        msg = "no numeric data to plot"
+        with pytest.raises(TypeError, match=msg):
+            testdata.plot(y="text")
+
+    @pytest.mark.xfail(reason="not support for period, categorical, datetime_mixed_tz")
+    def test_subplots_timeseries_y_axis_not_supported(self):
+        """
+        This test will fail for:
+            period:
+                since period isn't yet implemented in ``select_dtypes``
+                and because it will need a custom value converter +
+                tick formatter (as was done for x-axis plots)
+
+            categorical:
+                 because it will need a custom value converter +
+                 tick formatter (also doesn't work for x-axis, as of now)
+
+            datetime_mixed_tz:
+                because of the way how pandas handles ``Series`` of
+                ``datetime`` objects with different timezone,
+                generally converting ``datetime`` objects in a tz-aware
+                form could help with this problem
+        """
+        data = {
+            "numeric": np.array([1, 2, 5]),
+            "period": [
+                pd.Period("2017-08-01 00:00:00", freq="H"),
+                pd.Period("2017-08-01 02:00", freq="H"),
+                pd.Period("2017-08-02 00:00:00", freq="H"),
+            ],
+            "categorical": pd.Categorical(
+                ["c", "b", "a"], categories=["a", "b", "c"], ordered=False
+            ),
+            "datetime_mixed_tz": [
+                pd.to_datetime("2017-08-01 00:00:00", utc=True),
+                pd.to_datetime("2017-08-01 02:00:00"),
+                pd.to_datetime("2017-08-02 00:00:00"),
+            ],
+        }
+        testdata = DataFrame(data)
+        ax_period = testdata.plot(x="numeric", y="period")
+        assert (
+            ax_period.get_lines()[0].get_data()[1] == testdata["period"].values
+        ).all()
+        ax_categorical = testdata.plot(x="numeric", y="categorical")
+        assert (
+            ax_categorical.get_lines()[0].get_data()[1]
+            == testdata["categorical"].values
+        ).all()
+        ax_datetime_mixed_tz = testdata.plot(x="numeric", y="datetime_mixed_tz")
+        assert (
+            ax_datetime_mixed_tz.get_lines()[0].get_data()[1]
+            == testdata["datetime_mixed_tz"].values
+        ).all()
+
+    @pytest.mark.parametrize(
+        "layout, exp_layout",
+        [
+            [(2, 2), (2, 2)],
+            [(-1, 2), (2, 2)],
+            [(2, -1), (2, 2)],
+            [(1, 4), (1, 4)],
+            [(-1, 4), (1, 4)],
+            [(4, -1), (4, 1)],
+        ],
+    )
+    def test_subplots_layout_multi_column(self, layout, exp_layout):
+        # GH 6667
+        df = DataFrame(
+            np.random.default_rng(2).random((10, 3)),
+            index=list(string.ascii_letters[:10]),
+        )
+
+        axes = df.plot(subplots=True, layout=layout)
+        _check_axes_shape(axes, axes_num=3, layout=exp_layout)
+        assert axes.shape == exp_layout
+
+    def test_subplots_layout_multi_column_error(self):
+        # GH 6667
+        df = DataFrame(
+            np.random.default_rng(2).random((10, 3)),
+            index=list(string.ascii_letters[:10]),
+        )
+        msg = "Layout of 1x1 must be larger than required size 3"
+
+        with pytest.raises(ValueError, match=msg):
+            df.plot(subplots=True, layout=(1, 1))
+
+        msg = "At least one dimension of layout must be positive"
+        with pytest.raises(ValueError, match=msg):
+            df.plot(subplots=True, layout=(-1, -1))
+
+    @pytest.mark.parametrize(
+        "kwargs, expected_axes_num, expected_layout, expected_shape",
+        [
+            ({}, 1, (1, 1), (1,)),
+            ({"layout": (3, 3)}, 1, (3, 3), (3, 3)),
+        ],
+    )
+    def test_subplots_layout_single_column(
+        self, kwargs, expected_axes_num, expected_layout, expected_shape
+    ):
+        # GH 6667
+        df = DataFrame(
+            np.random.default_rng(2).random((10, 1)),
+            index=list(string.ascii_letters[:10]),
+        )
+        axes = df.plot(subplots=True, **kwargs)
+        _check_axes_shape(
+            axes,
+            axes_num=expected_axes_num,
+            layout=expected_layout,
+        )
+        assert axes.shape == expected_shape
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("idx", [range(5), date_range("1/1/2000", periods=5)])
+    def test_subplots_warnings(self, idx):
+        # GH 9464
+        with tm.assert_produces_warning(None):
+            df = DataFrame(np.random.default_rng(2).standard_normal((5, 4)), index=idx)
+            df.plot(subplots=True, layout=(3, 2))
+
+    def test_subplots_multiple_axes(self):
+        # GH 5353, 6970, GH 7069
+        fig, axes = mpl.pyplot.subplots(2, 3)
+        df = DataFrame(
+            np.random.default_rng(2).random((10, 3)),
+            index=list(string.ascii_letters[:10]),
+        )
+
+        returned = df.plot(subplots=True, ax=axes[0], sharex=False, sharey=False)
+        _check_axes_shape(returned, axes_num=3, layout=(1, 3))
+        assert returned.shape == (3,)
+        assert returned[0].figure is fig
+        # draw on second row
+        returned = df.plot(subplots=True, ax=axes[1], sharex=False, sharey=False)
+        _check_axes_shape(returned, axes_num=3, layout=(1, 3))
+        assert returned.shape == (3,)
+        assert returned[0].figure is fig
+        _check_axes_shape(axes, axes_num=6, layout=(2, 3))
+
+    def test_subplots_multiple_axes_error(self):
+        # GH 5353, 6970, GH 7069
+        df = DataFrame(
+            np.random.default_rng(2).random((10, 3)),
+            index=list(string.ascii_letters[:10]),
+        )
+        msg = "The number of passed axes must be 3, the same as the output plot"
+        _, axes = mpl.pyplot.subplots(2, 3)
+
+        with pytest.raises(ValueError, match=msg):
+            # pass different number of axes from required
+            df.plot(subplots=True, ax=axes)
+
+    @pytest.mark.parametrize(
+        "layout, exp_layout",
+        [
+            [(2, 1), (2, 2)],
+            [(2, -1), (2, 2)],
+            [(-1, 2), (2, 2)],
+        ],
+    )
+    def test_subplots_multiple_axes_2_dim(self, layout, exp_layout):
+        # GH 5353, 6970, GH 7069
+        # pass 2-dim axes and invalid layout
+        # invalid lauout should not affect to input and return value
+        # (show warning is tested in
+        # TestDataFrameGroupByPlots.test_grouped_box_multiple_axes
+        _, axes = mpl.pyplot.subplots(2, 2)
+        df = DataFrame(
+            np.random.default_rng(2).random((10, 4)),
+            index=list(string.ascii_letters[:10]),
+        )
+        with tm.assert_produces_warning(UserWarning):
+            returned = df.plot(
+                subplots=True, ax=axes, layout=layout, sharex=False, sharey=False
+            )
+            _check_axes_shape(returned, axes_num=4, layout=exp_layout)
+            assert returned.shape == (4,)
+
+    def test_subplots_multiple_axes_single_col(self):
+        # GH 5353, 6970, GH 7069
+        # single column
+        _, axes = mpl.pyplot.subplots(1, 1)
+        df = DataFrame(
+            np.random.default_rng(2).random((10, 1)),
+            index=list(string.ascii_letters[:10]),
+        )
+
+        axes = df.plot(subplots=True, ax=[axes], sharex=False, sharey=False)
+        _check_axes_shape(axes, axes_num=1, layout=(1, 1))
+        assert axes.shape == (1,)
+
+    def test_subplots_ts_share_axes(self):
+        # GH 3964
+        _, axes = mpl.pyplot.subplots(3, 3, sharex=True, sharey=True)
+        mpl.pyplot.subplots_adjust(left=0.05, right=0.95, hspace=0.3, wspace=0.3)
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 9)),
+            index=date_range(start="2014-07-01", freq="ME", periods=10),
+        )
+        for i, ax in enumerate(axes.ravel()):
+            df[i].plot(ax=ax, fontsize=5)
+
+        # Rows other than bottom should not be visible
+        for ax in axes[0:-1].ravel():
+            _check_visible(ax.get_xticklabels(), visible=False)
+
+        # Bottom row should be visible
+        for ax in axes[-1].ravel():
+            _check_visible(ax.get_xticklabels(), visible=True)
+
+        # First column should be visible
+        for ax in axes[[0, 1, 2], [0]].ravel():
+            _check_visible(ax.get_yticklabels(), visible=True)
+
+        # Other columns should not be visible
+        for ax in axes[[0, 1, 2], [1]].ravel():
+            _check_visible(ax.get_yticklabels(), visible=False)
+        for ax in axes[[0, 1, 2], [2]].ravel():
+            _check_visible(ax.get_yticklabels(), visible=False)
+
+    def test_subplots_sharex_axes_existing_axes(self):
+        # GH 9158
+        d = {"A": [1.0, 2.0, 3.0, 4.0], "B": [4.0, 3.0, 2.0, 1.0], "C": [5, 1, 3, 4]}
+        df = DataFrame(d, index=date_range("2014 10 11", "2014 10 14"))
+
+        axes = df[["A", "B"]].plot(subplots=True)
+        df["C"].plot(ax=axes[0], secondary_y=True)
+
+        _check_visible(axes[0].get_xticklabels(), visible=False)
+        _check_visible(axes[1].get_xticklabels(), visible=True)
+        for ax in axes.ravel():
+            _check_visible(ax.get_yticklabels(), visible=True)
+
+    def test_subplots_dup_columns(self):
+        # GH 10962
+        df = DataFrame(np.random.default_rng(2).random((5, 5)), columns=list("aaaaa"))
+        axes = df.plot(subplots=True)
+        for ax in axes:
+            _check_legend_labels(ax, labels=["a"])
+            assert len(ax.lines) == 1
+
+    def test_subplots_dup_columns_secondary_y(self):
+        # GH 10962
+        df = DataFrame(np.random.default_rng(2).random((5, 5)), columns=list("aaaaa"))
+        axes = df.plot(subplots=True, secondary_y="a")
+        for ax in axes:
+            # (right) is only attached when subplots=False
+            _check_legend_labels(ax, labels=["a"])
+            assert len(ax.lines) == 1
+
+    def test_subplots_dup_columns_secondary_y_no_subplot(self):
+        # GH 10962
+        df = DataFrame(np.random.default_rng(2).random((5, 5)), columns=list("aaaaa"))
+        ax = df.plot(secondary_y="a")
+        _check_legend_labels(ax, labels=["a (right)"] * 5)
+        assert len(ax.lines) == 0
+        assert len(ax.right_ax.lines) == 5
+
+    @pytest.mark.xfail(
+        np_version_gte1p24 and is_platform_linux(),
+        reason="Weird rounding problems",
+        strict=False,
+    )
+    def test_bar_log_no_subplots(self):
+        # GH3254, GH3298 matplotlib/matplotlib#1882, #1892
+        # regressions in 1.2.1
+        expected = np.array([0.1, 1.0, 10.0, 100])
+
+        # no subplots
+        df = DataFrame({"A": [3] * 5, "B": list(range(1, 6))}, index=range(5))
+        ax = df.plot.bar(grid=True, log=True)
+        tm.assert_numpy_array_equal(ax.yaxis.get_ticklocs(), expected)
+
+    @pytest.mark.xfail(
+        np_version_gte1p24 and is_platform_linux(),
+        reason="Weird rounding problems",
+        strict=False,
+    )
+    def test_bar_log_subplots(self):
+        expected = np.array([0.1, 1.0, 10.0, 100.0, 1000.0, 1e4])
+
+        ax = DataFrame([Series([200, 300]), Series([300, 500])]).plot.bar(
+            log=True, subplots=True
+        )
+
+        tm.assert_numpy_array_equal(ax[0].yaxis.get_ticklocs(), expected)
+        tm.assert_numpy_array_equal(ax[1].yaxis.get_ticklocs(), expected)
+
+    def test_boxplot_subplots_return_type_default(self, hist_df):
+        df = hist_df
+
+        # normal style: return_type=None
+        result = df.plot.box(subplots=True)
+        assert isinstance(result, Series)
+        _check_box_return_type(
+            result, None, expected_keys=["height", "weight", "category"]
+        )
+
+    @pytest.mark.parametrize("rt", ["dict", "axes", "both"])
+    def test_boxplot_subplots_return_type(self, hist_df, rt):
+        df = hist_df
+        returned = df.plot.box(return_type=rt, subplots=True)
+        _check_box_return_type(
+            returned,
+            rt,
+            expected_keys=["height", "weight", "category"],
+            check_ax_title=False,
+        )
+
+    def test_df_subplots_patterns_minorticks(self):
+        # GH 10657
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 2)),
+            index=date_range("1/1/2000", periods=10),
+            columns=list("AB"),
+        )
+
+        # shared subplots
+        _, axes = plt.subplots(2, 1, sharex=True)
+        axes = df.plot(subplots=True, ax=axes)
+        for ax in axes:
+            assert len(ax.lines) == 1
+            _check_visible(ax.get_yticklabels(), visible=True)
+        # xaxis of 1st ax must be hidden
+        _check_visible(axes[0].get_xticklabels(), visible=False)
+        _check_visible(axes[0].get_xticklabels(minor=True), visible=False)
+        _check_visible(axes[1].get_xticklabels(), visible=True)
+        _check_visible(axes[1].get_xticklabels(minor=True), visible=True)
+
+    def test_df_subplots_patterns_minorticks_1st_ax_hidden(self):
+        # GH 10657
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 2)),
+            index=date_range("1/1/2000", periods=10),
+            columns=list("AB"),
+        )
+        _, axes = plt.subplots(2, 1)
+        with tm.assert_produces_warning(UserWarning):
+            axes = df.plot(subplots=True, ax=axes, sharex=True)
+        for ax in axes:
+            assert len(ax.lines) == 1
+            _check_visible(ax.get_yticklabels(), visible=True)
+        # xaxis of 1st ax must be hidden
+        _check_visible(axes[0].get_xticklabels(), visible=False)
+        _check_visible(axes[0].get_xticklabels(minor=True), visible=False)
+        _check_visible(axes[1].get_xticklabels(), visible=True)
+        _check_visible(axes[1].get_xticklabels(minor=True), visible=True)
+
+    def test_df_subplots_patterns_minorticks_not_shared(self):
+        # GH 10657
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 2)),
+            index=date_range("1/1/2000", periods=10),
+            columns=list("AB"),
+        )
+        # not shared
+        _, axes = plt.subplots(2, 1)
+        axes = df.plot(subplots=True, ax=axes)
+        for ax in axes:
+            assert len(ax.lines) == 1
+            _check_visible(ax.get_yticklabels(), visible=True)
+            _check_visible(ax.get_xticklabels(), visible=True)
+            _check_visible(ax.get_xticklabels(minor=True), visible=True)
+
+    def test_subplots_sharex_false(self):
+        # test when sharex is set to False, two plots should have different
+        # labels, GH 25160
+        df = DataFrame(np.random.default_rng(2).random((10, 2)))
+        df.iloc[5:, 1] = np.nan
+        df.iloc[:5, 0] = np.nan
+
+        _, axs = mpl.pyplot.subplots(2, 1)
+        df.plot.line(ax=axs, subplots=True, sharex=False)
+
+        expected_ax1 = np.arange(4.5, 10, 0.5)
+        expected_ax2 = np.arange(-0.5, 5, 0.5)
+
+        tm.assert_numpy_array_equal(axs[0].get_xticks(), expected_ax1)
+        tm.assert_numpy_array_equal(axs[1].get_xticks(), expected_ax2)
+
+    def test_subplots_constrained_layout(self):
+        # GH 25261
+        idx = date_range(start="now", periods=10)
+        df = DataFrame(np.random.default_rng(2).random((10, 3)), index=idx)
+        kwargs = {}
+        if hasattr(mpl.pyplot.Figure, "get_constrained_layout"):
+            kwargs["constrained_layout"] = True
+        _, axes = mpl.pyplot.subplots(2, **kwargs)
+        with tm.assert_produces_warning(None):
+            df.plot(ax=axes[0])
+            with tm.ensure_clean(return_filelike=True) as path:
+                mpl.pyplot.savefig(path)
+
+    @pytest.mark.parametrize(
+        "index_name, old_label, new_label",
+        [
+            (None, "", "new"),
+            ("old", "old", "new"),
+            (None, "", ""),
+            (None, "", 1),
+            (None, "", [1, 2]),
+        ],
+    )
+    @pytest.mark.parametrize("kind", ["line", "area", "bar"])
+    def test_xlabel_ylabel_dataframe_subplots(
+        self, kind, index_name, old_label, new_label
+    ):
+        # GH 9093
+        df = DataFrame([[1, 2], [2, 5]], columns=["Type A", "Type B"])
+        df.index.name = index_name
+
+        # default is the ylabel is not shown and xlabel is index name
+        axes = df.plot(kind=kind, subplots=True)
+        assert all(ax.get_ylabel() == "" for ax in axes)
+        assert all(ax.get_xlabel() == old_label for ax in axes)
+
+        # old xlabel will be overridden and assigned ylabel will be used as ylabel
+        axes = df.plot(kind=kind, ylabel=new_label, xlabel=new_label, subplots=True)
+        assert all(ax.get_ylabel() == str(new_label) for ax in axes)
+        assert all(ax.get_xlabel() == str(new_label) for ax in axes)
+
+    @pytest.mark.parametrize(
+        "kwargs",
+        [
+            # stacked center
+            {"kind": "bar", "stacked": True},
+            {"kind": "bar", "stacked": True, "width": 0.9},
+            {"kind": "barh", "stacked": True},
+            {"kind": "barh", "stacked": True, "width": 0.9},
+            # center
+            {"kind": "bar", "stacked": False},
+            {"kind": "bar", "stacked": False, "width": 0.9},
+            {"kind": "barh", "stacked": False},
+            {"kind": "barh", "stacked": False, "width": 0.9},
+            # subplots center
+            {"kind": "bar", "subplots": True},
+            {"kind": "bar", "subplots": True, "width": 0.9},
+            {"kind": "barh", "subplots": True},
+            {"kind": "barh", "subplots": True, "width": 0.9},
+            # align edge
+            {"kind": "bar", "stacked": True, "align": "edge"},
+            {"kind": "bar", "stacked": True, "width": 0.9, "align": "edge"},
+            {"kind": "barh", "stacked": True, "align": "edge"},
+            {"kind": "barh", "stacked": True, "width": 0.9, "align": "edge"},
+            {"kind": "bar", "stacked": False, "align": "edge"},
+            {"kind": "bar", "stacked": False, "width": 0.9, "align": "edge"},
+            {"kind": "barh", "stacked": False, "align": "edge"},
+            {"kind": "barh", "stacked": False, "width": 0.9, "align": "edge"},
+            {"kind": "bar", "subplots": True, "align": "edge"},
+            {"kind": "bar", "subplots": True, "width": 0.9, "align": "edge"},
+            {"kind": "barh", "subplots": True, "align": "edge"},
+            {"kind": "barh", "subplots": True, "width": 0.9, "align": "edge"},
+        ],
+    )
+    def test_bar_align_multiple_columns(self, kwargs):
+        # GH2157
+        df = DataFrame({"A": [3] * 5, "B": list(range(5))}, index=range(5))
+        self._check_bar_alignment(df, **kwargs)
+
+    @pytest.mark.parametrize(
+        "kwargs",
+        [
+            {"kind": "bar", "stacked": False},
+            {"kind": "bar", "stacked": True},
+            {"kind": "barh", "stacked": False},
+            {"kind": "barh", "stacked": True},
+            {"kind": "bar", "subplots": True},
+            {"kind": "barh", "subplots": True},
+        ],
+    )
+    def test_bar_align_single_column(self, kwargs):
+        df = DataFrame(np.random.default_rng(2).standard_normal(5))
+        self._check_bar_alignment(df, **kwargs)
+
+    @pytest.mark.parametrize(
+        "kwargs",
+        [
+            {"kind": "bar", "stacked": False},
+            {"kind": "bar", "stacked": True},
+            {"kind": "barh", "stacked": False},
+            {"kind": "barh", "stacked": True},
+            {"kind": "bar", "subplots": True},
+            {"kind": "barh", "subplots": True},
+        ],
+    )
+    def test_bar_barwidth_position(self, kwargs):
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        self._check_bar_alignment(df, width=0.9, position=0.2, **kwargs)
+
+    @pytest.mark.parametrize("w", [1, 1.0])
+    def test_bar_barwidth_position_int(self, w):
+        # GH 12979
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        ax = df.plot.bar(stacked=True, width=w)
+        ticks = ax.xaxis.get_ticklocs()
+        tm.assert_numpy_array_equal(ticks, np.array([0, 1, 2, 3, 4]))
+        assert ax.get_xlim() == (-0.75, 4.75)
+        # check left-edge of bars
+        assert ax.patches[0].get_x() == -0.5
+        assert ax.patches[-1].get_x() == 3.5
+
+    @pytest.mark.parametrize(
+        "kind, kwargs",
+        [
+            ["bar", {"stacked": True}],
+            ["barh", {"stacked": False}],
+            ["barh", {"stacked": True}],
+            ["bar", {"subplots": True}],
+            ["barh", {"subplots": True}],
+        ],
+    )
+    def test_bar_barwidth_position_int_width_1(self, kind, kwargs):
+        # GH 12979
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)))
+        self._check_bar_alignment(df, kind=kind, width=1, **kwargs)
+
+    def _check_bar_alignment(
+        self,
+        df,
+        kind="bar",
+        stacked=False,
+        subplots=False,
+        align="center",
+        width=0.5,
+        position=0.5,
+    ):
+        axes = df.plot(
+            kind=kind,
+            stacked=stacked,
+            subplots=subplots,
+            align=align,
+            width=width,
+            position=position,
+            grid=True,
+        )
+
+        axes = _flatten_visible(axes)
+
+        for ax in axes:
+            if kind == "bar":
+                axis = ax.xaxis
+                ax_min, ax_max = ax.get_xlim()
+                min_edge = min(p.get_x() for p in ax.patches)
+                max_edge = max(p.get_x() + p.get_width() for p in ax.patches)
+            elif kind == "barh":
+                axis = ax.yaxis
+                ax_min, ax_max = ax.get_ylim()
+                min_edge = min(p.get_y() for p in ax.patches)
+                max_edge = max(p.get_y() + p.get_height() for p in ax.patches)
+            else:
+                raise ValueError
+
+            # GH 7498
+            # compare margins between lim and bar edges
+            tm.assert_almost_equal(ax_min, min_edge - 0.25)
+            tm.assert_almost_equal(ax_max, max_edge + 0.25)
+
+            p = ax.patches[0]
+            if kind == "bar" and (stacked is True or subplots is True):
+                edge = p.get_x()
+                center = edge + p.get_width() * position
+            elif kind == "bar" and stacked is False:
+                center = p.get_x() + p.get_width() * len(df.columns) * position
+                edge = p.get_x()
+            elif kind == "barh" and (stacked is True or subplots is True):
+                center = p.get_y() + p.get_height() * position
+                edge = p.get_y()
+            elif kind == "barh" and stacked is False:
+                center = p.get_y() + p.get_height() * len(df.columns) * position
+                edge = p.get_y()
+            else:
+                raise ValueError
+
+            # Check the ticks locates on integer
+            assert (axis.get_ticklocs() == np.arange(len(df))).all()
+
+            if align == "center":
+                # Check whether the bar locates on center
+                tm.assert_almost_equal(axis.get_ticklocs()[0], center)
+            elif align == "edge":
+                # Check whether the bar's edge starts from the tick
+                tm.assert_almost_equal(axis.get_ticklocs()[0], edge)
+            else:
+                raise ValueError
+
+        return axes

env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/frame/test_hist_box_by.py

@@ -0,0 +1,342 @@
+import re
+
+import numpy as np
+import pytest
+
+from pandas import DataFrame
+import pandas._testing as tm
+from pandas.tests.plotting.common import (
+    _check_axes_shape,
+    _check_plot_works,
+    get_x_axis,
+    get_y_axis,
+)
+
+pytest.importorskip("matplotlib")
+
+
+@pytest.fixture
+def hist_df():
+    df = DataFrame(
+        np.random.default_rng(2).standard_normal((30, 2)), columns=["A", "B"]
+    )
+    df["C"] = np.random.default_rng(2).choice(["a", "b", "c"], 30)
+    df["D"] = np.random.default_rng(2).choice(["a", "b", "c"], 30)
+    return df
+
+
+class TestHistWithBy:
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "by, column, titles, legends",
+        [
+            ("C", "A", ["a", "b", "c"], [["A"]] * 3),
+            ("C", ["A", "B"], ["a", "b", "c"], [["A", "B"]] * 3),
+            ("C", None, ["a", "b", "c"], [["A", "B"]] * 3),
+            (
+                ["C", "D"],
+                "A",
+                [
+                    "(a, a)",
+                    "(b, b)",
+                    "(c, c)",
+                ],
+                [["A"]] * 3,
+            ),
+            (
+                ["C", "D"],
+                ["A", "B"],
+                [
+                    "(a, a)",
+                    "(b, b)",
+                    "(c, c)",
+                ],
+                [["A", "B"]] * 3,
+            ),
+            (
+                ["C", "D"],
+                None,
+                [
+                    "(a, a)",
+                    "(b, b)",
+                    "(c, c)",
+                ],
+                [["A", "B"]] * 3,
+            ),
+        ],
+    )
+    def test_hist_plot_by_argument(self, by, column, titles, legends, hist_df):
+        # GH 15079
+        axes = _check_plot_works(
+            hist_df.plot.hist, column=column, by=by, default_axes=True
+        )
+        result_titles = [ax.get_title() for ax in axes]
+        result_legends = [
+            [legend.get_text() for legend in ax.get_legend().texts] for ax in axes
+        ]
+
+        assert result_legends == legends
+        assert result_titles == titles
+
+    @pytest.mark.parametrize(
+        "by, column, titles, legends",
+        [
+            (0, "A", ["a", "b", "c"], [["A"]] * 3),
+            (0, None, ["a", "b", "c"], [["A", "B"]] * 3),
+            (
+                [0, "D"],
+                "A",
+                [
+                    "(a, a)",
+                    "(b, b)",
+                    "(c, c)",
+                ],
+                [["A"]] * 3,
+            ),
+        ],
+    )
+    def test_hist_plot_by_0(self, by, column, titles, legends, hist_df):
+        # GH 15079
+        df = hist_df.copy()
+        df = df.rename(columns={"C": 0})
+
+        axes = _check_plot_works(df.plot.hist, default_axes=True, column=column, by=by)
+        result_titles = [ax.get_title() for ax in axes]
+        result_legends = [
+            [legend.get_text() for legend in ax.get_legend().texts] for ax in axes
+        ]
+
+        assert result_legends == legends
+        assert result_titles == titles
+
+    @pytest.mark.parametrize(
+        "by, column",
+        [
+            ([], ["A"]),
+            ([], ["A", "B"]),
+            ((), None),
+            ((), ["A", "B"]),
+        ],
+    )
+    def test_hist_plot_empty_list_string_tuple_by(self, by, column, hist_df):
+        # GH 15079
+        msg = "No group keys passed"
+        with pytest.raises(ValueError, match=msg):
+            _check_plot_works(
+                hist_df.plot.hist, default_axes=True, column=column, by=by
+            )
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "by, column, layout, axes_num",
+        [
+            (["C"], "A", (2, 2), 3),
+            ("C", "A", (2, 2), 3),
+            (["C"], ["A"], (1, 3), 3),
+            ("C", None, (3, 1), 3),
+            ("C", ["A", "B"], (3, 1), 3),
+            (["C", "D"], "A", (9, 1), 3),
+            (["C", "D"], "A", (3, 3), 3),
+            (["C", "D"], ["A"], (5, 2), 3),
+            (["C", "D"], ["A", "B"], (9, 1), 3),
+            (["C", "D"], None, (9, 1), 3),
+            (["C", "D"], ["A", "B"], (5, 2), 3),
+        ],
+    )
+    def test_hist_plot_layout_with_by(self, by, column, layout, axes_num, hist_df):
+        # GH 15079
+        # _check_plot_works adds an ax so catch warning. see GH #13188
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
+            axes = _check_plot_works(
+                hist_df.plot.hist, column=column, by=by, layout=layout
+            )
+        _check_axes_shape(axes, axes_num=axes_num, layout=layout)
+
+    @pytest.mark.parametrize(
+        "msg, by, layout",
+        [
+            ("larger than required size", ["C", "D"], (1, 1)),
+            (re.escape("Layout must be a tuple of (rows, columns)"), "C", (1,)),
+            ("At least one dimension of layout must be positive", "C", (-1, -1)),
+        ],
+    )
+    def test_hist_plot_invalid_layout_with_by_raises(self, msg, by, layout, hist_df):
+        # GH 15079, test if error is raised when invalid layout is given
+
+        with pytest.raises(ValueError, match=msg):
+            hist_df.plot.hist(column=["A", "B"], by=by, layout=layout)
+
+    @pytest.mark.slow
+    def test_axis_share_x_with_by(self, hist_df):
+        # GH 15079
+        ax1, ax2, ax3 = hist_df.plot.hist(column="A", by="C", sharex=True)
+
+        # share x
+        assert get_x_axis(ax1).joined(ax1, ax2)
+        assert get_x_axis(ax2).joined(ax1, ax2)
+        assert get_x_axis(ax3).joined(ax1, ax3)
+        assert get_x_axis(ax3).joined(ax2, ax3)
+
+        # don't share y
+        assert not get_y_axis(ax1).joined(ax1, ax2)
+        assert not get_y_axis(ax2).joined(ax1, ax2)
+        assert not get_y_axis(ax3).joined(ax1, ax3)
+        assert not get_y_axis(ax3).joined(ax2, ax3)
+
+    @pytest.mark.slow
+    def test_axis_share_y_with_by(self, hist_df):
+        # GH 15079
+        ax1, ax2, ax3 = hist_df.plot.hist(column="A", by="C", sharey=True)
+
+        # share y
+        assert get_y_axis(ax1).joined(ax1, ax2)
+        assert get_y_axis(ax2).joined(ax1, ax2)
+        assert get_y_axis(ax3).joined(ax1, ax3)
+        assert get_y_axis(ax3).joined(ax2, ax3)
+
+        # don't share x
+        assert not get_x_axis(ax1).joined(ax1, ax2)
+        assert not get_x_axis(ax2).joined(ax1, ax2)
+        assert not get_x_axis(ax3).joined(ax1, ax3)
+        assert not get_x_axis(ax3).joined(ax2, ax3)
+
+    @pytest.mark.parametrize("figsize", [(12, 8), (20, 10)])
+    def test_figure_shape_hist_with_by(self, figsize, hist_df):
+        # GH 15079
+        axes = hist_df.plot.hist(column="A", by="C", figsize=figsize)
+        _check_axes_shape(axes, axes_num=3, figsize=figsize)
+
+
+class TestBoxWithBy:
+    @pytest.mark.parametrize(
+        "by, column, titles, xticklabels",
+        [
+            ("C", "A", ["A"], [["a", "b", "c"]]),
+            (
+                ["C", "D"],
+                "A",
+                ["A"],
+                [
+                    [
+                        "(a, a)",
+                        "(b, b)",
+                        "(c, c)",
+                    ]
+                ],
+            ),
+            ("C", ["A", "B"], ["A", "B"], [["a", "b", "c"]] * 2),
+            (
+                ["C", "D"],
+                ["A", "B"],
+                ["A", "B"],
+                [
+                    [
+                        "(a, a)",
+                        "(b, b)",
+                        "(c, c)",
+                    ]
+                ]
+                * 2,
+            ),
+            (["C"], None, ["A", "B"], [["a", "b", "c"]] * 2),
+        ],
+    )
+    def test_box_plot_by_argument(self, by, column, titles, xticklabels, hist_df):
+        # GH 15079
+        axes = _check_plot_works(
+            hist_df.plot.box, default_axes=True, column=column, by=by
+        )
+        result_titles = [ax.get_title() for ax in axes]
+        result_xticklabels = [
+            [label.get_text() for label in ax.get_xticklabels()] for ax in axes
+        ]
+
+        assert result_xticklabels == xticklabels
+        assert result_titles == titles
+
+    @pytest.mark.parametrize(
+        "by, column, titles, xticklabels",
+        [
+            (0, "A", ["A"], [["a", "b", "c"]]),
+            (
+                [0, "D"],
+                "A",
+                ["A"],
+                [
+                    [
+                        "(a, a)",
+                        "(b, b)",
+                        "(c, c)",
+                    ]
+                ],
+            ),
+            (0, None, ["A", "B"], [["a", "b", "c"]] * 2),
+        ],
+    )
+    def test_box_plot_by_0(self, by, column, titles, xticklabels, hist_df):
+        # GH 15079
+        df = hist_df.copy()
+        df = df.rename(columns={"C": 0})
+
+        axes = _check_plot_works(df.plot.box, default_axes=True, column=column, by=by)
+        result_titles = [ax.get_title() for ax in axes]
+        result_xticklabels = [
+            [label.get_text() for label in ax.get_xticklabels()] for ax in axes
+        ]
+
+        assert result_xticklabels == xticklabels
+        assert result_titles == titles
+
+    @pytest.mark.parametrize(
+        "by, column",
+        [
+            ([], ["A"]),
+            ((), "A"),
+            ([], None),
+            ((), ["A", "B"]),
+        ],
+    )
+    def test_box_plot_with_none_empty_list_by(self, by, column, hist_df):
+        # GH 15079
+        msg = "No group keys passed"
+        with pytest.raises(ValueError, match=msg):
+            _check_plot_works(hist_df.plot.box, default_axes=True, column=column, by=by)
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "by, column, layout, axes_num",
+        [
+            (["C"], "A", (1, 1), 1),
+            ("C", "A", (1, 1), 1),
+            ("C", None, (2, 1), 2),
+            ("C", ["A", "B"], (1, 2), 2),
+            (["C", "D"], "A", (1, 1), 1),
+            (["C", "D"], None, (1, 2), 2),
+        ],
+    )
+    def test_box_plot_layout_with_by(self, by, column, layout, axes_num, hist_df):
+        # GH 15079
+        axes = _check_plot_works(
+            hist_df.plot.box, default_axes=True, column=column, by=by, layout=layout
+        )
+        _check_axes_shape(axes, axes_num=axes_num, layout=layout)
+
+    @pytest.mark.parametrize(
+        "msg, by, layout",
+        [
+            ("larger than required size", ["C", "D"], (1, 1)),
+            (re.escape("Layout must be a tuple of (rows, columns)"), "C", (1,)),
+            ("At least one dimension of layout must be positive", "C", (-1, -1)),
+        ],
+    )
+    def test_box_plot_invalid_layout_with_by_raises(self, msg, by, layout, hist_df):
+        # GH 15079, test if error is raised when invalid layout is given
+
+        with pytest.raises(ValueError, match=msg):
+            hist_df.plot.box(column=["A", "B"], by=by, layout=layout)
+
+    @pytest.mark.parametrize("figsize", [(12, 8), (20, 10)])
+    def test_figure_shape_hist_with_by(self, figsize, hist_df):
+        # GH 15079
+        axes = hist_df.plot.box(column="A", by="C", figsize=figsize)
+        _check_axes_shape(axes, axes_num=1, figsize=figsize)

env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/test_backend.py

@@ -0,0 +1,98 @@
+import sys
+import types
+
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas
+
+
+@pytest.fixture
+def dummy_backend():
+    db = types.ModuleType("pandas_dummy_backend")
+    setattr(db, "plot", lambda *args, **kwargs: "used_dummy")
+    return db
+
+
+@pytest.fixture
+def restore_backend():
+    """Restore the plotting backend to matplotlib"""
+    with pandas.option_context("plotting.backend", "matplotlib"):
+        yield
+
+
+def test_backend_is_not_module():
+    msg = "Could not find plotting backend 'not_an_existing_module'."
+    with pytest.raises(ValueError, match=msg):
+        pandas.set_option("plotting.backend", "not_an_existing_module")
+
+    assert pandas.options.plotting.backend == "matplotlib"
+
+
+def test_backend_is_correct(monkeypatch, restore_backend, dummy_backend):
+    monkeypatch.setitem(sys.modules, "pandas_dummy_backend", dummy_backend)
+
+    pandas.set_option("plotting.backend", "pandas_dummy_backend")
+    assert pandas.get_option("plotting.backend") == "pandas_dummy_backend"
+    assert (
+        pandas.plotting._core._get_plot_backend("pandas_dummy_backend") is dummy_backend
+    )
+
+
+def test_backend_can_be_set_in_plot_call(monkeypatch, restore_backend, dummy_backend):
+    monkeypatch.setitem(sys.modules, "pandas_dummy_backend", dummy_backend)
+    df = pandas.DataFrame([1, 2, 3])
+
+    assert pandas.get_option("plotting.backend") == "matplotlib"
+    assert df.plot(backend="pandas_dummy_backend") == "used_dummy"
+
+
+def test_register_entrypoint(restore_backend, tmp_path, monkeypatch, dummy_backend):
+    monkeypatch.syspath_prepend(tmp_path)
+    monkeypatch.setitem(sys.modules, "pandas_dummy_backend", dummy_backend)
+
+    dist_info = tmp_path / "my_backend-0.0.0.dist-info"
+    dist_info.mkdir()
+    # entry_point name should not match module name - otherwise pandas will
+    # fall back to backend lookup by module name
+    (dist_info / "entry_points.txt").write_bytes(
+        b"[pandas_plotting_backends]\nmy_ep_backend = pandas_dummy_backend\n"
+    )
+
+    assert pandas.plotting._core._get_plot_backend("my_ep_backend") is dummy_backend
+
+    with pandas.option_context("plotting.backend", "my_ep_backend"):
+        assert pandas.plotting._core._get_plot_backend() is dummy_backend
+
+
+def test_setting_backend_without_plot_raises(monkeypatch):
+    # GH-28163
+    module = types.ModuleType("pandas_plot_backend")
+    monkeypatch.setitem(sys.modules, "pandas_plot_backend", module)
+
+    assert pandas.options.plotting.backend == "matplotlib"
+    with pytest.raises(
+        ValueError, match="Could not find plotting backend 'pandas_plot_backend'."
+    ):
+        pandas.set_option("plotting.backend", "pandas_plot_backend")
+
+    assert pandas.options.plotting.backend == "matplotlib"
+
+
+@td.skip_if_installed("matplotlib")
+def test_no_matplotlib_ok():
+    msg = (
+        'matplotlib is required for plotting when the default backend "matplotlib" is '
+        "selected."
+    )
+    with pytest.raises(ImportError, match=msg):
+        pandas.plotting._core._get_plot_backend("matplotlib")
+
+
+def test_extra_kinds_ok(monkeypatch, restore_backend, dummy_backend):
+    # https://github.com/pandas-dev/pandas/pull/28647
+    monkeypatch.setitem(sys.modules, "pandas_dummy_backend", dummy_backend)
+    pandas.set_option("plotting.backend", "pandas_dummy_backend")
+    df = pandas.DataFrame({"A": [1, 2, 3]})
+    df.plot(kind="not a real kind")

env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/test_boxplot_method.py

@@ -0,0 +1,761 @@
+""" Test cases for .boxplot method """
+
+import itertools
+import string
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    Series,
+    date_range,
+    plotting,
+    timedelta_range,
+)
+import pandas._testing as tm
+from pandas.tests.plotting.common import (
+    _check_axes_shape,
+    _check_box_return_type,
+    _check_plot_works,
+    _check_ticks_props,
+    _check_visible,
+)
+
+from pandas.io.formats.printing import pprint_thing
+
+mpl = pytest.importorskip("matplotlib")
+plt = pytest.importorskip("matplotlib.pyplot")
+
+
+def _check_ax_limits(col, ax):
+    y_min, y_max = ax.get_ylim()
+    assert y_min <= col.min()
+    assert y_max >= col.max()
+
+
+class TestDataFramePlots:
+    def test_stacked_boxplot_set_axis(self):
+        # GH2980
+        import matplotlib.pyplot as plt
+
+        n = 80
+        df = DataFrame(
+            {
+                "Clinical": np.random.default_rng(2).choice([0, 1, 2, 3], n),
+                "Confirmed": np.random.default_rng(2).choice([0, 1, 2, 3], n),
+                "Discarded": np.random.default_rng(2).choice([0, 1, 2, 3], n),
+            },
+            index=np.arange(0, n),
+        )
+        ax = df.plot(kind="bar", stacked=True)
+        assert [int(x.get_text()) for x in ax.get_xticklabels()] == df.index.to_list()
+        ax.set_xticks(np.arange(0, 80, 10))
+        plt.draw()  # Update changes
+        assert [int(x.get_text()) for x in ax.get_xticklabels()] == list(
+            np.arange(0, 80, 10)
+        )
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "kwargs, warn",
+        [
+            [{"return_type": "dict"}, None],
+            [{"column": ["one", "two"]}, None],
+            [{"column": ["one", "two"], "by": "indic"}, UserWarning],
+            [{"column": ["one"], "by": ["indic", "indic2"]}, None],
+            [{"by": "indic"}, UserWarning],
+            [{"by": ["indic", "indic2"]}, UserWarning],
+            [{"notch": 1}, None],
+            [{"by": "indic", "notch": 1}, UserWarning],
+        ],
+    )
+    def test_boxplot_legacy1(self, kwargs, warn):
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((6, 4)),
+            index=list(string.ascii_letters[:6]),
+            columns=["one", "two", "three", "four"],
+        )
+        df["indic"] = ["foo", "bar"] * 3
+        df["indic2"] = ["foo", "bar", "foo"] * 2
+
+        # _check_plot_works can add an ax so catch warning. see GH #13188
+        with tm.assert_produces_warning(warn, check_stacklevel=False):
+            _check_plot_works(df.boxplot, **kwargs)
+
+    def test_boxplot_legacy1_series(self):
+        ser = Series(np.random.default_rng(2).standard_normal(6))
+        _check_plot_works(plotting._core.boxplot, data=ser, return_type="dict")
+
+    def test_boxplot_legacy2(self):
+        df = DataFrame(
+            np.random.default_rng(2).random((10, 2)), columns=["Col1", "Col2"]
+        )
+        df["X"] = Series(["A", "A", "A", "A", "A", "B", "B", "B", "B", "B"])
+        df["Y"] = Series(["A"] * 10)
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
+            _check_plot_works(df.boxplot, by="X")
+
+    def test_boxplot_legacy2_with_ax(self):
+        df = DataFrame(
+            np.random.default_rng(2).random((10, 2)), columns=["Col1", "Col2"]
+        )
+        df["X"] = Series(["A", "A", "A", "A", "A", "B", "B", "B", "B", "B"])
+        df["Y"] = Series(["A"] * 10)
+        # When ax is supplied and required number of axes is 1,
+        # passed ax should be used:
+        _, ax = mpl.pyplot.subplots()
+        axes = df.boxplot("Col1", by="X", ax=ax)
+        ax_axes = ax.axes
+        assert ax_axes is axes
+
+    def test_boxplot_legacy2_with_ax_return_type(self):
+        df = DataFrame(
+            np.random.default_rng(2).random((10, 2)), columns=["Col1", "Col2"]
+        )
+        df["X"] = Series(["A", "A", "A", "A", "A", "B", "B", "B", "B", "B"])
+        df["Y"] = Series(["A"] * 10)
+        fig, ax = mpl.pyplot.subplots()
+        axes = df.groupby("Y").boxplot(ax=ax, return_type="axes")
+        ax_axes = ax.axes
+        assert ax_axes is axes["A"]
+
+    def test_boxplot_legacy2_with_multi_col(self):
+        df = DataFrame(
+            np.random.default_rng(2).random((10, 2)), columns=["Col1", "Col2"]
+        )
+        df["X"] = Series(["A", "A", "A", "A", "A", "B", "B", "B", "B", "B"])
+        df["Y"] = Series(["A"] * 10)
+        # Multiple columns with an ax argument should use same figure
+        fig, ax = mpl.pyplot.subplots()
+        with tm.assert_produces_warning(UserWarning):
+            axes = df.boxplot(
+                column=["Col1", "Col2"], by="X", ax=ax, return_type="axes"
+            )
+        assert axes["Col1"].get_figure() is fig
+
+    def test_boxplot_legacy2_by_none(self):
+        df = DataFrame(
+            np.random.default_rng(2).random((10, 2)), columns=["Col1", "Col2"]
+        )
+        df["X"] = Series(["A", "A", "A", "A", "A", "B", "B", "B", "B", "B"])
+        df["Y"] = Series(["A"] * 10)
+        # When by is None, check that all relevant lines are present in the
+        # dict
+        _, ax = mpl.pyplot.subplots()
+        d = df.boxplot(ax=ax, return_type="dict")
+        lines = list(itertools.chain.from_iterable(d.values()))
+        assert len(ax.get_lines()) == len(lines)
+
+    def test_boxplot_return_type_none(self, hist_df):
+        # GH 12216; return_type=None & by=None -> axes
+        result = hist_df.boxplot()
+        assert isinstance(result, mpl.pyplot.Axes)
+
+    def test_boxplot_return_type_legacy(self):
+        # API change in https://github.com/pandas-dev/pandas/pull/7096
+
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((6, 4)),
+            index=list(string.ascii_letters[:6]),
+            columns=["one", "two", "three", "four"],
+        )
+        msg = "return_type must be {'axes', 'dict', 'both'}"
+        with pytest.raises(ValueError, match=msg):
+            df.boxplot(return_type="NOT_A_TYPE")
+
+        result = df.boxplot()
+        _check_box_return_type(result, "axes")
+
+    @pytest.mark.parametrize("return_type", ["dict", "axes", "both"])
+    def test_boxplot_return_type_legacy_return_type(self, return_type):
+        # API change in https://github.com/pandas-dev/pandas/pull/7096
+
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((6, 4)),
+            index=list(string.ascii_letters[:6]),
+            columns=["one", "two", "three", "four"],
+        )
+        with tm.assert_produces_warning(False):
+            result = df.boxplot(return_type=return_type)
+        _check_box_return_type(result, return_type)
+
+    def test_boxplot_axis_limits(self, hist_df):
+        df = hist_df.copy()
+        df["age"] = np.random.default_rng(2).integers(1, 20, df.shape[0])
+        # One full row
+        height_ax, weight_ax = df.boxplot(["height", "weight"], by="category")
+        _check_ax_limits(df["height"], height_ax)
+        _check_ax_limits(df["weight"], weight_ax)
+        assert weight_ax._sharey == height_ax
+
+    def test_boxplot_axis_limits_two_rows(self, hist_df):
+        df = hist_df.copy()
+        df["age"] = np.random.default_rng(2).integers(1, 20, df.shape[0])
+        # Two rows, one partial
+        p = df.boxplot(["height", "weight", "age"], by="category")
+        height_ax, weight_ax, age_ax = p[0, 0], p[0, 1], p[1, 0]
+        dummy_ax = p[1, 1]
+
+        _check_ax_limits(df["height"], height_ax)
+        _check_ax_limits(df["weight"], weight_ax)
+        _check_ax_limits(df["age"], age_ax)
+        assert weight_ax._sharey == height_ax
+        assert age_ax._sharey == height_ax
+        assert dummy_ax._sharey is None
+
+    def test_boxplot_empty_column(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((20, 4)))
+        df.loc[:, 0] = np.nan
+        _check_plot_works(df.boxplot, return_type="axes")
+
+    def test_figsize(self):
+        df = DataFrame(
+            np.random.default_rng(2).random((10, 5)), columns=["A", "B", "C", "D", "E"]
+        )
+        result = df.boxplot(return_type="axes", figsize=(12, 8))
+        assert result.figure.bbox_inches.width == 12
+        assert result.figure.bbox_inches.height == 8
+
+    def test_fontsize(self):
+        df = DataFrame({"a": [1, 2, 3, 4, 5, 6]})
+        _check_ticks_props(df.boxplot("a", fontsize=16), xlabelsize=16, ylabelsize=16)
+
+    def test_boxplot_numeric_data(self):
+        # GH 22799
+        df = DataFrame(
+            {
+                "a": date_range("2012-01-01", periods=100),
+                "b": np.random.default_rng(2).standard_normal(100),
+                "c": np.random.default_rng(2).standard_normal(100) + 2,
+                "d": date_range("2012-01-01", periods=100).astype(str),
+                "e": date_range("2012-01-01", periods=100, tz="UTC"),
+                "f": timedelta_range("1 days", periods=100),
+            }
+        )
+        ax = df.plot(kind="box")
+        assert [x.get_text() for x in ax.get_xticklabels()] == ["b", "c"]
+
+    @pytest.mark.parametrize(
+        "colors_kwd, expected",
+        [
+            (
+                {"boxes": "r", "whiskers": "b", "medians": "g", "caps": "c"},
+                {"boxes": "r", "whiskers": "b", "medians": "g", "caps": "c"},
+            ),
+            ({"boxes": "r"}, {"boxes": "r"}),
+            ("r", {"boxes": "r", "whiskers": "r", "medians": "r", "caps": "r"}),
+        ],
+    )
+    def test_color_kwd(self, colors_kwd, expected):
+        # GH: 26214
+        df = DataFrame(np.random.default_rng(2).random((10, 2)))
+        result = df.boxplot(color=colors_kwd, return_type="dict")
+        for k, v in expected.items():
+            assert result[k][0].get_color() == v
+
+    @pytest.mark.parametrize(
+        "scheme,expected",
+        [
+            (
+                "dark_background",
+                {
+                    "boxes": "#8dd3c7",
+                    "whiskers": "#8dd3c7",
+                    "medians": "#bfbbd9",
+                    "caps": "#8dd3c7",
+                },
+            ),
+            (
+                "default",
+                {
+                    "boxes": "#1f77b4",
+                    "whiskers": "#1f77b4",
+                    "medians": "#2ca02c",
+                    "caps": "#1f77b4",
+                },
+            ),
+        ],
+    )
+    def test_colors_in_theme(self, scheme, expected):
+        # GH: 40769
+        df = DataFrame(np.random.default_rng(2).random((10, 2)))
+        import matplotlib.pyplot as plt
+
+        plt.style.use(scheme)
+        result = df.plot.box(return_type="dict")
+        for k, v in expected.items():
+            assert result[k][0].get_color() == v
+
+    @pytest.mark.parametrize(
+        "dict_colors, msg",
+        [({"boxes": "r", "invalid_key": "r"}, "invalid key 'invalid_key'")],
+    )
+    def test_color_kwd_errors(self, dict_colors, msg):
+        # GH: 26214
+        df = DataFrame(np.random.default_rng(2).random((10, 2)))
+        with pytest.raises(ValueError, match=msg):
+            df.boxplot(color=dict_colors, return_type="dict")
+
+    @pytest.mark.parametrize(
+        "props, expected",
+        [
+            ("boxprops", "boxes"),
+            ("whiskerprops", "whiskers"),
+            ("capprops", "caps"),
+            ("medianprops", "medians"),
+        ],
+    )
+    def test_specified_props_kwd(self, props, expected):
+        # GH 30346
+        df = DataFrame({k: np.random.default_rng(2).random(10) for k in "ABC"})
+        kwd = {props: {"color": "C1"}}
+        result = df.boxplot(return_type="dict", **kwd)
+
+        assert result[expected][0].get_color() == "C1"
+
+    @pytest.mark.parametrize("vert", [True, False])
+    def test_plot_xlabel_ylabel(self, vert):
+        df = DataFrame(
+            {
+                "a": np.random.default_rng(2).standard_normal(10),
+                "b": np.random.default_rng(2).standard_normal(10),
+                "group": np.random.default_rng(2).choice(["group1", "group2"], 10),
+            }
+        )
+        xlabel, ylabel = "x", "y"
+        ax = df.plot(kind="box", vert=vert, xlabel=xlabel, ylabel=ylabel)
+        assert ax.get_xlabel() == xlabel
+        assert ax.get_ylabel() == ylabel
+
+    @pytest.mark.parametrize("vert", [True, False])
+    def test_plot_box(self, vert):
+        # GH 54941
+        rng = np.random.default_rng(2)
+        df1 = DataFrame(rng.integers(0, 100, size=(100, 4)), columns=list("ABCD"))
+        df2 = DataFrame(rng.integers(0, 100, size=(100, 4)), columns=list("ABCD"))
+
+        xlabel, ylabel = "x", "y"
+        _, axs = plt.subplots(ncols=2, figsize=(10, 7), sharey=True)
+        df1.plot.box(ax=axs[0], vert=vert, xlabel=xlabel, ylabel=ylabel)
+        df2.plot.box(ax=axs[1], vert=vert, xlabel=xlabel, ylabel=ylabel)
+        for ax in axs:
+            assert ax.get_xlabel() == xlabel
+            assert ax.get_ylabel() == ylabel
+        mpl.pyplot.close()
+
+    @pytest.mark.parametrize("vert", [True, False])
+    def test_boxplot_xlabel_ylabel(self, vert):
+        df = DataFrame(
+            {
+                "a": np.random.default_rng(2).standard_normal(10),
+                "b": np.random.default_rng(2).standard_normal(10),
+                "group": np.random.default_rng(2).choice(["group1", "group2"], 10),
+            }
+        )
+        xlabel, ylabel = "x", "y"
+        ax = df.boxplot(vert=vert, xlabel=xlabel, ylabel=ylabel)
+        assert ax.get_xlabel() == xlabel
+        assert ax.get_ylabel() == ylabel
+
+    @pytest.mark.parametrize("vert", [True, False])
+    def test_boxplot_group_xlabel_ylabel(self, vert):
+        df = DataFrame(
+            {
+                "a": np.random.default_rng(2).standard_normal(10),
+                "b": np.random.default_rng(2).standard_normal(10),
+                "group": np.random.default_rng(2).choice(["group1", "group2"], 10),
+            }
+        )
+        xlabel, ylabel = "x", "y"
+        ax = df.boxplot(by="group", vert=vert, xlabel=xlabel, ylabel=ylabel)
+        for subplot in ax:
+            assert subplot.get_xlabel() == xlabel
+            assert subplot.get_ylabel() == ylabel
+        mpl.pyplot.close()
+
+    @pytest.mark.parametrize("vert", [True, False])
+    def test_boxplot_group_no_xlabel_ylabel(self, vert):
+        df = DataFrame(
+            {
+                "a": np.random.default_rng(2).standard_normal(10),
+                "b": np.random.default_rng(2).standard_normal(10),
+                "group": np.random.default_rng(2).choice(["group1", "group2"], 10),
+            }
+        )
+        ax = df.boxplot(by="group", vert=vert)
+        for subplot in ax:
+            target_label = subplot.get_xlabel() if vert else subplot.get_ylabel()
+            assert target_label == pprint_thing(["group"])
+        mpl.pyplot.close()
+
+
+class TestDataFrameGroupByPlots:
+    def test_boxplot_legacy1(self, hist_df):
+        grouped = hist_df.groupby(by="gender")
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
+            axes = _check_plot_works(grouped.boxplot, return_type="axes")
+        _check_axes_shape(list(axes.values), axes_num=2, layout=(1, 2))
+
+    def test_boxplot_legacy1_return_type(self, hist_df):
+        grouped = hist_df.groupby(by="gender")
+        axes = _check_plot_works(grouped.boxplot, subplots=False, return_type="axes")
+        _check_axes_shape(axes, axes_num=1, layout=(1, 1))
+
+    @pytest.mark.slow
+    def test_boxplot_legacy2(self):
+        tuples = zip(string.ascii_letters[:10], range(10))
+        df = DataFrame(
+            np.random.default_rng(2).random((10, 3)),
+            index=MultiIndex.from_tuples(tuples),
+        )
+        grouped = df.groupby(level=1)
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
+            axes = _check_plot_works(grouped.boxplot, return_type="axes")
+        _check_axes_shape(list(axes.values), axes_num=10, layout=(4, 3))
+
+    @pytest.mark.slow
+    def test_boxplot_legacy2_return_type(self):
+        tuples = zip(string.ascii_letters[:10], range(10))
+        df = DataFrame(
+            np.random.default_rng(2).random((10, 3)),
+            index=MultiIndex.from_tuples(tuples),
+        )
+        grouped = df.groupby(level=1)
+        axes = _check_plot_works(grouped.boxplot, subplots=False, return_type="axes")
+        _check_axes_shape(axes, axes_num=1, layout=(1, 1))
+
+    @pytest.mark.parametrize(
+        "subplots, warn, axes_num, layout",
+        [[True, UserWarning, 3, (2, 2)], [False, None, 1, (1, 1)]],
+    )
+    def test_boxplot_legacy3(self, subplots, warn, axes_num, layout):
+        tuples = zip(string.ascii_letters[:10], range(10))
+        df = DataFrame(
+            np.random.default_rng(2).random((10, 3)),
+            index=MultiIndex.from_tuples(tuples),
+        )
+        msg = "DataFrame.groupby with axis=1 is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            grouped = df.unstack(level=1).groupby(level=0, axis=1)
+        with tm.assert_produces_warning(warn, check_stacklevel=False):
+            axes = _check_plot_works(
+                grouped.boxplot, subplots=subplots, return_type="axes"
+            )
+        _check_axes_shape(axes, axes_num=axes_num, layout=layout)
+
+    def test_grouped_plot_fignums(self):
+        n = 10
+        weight = Series(np.random.default_rng(2).normal(166, 20, size=n))
+        height = Series(np.random.default_rng(2).normal(60, 10, size=n))
+        gender = np.random.default_rng(2).choice(["male", "female"], size=n)
+        df = DataFrame({"height": height, "weight": weight, "gender": gender})
+        gb = df.groupby("gender")
+
+        res = gb.plot()
+        assert len(mpl.pyplot.get_fignums()) == 2
+        assert len(res) == 2
+        plt.close("all")
+
+        res = gb.boxplot(return_type="axes")
+        assert len(mpl.pyplot.get_fignums()) == 1
+        assert len(res) == 2
+
+    def test_grouped_plot_fignums_excluded_col(self):
+        n = 10
+        weight = Series(np.random.default_rng(2).normal(166, 20, size=n))
+        height = Series(np.random.default_rng(2).normal(60, 10, size=n))
+        gender = np.random.default_rng(2).choice(["male", "female"], size=n)
+        df = DataFrame({"height": height, "weight": weight, "gender": gender})
+        # now works with GH 5610 as gender is excluded
+        df.groupby("gender").hist()
+
+    @pytest.mark.slow
+    def test_grouped_box_return_type(self, hist_df):
+        df = hist_df
+
+        # old style: return_type=None
+        result = df.boxplot(by="gender")
+        assert isinstance(result, np.ndarray)
+        _check_box_return_type(
+            result, None, expected_keys=["height", "weight", "category"]
+        )
+
+    @pytest.mark.slow
+    def test_grouped_box_return_type_groupby(self, hist_df):
+        df = hist_df
+        # now for groupby
+        result = df.groupby("gender").boxplot(return_type="dict")
+        _check_box_return_type(result, "dict", expected_keys=["Male", "Female"])
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("return_type", ["dict", "axes", "both"])
+    def test_grouped_box_return_type_arg(self, hist_df, return_type):
+        df = hist_df
+
+        returned = df.groupby("classroom").boxplot(return_type=return_type)
+        _check_box_return_type(returned, return_type, expected_keys=["A", "B", "C"])
+
+        returned = df.boxplot(by="classroom", return_type=return_type)
+        _check_box_return_type(
+            returned, return_type, expected_keys=["height", "weight", "category"]
+        )
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("return_type", ["dict", "axes", "both"])
+    def test_grouped_box_return_type_arg_duplcate_cats(self, return_type):
+        columns2 = "X B C D A".split()
+        df2 = DataFrame(
+            np.random.default_rng(2).standard_normal((6, 5)), columns=columns2
+        )
+        categories2 = "A B".split()
+        df2["category"] = categories2 * 3
+
+        returned = df2.groupby("category").boxplot(return_type=return_type)
+        _check_box_return_type(returned, return_type, expected_keys=categories2)
+
+        returned = df2.boxplot(by="category", return_type=return_type)
+        _check_box_return_type(returned, return_type, expected_keys=columns2)
+
+    @pytest.mark.slow
+    def test_grouped_box_layout_too_small(self, hist_df):
+        df = hist_df
+
+        msg = "Layout of 1x1 must be larger than required size 2"
+        with pytest.raises(ValueError, match=msg):
+            df.boxplot(column=["weight", "height"], by=df.gender, layout=(1, 1))
+
+    @pytest.mark.slow
+    def test_grouped_box_layout_needs_by(self, hist_df):
+        df = hist_df
+        msg = "The 'layout' keyword is not supported when 'by' is None"
+        with pytest.raises(ValueError, match=msg):
+            df.boxplot(
+                column=["height", "weight", "category"],
+                layout=(2, 1),
+                return_type="dict",
+            )
+
+    @pytest.mark.slow
+    def test_grouped_box_layout_positive_layout(self, hist_df):
+        df = hist_df
+        msg = "At least one dimension of layout must be positive"
+        with pytest.raises(ValueError, match=msg):
+            df.boxplot(column=["weight", "height"], by=df.gender, layout=(-1, -1))
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "gb_key, axes_num, rows",
+        [["gender", 2, 1], ["category", 4, 2], ["classroom", 3, 2]],
+    )
+    def test_grouped_box_layout_positive_layout_axes(
+        self, hist_df, gb_key, axes_num, rows
+    ):
+        df = hist_df
+        # _check_plot_works adds an ax so catch warning. see GH #13188 GH 6769
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
+            _check_plot_works(
+                df.groupby(gb_key).boxplot, column="height", return_type="dict"
+            )
+        _check_axes_shape(mpl.pyplot.gcf().axes, axes_num=axes_num, layout=(rows, 2))
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "col, visible", [["height", False], ["weight", True], ["category", True]]
+    )
+    def test_grouped_box_layout_visible(self, hist_df, col, visible):
+        df = hist_df
+        # GH 5897
+        axes = df.boxplot(
+            column=["height", "weight", "category"], by="gender", return_type="axes"
+        )
+        _check_axes_shape(mpl.pyplot.gcf().axes, axes_num=3, layout=(2, 2))
+        ax = axes[col]
+        _check_visible(ax.get_xticklabels(), visible=visible)
+        _check_visible([ax.xaxis.get_label()], visible=visible)
+
+    @pytest.mark.slow
+    def test_grouped_box_layout_shape(self, hist_df):
+        df = hist_df
+        df.groupby("classroom").boxplot(
+            column=["height", "weight", "category"], return_type="dict"
+        )
+        _check_axes_shape(mpl.pyplot.gcf().axes, axes_num=3, layout=(2, 2))
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("cols", [2, -1])
+    def test_grouped_box_layout_works(self, hist_df, cols):
+        df = hist_df
+        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
+            _check_plot_works(
+                df.groupby("category").boxplot,
+                column="height",
+                layout=(3, cols),
+                return_type="dict",
+            )
+        _check_axes_shape(mpl.pyplot.gcf().axes, axes_num=4, layout=(3, 2))
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("rows, res", [[4, 4], [-1, 3]])
+    def test_grouped_box_layout_axes_shape_rows(self, hist_df, rows, res):
+        df = hist_df
+        df.boxplot(
+            column=["height", "weight", "category"], by="gender", layout=(rows, 1)
+        )
+        _check_axes_shape(mpl.pyplot.gcf().axes, axes_num=3, layout=(res, 1))
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("cols, res", [[4, 4], [-1, 3]])
+    def test_grouped_box_layout_axes_shape_cols_groupby(self, hist_df, cols, res):
+        df = hist_df
+        df.groupby("classroom").boxplot(
+            column=["height", "weight", "category"],
+            layout=(1, cols),
+            return_type="dict",
+        )
+        _check_axes_shape(mpl.pyplot.gcf().axes, axes_num=3, layout=(1, res))
+
+    @pytest.mark.slow
+    def test_grouped_box_multiple_axes(self, hist_df):
+        # GH 6970, GH 7069
+        df = hist_df
+
+        # check warning to ignore sharex / sharey
+        # this check should be done in the first function which
+        # passes multiple axes to plot, hist or boxplot
+        # location should be changed if other test is added
+        # which has earlier alphabetical order
+        with tm.assert_produces_warning(UserWarning):
+            _, axes = mpl.pyplot.subplots(2, 2)
+            df.groupby("category").boxplot(column="height", return_type="axes", ax=axes)
+            _check_axes_shape(mpl.pyplot.gcf().axes, axes_num=4, layout=(2, 2))
+
+    @pytest.mark.slow
+    def test_grouped_box_multiple_axes_on_fig(self, hist_df):
+        # GH 6970, GH 7069
+        df = hist_df
+        fig, axes = mpl.pyplot.subplots(2, 3)
+        with tm.assert_produces_warning(UserWarning):
+            returned = df.boxplot(
+                column=["height", "weight", "category"],
+                by="gender",
+                return_type="axes",
+                ax=axes[0],
+            )
+        returned = np.array(list(returned.values))
+        _check_axes_shape(returned, axes_num=3, layout=(1, 3))
+        tm.assert_numpy_array_equal(returned, axes[0])
+        assert returned[0].figure is fig
+
+        # draw on second row
+        with tm.assert_produces_warning(UserWarning):
+            returned = df.groupby("classroom").boxplot(
+                column=["height", "weight", "category"], return_type="axes", ax=axes[1]
+            )
+        returned = np.array(list(returned.values))
+        _check_axes_shape(returned, axes_num=3, layout=(1, 3))
+        tm.assert_numpy_array_equal(returned, axes[1])
+        assert returned[0].figure is fig
+
+    @pytest.mark.slow
+    def test_grouped_box_multiple_axes_ax_error(self, hist_df):
+        # GH 6970, GH 7069
+        df = hist_df
+        msg = "The number of passed axes must be 3, the same as the output plot"
+        with pytest.raises(ValueError, match=msg):
+            fig, axes = mpl.pyplot.subplots(2, 3)
+            # pass different number of axes from required
+            with tm.assert_produces_warning(UserWarning):
+                axes = df.groupby("classroom").boxplot(ax=axes)
+
+    def test_fontsize(self):
+        df = DataFrame({"a": [1, 2, 3, 4, 5, 6], "b": [0, 0, 0, 1, 1, 1]})
+        _check_ticks_props(
+            df.boxplot("a", by="b", fontsize=16), xlabelsize=16, ylabelsize=16
+        )
+
+    @pytest.mark.parametrize(
+        "col, expected_xticklabel",
+        [
+            ("v", ["(a, v)", "(b, v)", "(c, v)", "(d, v)", "(e, v)"]),
+            (["v"], ["(a, v)", "(b, v)", "(c, v)", "(d, v)", "(e, v)"]),
+            ("v1", ["(a, v1)", "(b, v1)", "(c, v1)", "(d, v1)", "(e, v1)"]),
+            (
+                ["v", "v1"],
+                [
+                    "(a, v)",
+                    "(a, v1)",
+                    "(b, v)",
+                    "(b, v1)",
+                    "(c, v)",
+                    "(c, v1)",
+                    "(d, v)",
+                    "(d, v1)",
+                    "(e, v)",
+                    "(e, v1)",
+                ],
+            ),
+            (
+                None,
+                [
+                    "(a, v)",
+                    "(a, v1)",
+                    "(b, v)",
+                    "(b, v1)",
+                    "(c, v)",
+                    "(c, v1)",
+                    "(d, v)",
+                    "(d, v1)",
+                    "(e, v)",
+                    "(e, v1)",
+                ],
+            ),
+        ],
+    )
+    def test_groupby_boxplot_subplots_false(self, col, expected_xticklabel):
+        # GH 16748
+        df = DataFrame(
+            {
+                "cat": np.random.default_rng(2).choice(list("abcde"), 100),
+                "v": np.random.default_rng(2).random(100),
+                "v1": np.random.default_rng(2).random(100),
+            }
+        )
+        grouped = df.groupby("cat")
+
+        axes = _check_plot_works(
+            grouped.boxplot, subplots=False, column=col, return_type="axes"
+        )
+
+        result_xticklabel = [x.get_text() for x in axes.get_xticklabels()]
+        assert expected_xticklabel == result_xticklabel
+
+    def test_groupby_boxplot_object(self, hist_df):
+        # GH 43480
+        df = hist_df.astype("object")
+        grouped = df.groupby("gender")
+        msg = "boxplot method requires numerical columns, nothing to plot"
+        with pytest.raises(ValueError, match=msg):
+            _check_plot_works(grouped.boxplot, subplots=False)
+
+    def test_boxplot_multiindex_column(self):
+        # GH 16748
+        arrays = [
+            ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
+            ["one", "two", "one", "two", "one", "two", "one", "two"],
+        ]
+        tuples = list(zip(*arrays))
+        index = MultiIndex.from_tuples(tuples, names=["first", "second"])
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 8)),
+            index=["A", "B", "C"],
+            columns=index,
+        )
+
+        col = [("bar", "one"), ("bar", "two")]
+        axes = _check_plot_works(df.boxplot, column=col, return_type="axes")
+
+        expected_xticklabel = ["(bar, one)", "(bar, two)"]
+        result_xticklabel = [x.get_text() for x in axes.get_xticklabels()]
+        assert expected_xticklabel == result_xticklabel

env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/test_common.py

@@ -0,0 +1,60 @@
+import pytest
+
+from pandas import DataFrame
+from pandas.tests.plotting.common import (
+    _check_plot_works,
+    _check_ticks_props,
+    _gen_two_subplots,
+)
+
+plt = pytest.importorskip("matplotlib.pyplot")
+
+
+class TestCommon:
+    def test__check_ticks_props(self):
+        # GH 34768
+        df = DataFrame({"b": [0, 1, 0], "a": [1, 2, 3]})
+        ax = _check_plot_works(df.plot, rot=30)
+        ax.yaxis.set_tick_params(rotation=30)
+        msg = "expected 0.00000 but got "
+        with pytest.raises(AssertionError, match=msg):
+            _check_ticks_props(ax, xrot=0)
+        with pytest.raises(AssertionError, match=msg):
+            _check_ticks_props(ax, xlabelsize=0)
+        with pytest.raises(AssertionError, match=msg):
+            _check_ticks_props(ax, yrot=0)
+        with pytest.raises(AssertionError, match=msg):
+            _check_ticks_props(ax, ylabelsize=0)
+
+    def test__gen_two_subplots_with_ax(self):
+        fig = plt.gcf()
+        gen = _gen_two_subplots(f=lambda **kwargs: None, fig=fig, ax="test")
+        # On the first yield, no subplot should be added since ax was passed
+        next(gen)
+        assert fig.get_axes() == []
+        # On the second, the one axis should match fig.subplot(2, 1, 2)
+        next(gen)
+        axes = fig.get_axes()
+        assert len(axes) == 1
+        subplot_geometry = list(axes[0].get_subplotspec().get_geometry()[:-1])
+        subplot_geometry[-1] += 1
+        assert subplot_geometry == [2, 1, 2]
+
+    def test_colorbar_layout(self):
+        fig = plt.figure()
+
+        axes = fig.subplot_mosaic(
+            """
+            AB
+            CC
+            """
+        )
+
+        x = [1, 2, 3]
+        y = [1, 2, 3]
+
+        cs0 = axes["A"].scatter(x, y)
+        axes["B"].scatter(x, y)
+
+        fig.colorbar(cs0, ax=[axes["A"], axes["B"]], location="right")
+        DataFrame(x).plot(ax=axes["C"])

env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/test_converter.py

@@ -0,0 +1,410 @@
+from datetime import (
+    date,
+    datetime,
+)
+import subprocess
+import sys
+
+import numpy as np
+import pytest
+
+import pandas._config.config as cf
+
+from pandas._libs.tslibs import to_offset
+
+from pandas import (
+    Index,
+    Period,
+    PeriodIndex,
+    Series,
+    Timestamp,
+    arrays,
+    date_range,
+)
+import pandas._testing as tm
+
+from pandas.plotting import (
+    deregister_matplotlib_converters,
+    register_matplotlib_converters,
+)
+from pandas.tseries.offsets import (
+    Day,
+    Micro,
+    Milli,
+    Second,
+)
+
+try:
+    from pandas.plotting._matplotlib import converter
+except ImportError:
+    # try / except, rather than skip, to avoid internal refactoring
+    # causing an improper skip
+    pass
+
+pytest.importorskip("matplotlib.pyplot")
+dates = pytest.importorskip("matplotlib.dates")
+
+
+@pytest.mark.single_cpu
+def test_registry_mpl_resets():
+    # Check that Matplotlib converters are properly reset (see issue #27481)
+    code = (
+        "import matplotlib.units as units; "
+        "import matplotlib.dates as mdates; "
+        "n_conv = len(units.registry); "
+        "import pandas as pd; "
+        "pd.plotting.register_matplotlib_converters(); "
+        "pd.plotting.deregister_matplotlib_converters(); "
+        "assert len(units.registry) == n_conv"
+    )
+    call = [sys.executable, "-c", code]
+    subprocess.check_output(call)
+
+
+def test_timtetonum_accepts_unicode():
+    assert converter.time2num("00:01") == converter.time2num("00:01")
+
+
+class TestRegistration:
+    @pytest.mark.single_cpu
+    def test_dont_register_by_default(self):
+        # Run in subprocess to ensure a clean state
+        code = (
+            "import matplotlib.units; "
+            "import pandas as pd; "
+            "units = dict(matplotlib.units.registry); "
+            "assert pd.Timestamp not in units"
+        )
+        call = [sys.executable, "-c", code]
+        assert subprocess.check_call(call) == 0
+
+    def test_registering_no_warning(self):
+        plt = pytest.importorskip("matplotlib.pyplot")
+        s = Series(range(12), index=date_range("2017", periods=12))
+        _, ax = plt.subplots()
+
+        # Set to the "warn" state, in case this isn't the first test run
+        register_matplotlib_converters()
+        ax.plot(s.index, s.values)
+        plt.close()
+
+    def test_pandas_plots_register(self):
+        plt = pytest.importorskip("matplotlib.pyplot")
+        s = Series(range(12), index=date_range("2017", periods=12))
+        # Set to the "warn" state, in case this isn't the first test run
+        with tm.assert_produces_warning(None) as w:
+            s.plot()
+
+        try:
+            assert len(w) == 0
+        finally:
+            plt.close()
+
+    def test_matplotlib_formatters(self):
+        units = pytest.importorskip("matplotlib.units")
+
+        # Can't make any assertion about the start state.
+        # We we check that toggling converters off removes it, and toggling it
+        # on restores it.
+
+        with cf.option_context("plotting.matplotlib.register_converters", True):
+            with cf.option_context("plotting.matplotlib.register_converters", False):
+                assert Timestamp not in units.registry
+            assert Timestamp in units.registry
+
+    def test_option_no_warning(self):
+        pytest.importorskip("matplotlib.pyplot")
+        ctx = cf.option_context("plotting.matplotlib.register_converters", False)
+        plt = pytest.importorskip("matplotlib.pyplot")
+        s = Series(range(12), index=date_range("2017", periods=12))
+        _, ax = plt.subplots()
+
+        # Test without registering first, no warning
+        with ctx:
+            ax.plot(s.index, s.values)
+
+        # Now test with registering
+        register_matplotlib_converters()
+        with ctx:
+            ax.plot(s.index, s.values)
+        plt.close()
+
+    def test_registry_resets(self):
+        units = pytest.importorskip("matplotlib.units")
+        dates = pytest.importorskip("matplotlib.dates")
+
+        # make a copy, to reset to
+        original = dict(units.registry)
+
+        try:
+            # get to a known state
+            units.registry.clear()
+            date_converter = dates.DateConverter()
+            units.registry[datetime] = date_converter
+            units.registry[date] = date_converter
+
+            register_matplotlib_converters()
+            assert units.registry[date] is not date_converter
+            deregister_matplotlib_converters()
+            assert units.registry[date] is date_converter
+
+        finally:
+            # restore original stater
+            units.registry.clear()
+            for k, v in original.items():
+                units.registry[k] = v
+
+
+class TestDateTimeConverter:
+    @pytest.fixture
+    def dtc(self):
+        return converter.DatetimeConverter()
+
+    def test_convert_accepts_unicode(self, dtc):
+        r1 = dtc.convert("2000-01-01 12:22", None, None)
+        r2 = dtc.convert("2000-01-01 12:22", None, None)
+        assert r1 == r2, "DatetimeConverter.convert should accept unicode"
+
+    def test_conversion(self, dtc):
+        rs = dtc.convert(["2012-1-1"], None, None)[0]
+        xp = dates.date2num(datetime(2012, 1, 1))
+        assert rs == xp
+
+        rs = dtc.convert("2012-1-1", None, None)
+        assert rs == xp
+
+        rs = dtc.convert(date(2012, 1, 1), None, None)
+        assert rs == xp
+
+        rs = dtc.convert("2012-1-1", None, None)
+        assert rs == xp
+
+        rs = dtc.convert(Timestamp("2012-1-1"), None, None)
+        assert rs == xp
+
+        # also testing datetime64 dtype (GH8614)
+        rs = dtc.convert("2012-01-01", None, None)
+        assert rs == xp
+
+        rs = dtc.convert("2012-01-01 00:00:00+0000", None, None)
+        assert rs == xp
+
+        rs = dtc.convert(
+            np.array(["2012-01-01 00:00:00+0000", "2012-01-02 00:00:00+0000"]),
+            None,
+            None,
+        )
+        assert rs[0] == xp
+
+        # we have a tz-aware date (constructed to that when we turn to utc it
+        # is the same as our sample)
+        ts = Timestamp("2012-01-01").tz_localize("UTC").tz_convert("US/Eastern")
+        rs = dtc.convert(ts, None, None)
+        assert rs == xp
+
+        rs = dtc.convert(ts.to_pydatetime(), None, None)
+        assert rs == xp
+
+        rs = dtc.convert(Index([ts - Day(1), ts]), None, None)
+        assert rs[1] == xp
+
+        rs = dtc.convert(Index([ts - Day(1), ts]).to_pydatetime(), None, None)
+        assert rs[1] == xp
+
+    def test_conversion_float(self, dtc):
+        rtol = 0.5 * 10**-9
+
+        rs = dtc.convert(Timestamp("2012-1-1 01:02:03", tz="UTC"), None, None)
+        xp = converter.mdates.date2num(Timestamp("2012-1-1 01:02:03", tz="UTC"))
+        tm.assert_almost_equal(rs, xp, rtol=rtol)
+
+        rs = dtc.convert(
+            Timestamp("2012-1-1 09:02:03", tz="Asia/Hong_Kong"), None, None
+        )
+        tm.assert_almost_equal(rs, xp, rtol=rtol)
+
+        rs = dtc.convert(datetime(2012, 1, 1, 1, 2, 3), None, None)
+        tm.assert_almost_equal(rs, xp, rtol=rtol)
+
+    @pytest.mark.parametrize(
+        "values",
+        [
+            [date(1677, 1, 1), date(1677, 1, 2)],
+            [datetime(1677, 1, 1, 12), datetime(1677, 1, 2, 12)],
+        ],
+    )
+    def test_conversion_outofbounds_datetime(self, dtc, values):
+        # 2579
+        rs = dtc.convert(values, None, None)
+        xp = converter.mdates.date2num(values)
+        tm.assert_numpy_array_equal(rs, xp)
+        rs = dtc.convert(values[0], None, None)
+        xp = converter.mdates.date2num(values[0])
+        assert rs == xp
+
+    @pytest.mark.parametrize(
+        "time,format_expected",
+        [
+            (0, "00:00"),  # time2num(datetime.time.min)
+            (86399.999999, "23:59:59.999999"),  # time2num(datetime.time.max)
+            (90000, "01:00"),
+            (3723, "01:02:03"),
+            (39723.2, "11:02:03.200"),
+        ],
+    )
+    def test_time_formatter(self, time, format_expected):
+        # issue 18478
+        result = converter.TimeFormatter(None)(time)
+        assert result == format_expected
+
+    @pytest.mark.parametrize("freq", ("B", "ms", "s"))
+    def test_dateindex_conversion(self, freq, dtc):
+        rtol = 10**-9
+        dateindex = date_range("2020-01-01", periods=10, freq=freq)
+        rs = dtc.convert(dateindex, None, None)
+        xp = converter.mdates.date2num(dateindex._mpl_repr())
+        tm.assert_almost_equal(rs, xp, rtol=rtol)
+
+    @pytest.mark.parametrize("offset", [Second(), Milli(), Micro(50)])
+    def test_resolution(self, offset, dtc):
+        # Matplotlib's time representation using floats cannot distinguish
+        # intervals smaller than ~10 microsecond in the common range of years.
+        ts1 = Timestamp("2012-1-1")
+        ts2 = ts1 + offset
+        val1 = dtc.convert(ts1, None, None)
+        val2 = dtc.convert(ts2, None, None)
+        if not val1 < val2:
+            raise AssertionError(f"{val1} is not less than {val2}.")
+
+    def test_convert_nested(self, dtc):
+        inner = [Timestamp("2017-01-01"), Timestamp("2017-01-02")]
+        data = [inner, inner]
+        result = dtc.convert(data, None, None)
+        expected = [dtc.convert(x, None, None) for x in data]
+        assert (np.array(result) == expected).all()
+
+
+class TestPeriodConverter:
+    @pytest.fixture
+    def pc(self):
+        return converter.PeriodConverter()
+
+    @pytest.fixture
+    def axis(self):
+        class Axis:
+            pass
+
+        axis = Axis()
+        axis.freq = "D"
+        return axis
+
+    def test_convert_accepts_unicode(self, pc, axis):
+        r1 = pc.convert("2012-1-1", None, axis)
+        r2 = pc.convert("2012-1-1", None, axis)
+        assert r1 == r2
+
+    def test_conversion(self, pc, axis):
+        rs = pc.convert(["2012-1-1"], None, axis)[0]
+        xp = Period("2012-1-1").ordinal
+        assert rs == xp
+
+        rs = pc.convert("2012-1-1", None, axis)
+        assert rs == xp
+
+        rs = pc.convert([date(2012, 1, 1)], None, axis)[0]
+        assert rs == xp
+
+        rs = pc.convert(date(2012, 1, 1), None, axis)
+        assert rs == xp
+
+        rs = pc.convert([Timestamp("2012-1-1")], None, axis)[0]
+        assert rs == xp
+
+        rs = pc.convert(Timestamp("2012-1-1"), None, axis)
+        assert rs == xp
+
+        rs = pc.convert("2012-01-01", None, axis)
+        assert rs == xp
+
+        rs = pc.convert("2012-01-01 00:00:00+0000", None, axis)
+        assert rs == xp
+
+        rs = pc.convert(
+            np.array(
+                ["2012-01-01 00:00:00", "2012-01-02 00:00:00"],
+                dtype="datetime64[ns]",
+            ),
+            None,
+            axis,
+        )
+        assert rs[0] == xp
+
+    def test_integer_passthrough(self, pc, axis):
+        # GH9012
+        rs = pc.convert([0, 1], None, axis)
+        xp = [0, 1]
+        assert rs == xp
+
+    def test_convert_nested(self, pc, axis):
+        data = ["2012-1-1", "2012-1-2"]
+        r1 = pc.convert([data, data], None, axis)
+        r2 = [pc.convert(data, None, axis) for _ in range(2)]
+        assert r1 == r2
+
+
+class TestTimeDeltaConverter:
+    """Test timedelta converter"""
+
+    @pytest.mark.parametrize(
+        "x, decimal, format_expected",
+        [
+            (0.0, 0, "00:00:00"),
+            (3972320000000, 1, "01:06:12.3"),
+            (713233432000000, 2, "8 days 06:07:13.43"),
+            (32423432000000, 4, "09:00:23.4320"),
+        ],
+    )
+    def test_format_timedelta_ticks(self, x, decimal, format_expected):
+        tdc = converter.TimeSeries_TimedeltaFormatter
+        result = tdc.format_timedelta_ticks(x, pos=None, n_decimals=decimal)
+        assert result == format_expected
+
+    @pytest.mark.parametrize("view_interval", [(1, 2), (2, 1)])
+    def test_call_w_different_view_intervals(self, view_interval, monkeypatch):
+        # previously broke on reversed xlmits; see GH37454
+        class mock_axis:
+            def get_view_interval(self):
+                return view_interval
+
+        tdc = converter.TimeSeries_TimedeltaFormatter()
+        monkeypatch.setattr(tdc, "axis", mock_axis())
+        tdc(0.0, 0)
+
+
+@pytest.mark.parametrize("year_span", [11.25, 30, 80, 150, 400, 800, 1500, 2500, 3500])
+# The range is limited to 11.25 at the bottom by if statements in
+# the _quarterly_finder() function
+def test_quarterly_finder(year_span):
+    vmin = -1000
+    vmax = vmin + year_span * 4
+    span = vmax - vmin + 1
+    if span < 45:
+        pytest.skip("the quarterly finder is only invoked if the span is >= 45")
+    nyears = span / 4
+    (min_anndef, maj_anndef) = converter._get_default_annual_spacing(nyears)
+    result = converter._quarterly_finder(vmin, vmax, to_offset("QE"))
+    quarters = PeriodIndex(
+        arrays.PeriodArray(np.array([x[0] for x in result]), dtype="period[Q]")
+    )
+    majors = np.array([x[1] for x in result])
+    minors = np.array([x[2] for x in result])
+    major_quarters = quarters[majors]
+    minor_quarters = quarters[minors]
+    check_major_years = major_quarters.year % maj_anndef == 0
+    check_minor_years = minor_quarters.year % min_anndef == 0
+    check_major_quarters = major_quarters.quarter == 1
+    check_minor_quarters = minor_quarters.quarter == 1
+    assert np.all(check_major_years)
+    assert np.all(check_minor_years)
+    assert np.all(check_major_quarters)
+    assert np.all(check_minor_quarters)