Add files using upload-large-folder tool

videochat2/lib/python3.10/site-packages/pandas/tests/api/test_types.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import pandas._testing as tm
+from pandas.api import types
+from pandas.tests.api.test_api import Base
+
+
+class TestTypes(Base):
+    allowed = [
+        "is_any_real_numeric_dtype",
+        "is_bool",
+        "is_bool_dtype",
+        "is_categorical_dtype",
+        "is_complex",
+        "is_complex_dtype",
+        "is_datetime64_any_dtype",
+        "is_datetime64_dtype",
+        "is_datetime64_ns_dtype",
+        "is_datetime64tz_dtype",
+        "is_dtype_equal",
+        "is_float",
+        "is_float_dtype",
+        "is_int64_dtype",
+        "is_integer",
+        "is_integer_dtype",
+        "is_number",
+        "is_numeric_dtype",
+        "is_object_dtype",
+        "is_scalar",
+        "is_sparse",
+        "is_string_dtype",
+        "is_signed_integer_dtype",
+        "is_timedelta64_dtype",
+        "is_timedelta64_ns_dtype",
+        "is_unsigned_integer_dtype",
+        "is_period_dtype",
+        "is_interval",
+        "is_interval_dtype",
+        "is_re",
+        "is_re_compilable",
+        "is_dict_like",
+        "is_iterator",
+        "is_file_like",
+        "is_list_like",
+        "is_hashable",
+        "is_array_like",
+        "is_named_tuple",
+        "pandas_dtype",
+        "union_categoricals",
+        "infer_dtype",
+        "is_extension_array_dtype",
+    ]
+    deprecated: list[str] = []
+    dtypes = ["CategoricalDtype", "DatetimeTZDtype", "PeriodDtype", "IntervalDtype"]
+
+    def test_types(self):
+        self.check(types, self.allowed + self.dtypes + self.deprecated)
+
+    def test_deprecated_from_api_types(self):
+        for t in self.deprecated:
+            with tm.assert_produces_warning(FutureWarning):
+                getattr(types, t)(1)

videochat2/lib/python3.10/site-packages/pandas/tests/base/common.py

@@ -0,0 +1,10 @@
+from typing import Any
+
+from pandas import Index
+from pandas.api.types import is_bool_dtype
+
+
+def allow_na_ops(obj: Any) -> bool:
+    """Whether to skip test cases including NaN"""
+    is_bool_index = isinstance(obj, Index) and is_bool_dtype(obj)
+    return not is_bool_index and obj._can_hold_na

videochat2/lib/python3.10/site-packages/pandas/tests/base/test_fillna.py

@@ -0,0 +1,60 @@
+"""
+Though Index.fillna and Series.fillna has separate impl,
+test here to confirm these works as the same
+"""
+
+import numpy as np
+import pytest
+
+from pandas import MultiIndex
+import pandas._testing as tm
+from pandas.tests.base.common import allow_na_ops
+
+
+def test_fillna(index_or_series_obj):
+    # GH 11343
+    obj = index_or_series_obj
+
+    if isinstance(obj, MultiIndex):
+        msg = "isna is not defined for MultiIndex"
+        with pytest.raises(NotImplementedError, match=msg):
+            obj.fillna(0)
+        return
+
+    # values will not be changed
+    fill_value = obj.values[0] if len(obj) > 0 else 0
+    result = obj.fillna(fill_value)
+
+    tm.assert_equal(obj, result)
+
+    # check shallow_copied
+    assert obj is not result
+
+
+@pytest.mark.parametrize("null_obj", [np.nan, None])
+def test_fillna_null(null_obj, index_or_series_obj):
+    # GH 11343
+    obj = index_or_series_obj
+    klass = type(obj)
+
+    if not allow_na_ops(obj):
+        pytest.skip(f"{klass} doesn't allow for NA operations")
+    elif len(obj) < 1:
+        pytest.skip("Test doesn't make sense on empty data")
+    elif isinstance(obj, MultiIndex):
+        pytest.skip(f"MultiIndex can't hold '{null_obj}'")
+
+    values = obj._values
+    fill_value = values[0]
+    expected = values.copy()
+    values[0:2] = null_obj
+    expected[0:2] = fill_value
+
+    expected = klass(expected)
+    obj = klass(values)
+
+    result = obj.fillna(fill_value)
+    tm.assert_equal(result, expected)
+
+    # check shallow_copied
+    assert obj is not result

videochat2/lib/python3.10/site-packages/pandas/tests/base/test_misc.py

@@ -0,0 +1,187 @@
+import sys
+
+import numpy as np
+import pytest
+
+from pandas.compat import (
+    IS64,
+    PYPY,
+)
+
+from pandas.core.dtypes.common import (
+    is_categorical_dtype,
+    is_dtype_equal,
+    is_object_dtype,
+)
+
+import pandas as pd
+from pandas import (
+    Index,
+    Series,
+)
+import pandas._testing as tm
+
+
+def test_isnull_notnull_docstrings():
+    # GH#41855 make sure its clear these are aliases
+    doc = pd.DataFrame.notnull.__doc__
+    assert doc.startswith("\nDataFrame.notnull is an alias for DataFrame.notna.\n")
+    doc = pd.DataFrame.isnull.__doc__
+    assert doc.startswith("\nDataFrame.isnull is an alias for DataFrame.isna.\n")
+
+    doc = Series.notnull.__doc__
+    assert doc.startswith("\nSeries.notnull is an alias for Series.notna.\n")
+    doc = Series.isnull.__doc__
+    assert doc.startswith("\nSeries.isnull is an alias for Series.isna.\n")
+
+
+@pytest.mark.parametrize(
+    "op_name, op",
+    [
+        ("add", "+"),
+        ("sub", "-"),
+        ("mul", "*"),
+        ("mod", "%"),
+        ("pow", "**"),
+        ("truediv", "/"),
+        ("floordiv", "//"),
+    ],
+)
+def test_binary_ops_docstring(frame_or_series, op_name, op):
+    # not using the all_arithmetic_functions fixture with _get_opstr
+    # as _get_opstr is used internally in the dynamic implementation of the docstring
+    klass = frame_or_series
+
+    operand1 = klass.__name__.lower()
+    operand2 = "other"
+    expected_str = " ".join([operand1, op, operand2])
+    assert expected_str in getattr(klass, op_name).__doc__
+
+    # reverse version of the binary ops
+    expected_str = " ".join([operand2, op, operand1])
+    assert expected_str in getattr(klass, "r" + op_name).__doc__
+
+
+def test_ndarray_compat_properties(index_or_series_obj):
+    obj = index_or_series_obj
+
+    # Check that we work.
+    for p in ["shape", "dtype", "T", "nbytes"]:
+        assert getattr(obj, p, None) is not None
+
+    # deprecated properties
+    for p in ["strides", "itemsize", "base", "data"]:
+        assert not hasattr(obj, p)
+
+    msg = "can only convert an array of size 1 to a Python scalar"
+    with pytest.raises(ValueError, match=msg):
+        obj.item()  # len > 1
+
+    assert obj.ndim == 1
+    assert obj.size == len(obj)
+
+    assert Index([1]).item() == 1
+    assert Series([1]).item() == 1
+
+
+@pytest.mark.skipif(PYPY, reason="not relevant for PyPy")
+def test_memory_usage(index_or_series_obj):
+    obj = index_or_series_obj
+
+    res = obj.memory_usage()
+    res_deep = obj.memory_usage(deep=True)
+
+    is_ser = isinstance(obj, Series)
+    is_object = is_object_dtype(obj) or (
+        isinstance(obj, Series) and is_object_dtype(obj.index)
+    )
+    is_categorical = is_categorical_dtype(obj.dtype) or (
+        isinstance(obj, Series) and is_categorical_dtype(obj.index.dtype)
+    )
+    is_object_string = is_dtype_equal(obj, "string[python]") or (
+        is_ser and is_dtype_equal(obj.index.dtype, "string[python]")
+    )
+
+    if len(obj) == 0:
+        if isinstance(obj, Index):
+            expected = 0
+        else:
+            expected = 108 if IS64 else 64
+        assert res_deep == res == expected
+    elif is_object or is_categorical or is_object_string:
+        # only deep will pick them up
+        assert res_deep > res
+    else:
+        assert res == res_deep
+
+    # sys.getsizeof will call the .memory_usage with
+    # deep=True, and add on some GC overhead
+    diff = res_deep - sys.getsizeof(obj)
+    assert abs(diff) < 100
+
+
+def test_memory_usage_components_series(series_with_simple_index):
+    series = series_with_simple_index
+    total_usage = series.memory_usage(index=True)
+    non_index_usage = series.memory_usage(index=False)
+    index_usage = series.index.memory_usage()
+    assert total_usage == non_index_usage + index_usage
+
+
+@pytest.mark.parametrize("dtype", tm.NARROW_NP_DTYPES)
+def test_memory_usage_components_narrow_series(dtype):
+    series = tm.make_rand_series(name="a", dtype=dtype)
+    total_usage = series.memory_usage(index=True)
+    non_index_usage = series.memory_usage(index=False)
+    index_usage = series.index.memory_usage()
+    assert total_usage == non_index_usage + index_usage
+
+
+def test_searchsorted(request, index_or_series_obj):
+    # numpy.searchsorted calls obj.searchsorted under the hood.
+    # See gh-12238
+    obj = index_or_series_obj
+
+    if isinstance(obj, pd.MultiIndex):
+        # See gh-14833
+        request.node.add_marker(
+            pytest.mark.xfail(
+                reason="np.searchsorted doesn't work on pd.MultiIndex: GH 14833"
+            )
+        )
+    elif obj.dtype.kind == "c" and isinstance(obj, Index):
+        # TODO: Should Series cases also raise? Looks like they use numpy
+        #  comparison semantics https://github.com/numpy/numpy/issues/15981
+        mark = pytest.mark.xfail(reason="complex objects are not comparable")
+        request.node.add_marker(mark)
+
+    max_obj = max(obj, default=0)
+    index = np.searchsorted(obj, max_obj)
+    assert 0 <= index <= len(obj)
+
+    index = np.searchsorted(obj, max_obj, sorter=range(len(obj)))
+    assert 0 <= index <= len(obj)
+
+
+def test_access_by_position(index_flat):
+    index = index_flat
+
+    if len(index) == 0:
+        pytest.skip("Test doesn't make sense on empty data")
+
+    series = Series(index)
+    assert index[0] == series.iloc[0]
+    assert index[5] == series.iloc[5]
+    assert index[-1] == series.iloc[-1]
+
+    size = len(index)
+    assert index[-1] == index[size - 1]
+
+    msg = f"index {size} is out of bounds for axis 0 with size {size}"
+    if is_dtype_equal(index.dtype, "string[pyarrow]"):
+        msg = "index out of bounds"
+    with pytest.raises(IndexError, match=msg):
+        index[size]
+    msg = "single positional indexer is out-of-bounds"
+    with pytest.raises(IndexError, match=msg):
+        series.iloc[size]

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

@@ -0,0 +1,585 @@
+"""
+Module consolidating common testing functions for checking plotting.
+"""
+
+from __future__ import annotations
+
+from typing import (
+    TYPE_CHECKING,
+    Sequence,
+)
+
+import numpy as np
+
+from pandas.util._decorators import cache_readonly
+import pandas.util._test_decorators as td
+
+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 matplotlib.axes import Axes
+
+
+@td.skip_if_no_mpl
+class TestPlotBase:
+    """
+    This is a common base class used for various plotting tests
+    """
+
+    def setup_method(self):
+        import matplotlib as mpl
+
+        mpl.rcdefaults()
+
+    def teardown_method(self):
+        tm.close()
+
+    @cache_readonly
+    def plt(self):
+        import matplotlib.pyplot as plt
+
+        return plt
+
+    @cache_readonly
+    def colorconverter(self):
+        from matplotlib import colors
+
+        return colors.colorConverter
+
+    def _check_legend_labels(self, 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 = self._flatten_visible(axes)
+        for ax in axes:
+            if visible:
+                assert ax.get_legend() is not None
+                self._check_text_labels(ax.get_legend().get_texts(), labels)
+            else:
+                assert ax.get_legend() is None
+
+    def _check_legend_marker(self, 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(self, xp, rs):
+        """
+        Check each axes has identical lines
+
+        Parameters
+        ----------
+        xp : matplotlib Axes object
+        rs : matplotlib Axes object
+        """
+        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)
+
+        tm.close()
+
+    def _check_visible(self, 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(
+        self, 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 = self._flatten_visible(axes)
+        for ax in axes:
+            for patch in ax.patches:
+                assert patch.fill == filled
+
+    def _get_colors_mapped(self, 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(
+        self, 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.collections import (
+            Collection,
+            LineCollection,
+            PolyCollection,
+        )
+        from matplotlib.lines import Line2D
+
+        conv = self.colorconverter
+        if linecolors is not None:
+            if mapping is not None:
+                linecolors = self._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 = self._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(self, 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(
+        self, 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 = self._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(self, 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 = self._flatten_visible(axes)
+        for ax in axes:
+            assert ax.xaxis.get_scale() == xaxis
+            assert ax.yaxis.get_scale() == yaxis
+
+    def _check_axes_shape(self, 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 = self._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:
+            result = self._get_axes_layout(flatten_axes(axes))
+            assert result == layout
+
+        tm.assert_numpy_array_equal(
+            visible_axes[0].figure.get_size_inches(),
+            np.array(figsize, dtype=np.float64),
+        )
+
+    def _get_axes_layout(self, axes):
+        x_set = set()
+        y_set = set()
+        for ax in 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])
+        return (len(y_set), len(x_set))
+
+    def _flatten_visible(self, 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 = flatten_axes(axes)
+        axes = [ax for ax in axes if ax.get_visible()]
+        return axes
+
+    def _check_has_errorbars(self, 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 = self._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(
+        self, 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 self._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(self, obj, kinds, kws={}):
+        # Make sure plot defaults to rcParams['axes.grid'] setting, GH 9792
+
+        import matplotlib as mpl
+
+        def is_grid_on():
+            xticks = self.plt.gca().xaxis.get_major_ticks()
+            yticks = self.plt.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:
+            self.plt.subplot(1, 4 * len(kinds), spndx)
+            spndx += 1
+            mpl.rc("axes", grid=False)
+            obj.plot(kind=kind, **kws)
+            assert not is_grid_on()
+            self.plt.clf()
+
+            self.plt.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()
+            self.plt.clf()
+
+            if kind not in ["pie", "hexbin", "scatter"]:
+                self.plt.subplot(1, 4 * len(kinds), spndx)
+                spndx += 1
+                mpl.rc("axes", grid=True)
+                obj.plot(kind=kind, **kws)
+                assert is_grid_on()
+                self.plt.clf()
+
+                self.plt.subplot(1, 4 * len(kinds), spndx)
+                spndx += 1
+                mpl.rc("axes", grid=False)
+                obj.plot(kind=kind, grid=True, **kws)
+                assert is_grid_on()
+                self.plt.clf()
+
+    def _unpack_cycler(self, 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(self, ax):
+        return ax._shared_axes["x"]
+
+    def get_y_axis(self, 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)
+
+        with tm.ensure_clean(return_filelike=True) as path:
+            plt.savefig(path)
+
+    finally:
+        tm.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)

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

@@ -0,0 +1,34 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    to_datetime,
+)
+
+
+@pytest.fixture
+def hist_df():
+    n = 100
+    np_random = np.random.RandomState(42)
+    gender = np_random.choice(["Male", "Female"], size=n)
+    classroom = np_random.choice(["A", "B", "C"], size=n)
+
+    hist_df = DataFrame(
+        {
+            "gender": gender,
+            "classroom": classroom,
+            "height": np.random.normal(66, 4, size=n),
+            "weight": np.random.normal(161, 32, size=n),
+            "category": np.random.randint(4, size=n),
+            "datetime": to_datetime(
+                np.random.randint(
+                    812419200000000000,
+                    819331200000000000,
+                    size=n,
+                    dtype=np.int64,
+                )
+            ),
+        }
+    )
+    return hist_df

videochat2/lib/python3.10/site-packages/pandas/tests/plotting/frame/test_frame.py

@@ -0,0 +1,2223 @@
+""" Test cases for DataFrame.plot """
+from datetime import (
+    date,
+    datetime,
+)
+import gc
+import itertools
+import re
+import string
+import warnings
+import weakref
+
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas.core.dtypes.api import is_list_like
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    PeriodIndex,
+    Series,
+    bdate_range,
+    date_range,
+    plotting,
+)
+import pandas._testing as tm
+from pandas.tests.plotting.common import (
+    TestPlotBase,
+    _check_plot_works,
+)
+
+from pandas.io.formats.printing import pprint_thing
+
+
+@td.skip_if_no_mpl
+class TestDataFramePlots(TestPlotBase):
+    @pytest.mark.xfail(reason="Api changed in 3.6.0")
+    @pytest.mark.slow
+    def test_plot(self):
+        df = tm.makeTimeDataFrame()
+        _check_plot_works(df.plot, grid=False)
+
+        # _check_plot_works adds an ax so use default_axes=True to avoid warning
+        axes = _check_plot_works(df.plot, default_axes=True, subplots=True)
+        self._check_axes_shape(axes, axes_num=4, layout=(4, 1))
+
+        axes = _check_plot_works(
+            df.plot,
+            default_axes=True,
+            subplots=True,
+            layout=(-1, 2),
+        )
+        self._check_axes_shape(axes, axes_num=4, layout=(2, 2))
+
+        axes = _check_plot_works(
+            df.plot,
+            default_axes=True,
+            subplots=True,
+            use_index=False,
+        )
+        self._check_ticks_props(axes, xrot=0)
+        self._check_axes_shape(axes, axes_num=4, layout=(4, 1))
+
+        df = DataFrame({"x": [1, 2], "y": [3, 4]})
+        msg = "'Line2D' object has no property 'blarg'"
+        with pytest.raises(AttributeError, match=msg):
+            df.plot.line(blarg=True)
+
+        df = DataFrame(np.random.rand(10, 3), index=list(string.ascii_letters[:10]))
+
+        ax = _check_plot_works(df.plot, use_index=True)
+        self._check_ticks_props(ax, xrot=0)
+        _check_plot_works(df.plot, yticks=[1, 5, 10])
+        _check_plot_works(df.plot, xticks=[1, 5, 10])
+        _check_plot_works(df.plot, ylim=(-100, 100), xlim=(-100, 100))
+
+        _check_plot_works(df.plot, default_axes=True, subplots=True, title="blah")
+
+        # We have to redo it here because _check_plot_works does two plots,
+        # once without an ax kwarg and once with an ax kwarg and the new sharex
+        # behaviour does not remove the visibility of the latter axis (as ax is
+        # present).  see: https://github.com/pandas-dev/pandas/issues/9737
+
+        axes = df.plot(subplots=True, title="blah")
+        self._check_axes_shape(axes, axes_num=3, layout=(3, 1))
+        # axes[0].figure.savefig("test.png")
+        for ax in axes[:2]:
+            self._check_visible(ax.xaxis)  # xaxis must be visible for grid
+            self._check_visible(ax.get_xticklabels(), visible=False)
+            self._check_visible(ax.get_xticklabels(minor=True), visible=False)
+            self._check_visible([ax.xaxis.get_label()], visible=False)
+        for ax in [axes[2]]:
+            self._check_visible(ax.xaxis)
+            self._check_visible(ax.get_xticklabels())
+            self._check_visible([ax.xaxis.get_label()])
+            self._check_ticks_props(ax, xrot=0)
+
+        _check_plot_works(df.plot, title="blah")
+
+        tuples = zip(string.ascii_letters[:10], range(10))
+        df = DataFrame(np.random.rand(10, 3), index=MultiIndex.from_tuples(tuples))
+        ax = _check_plot_works(df.plot, use_index=True)
+        self._check_ticks_props(ax, xrot=0)
+
+        # unicode
+        index = MultiIndex.from_tuples(
+            [
+                ("\u03b1", 0),
+                ("\u03b1", 1),
+                ("\u03b2", 2),
+                ("\u03b2", 3),
+                ("\u03b3", 4),
+                ("\u03b3", 5),
+                ("\u03b4", 6),
+                ("\u03b4", 7),
+            ],
+            names=["i0", "i1"],
+        )
+        columns = MultiIndex.from_tuples(
+            [("bar", "\u0394"), ("bar", "\u0395")], names=["c0", "c1"]
+        )
+        df = DataFrame(np.random.randint(0, 10, (8, 2)), columns=columns, index=index)
+        _check_plot_works(df.plot, title="\u03A3")
+
+        # GH 6951
+        # Test with single column
+        df = DataFrame({"x": np.random.rand(10)})
+        axes = _check_plot_works(df.plot.bar, subplots=True)
+        self._check_axes_shape(axes, axes_num=1, layout=(1, 1))
+
+        axes = _check_plot_works(df.plot.bar, subplots=True, layout=(-1, 1))
+        self._check_axes_shape(axes, axes_num=1, layout=(1, 1))
+        # When ax is supplied and required number of axes is 1,
+        # passed ax should be used:
+        fig, ax = self.plt.subplots()
+        axes = df.plot.bar(subplots=True, ax=ax)
+        assert len(axes) == 1
+        result = ax.axes
+        assert result is axes[0]
+
+    def test_nullable_int_plot(self):
+        # GH 32073
+        dates = ["2008", "2009", None, "2011", "2012"]
+        df = DataFrame(
+            {
+                "A": [1, 2, 3, 4, 5],
+                "B": [1, 2, 3, 4, 5],
+                "C": np.array([7, 5, np.nan, 3, 2], dtype=object),
+                "D": pd.to_datetime(dates, format="%Y").view("i8"),
+                "E": pd.to_datetime(dates, format="%Y", utc=True).view("i8"),
+            }
+        )
+
+        _check_plot_works(df.plot, x="A", y="B")
+        _check_plot_works(df[["A", "B"]].plot, x="A", y="B")
+        _check_plot_works(df[["C", "A"]].plot, x="C", y="A")  # nullable value on x-axis
+        _check_plot_works(df[["A", "C"]].plot, x="A", y="C")
+        _check_plot_works(df[["B", "C"]].plot, x="B", y="C")
+        _check_plot_works(df[["A", "D"]].plot, x="A", y="D")
+        _check_plot_works(df[["A", "E"]].plot, x="A", y="E")
+
+    @pytest.mark.slow
+    def test_integer_array_plot(self):
+        # GH 25587
+        arr = pd.array([1, 2, 3, 4], dtype="UInt32")
+
+        s = Series(arr)
+        _check_plot_works(s.plot.line)
+        _check_plot_works(s.plot.bar)
+        _check_plot_works(s.plot.hist)
+        _check_plot_works(s.plot.pie)
+
+        df = DataFrame({"x": arr, "y": arr})
+        _check_plot_works(df.plot.line)
+        _check_plot_works(df.plot.bar)
+        _check_plot_works(df.plot.hist)
+        _check_plot_works(df.plot.pie, y="y")
+        _check_plot_works(df.plot.scatter, x="x", y="y")
+        _check_plot_works(df.plot.hexbin, x="x", y="y")
+
+    def test_nonnumeric_exclude(self):
+        df = DataFrame({"A": ["x", "y", "z"], "B": [1, 2, 3]})
+        ax = df.plot()
+        assert len(ax.get_lines()) == 1  # B was plotted
+
+    def test_implicit_label(self):
+        df = DataFrame(np.random.randn(10, 3), columns=["a", "b", "c"])
+        ax = df.plot(x="a", y="b")
+        self._check_text_labels(ax.xaxis.get_label(), "a")
+
+    def test_donot_overwrite_index_name(self):
+        # GH 8494
+        df = DataFrame(np.random.randn(2, 2), columns=["a", "b"])
+        df.index.name = "NAME"
+        df.plot(y="b", label="LABEL")
+        assert df.index.name == "NAME"
+
+    def test_plot_xy(self):
+        # columns.inferred_type == 'string'
+        df = tm.makeTimeDataFrame()
+        self._check_data(df.plot(x=0, y=1), df.set_index("A")["B"].plot())
+        self._check_data(df.plot(x=0), df.set_index("A").plot())
+        self._check_data(df.plot(y=0), df.B.plot())
+        self._check_data(df.plot(x="A", y="B"), df.set_index("A").B.plot())
+        self._check_data(df.plot(x="A"), df.set_index("A").plot())
+        self._check_data(df.plot(y="B"), df.B.plot())
+
+        # columns.inferred_type == 'integer'
+        df.columns = np.arange(1, len(df.columns) + 1)
+        self._check_data(df.plot(x=1, y=2), df.set_index(1)[2].plot())
+        self._check_data(df.plot(x=1), df.set_index(1).plot())
+        self._check_data(df.plot(y=1), df[1].plot())
+
+        # figsize and title
+        ax = df.plot(x=1, y=2, title="Test", figsize=(16, 8))
+        self._check_text_labels(ax.title, "Test")
+        self._check_axes_shape(ax, axes_num=1, layout=(1, 1), figsize=(16.0, 8.0))
+
+        # columns.inferred_type == 'mixed'
+        # TODO add MultiIndex test
+
+    @pytest.mark.parametrize(
+        "input_log, expected_log", [(True, "log"), ("sym", "symlog")]
+    )
+    def test_logscales(self, input_log, expected_log):
+        df = DataFrame({"a": np.arange(100)}, index=np.arange(100))
+
+        ax = df.plot(logy=input_log)
+        self._check_ax_scales(ax, yaxis=expected_log)
+        assert ax.get_yscale() == expected_log
+
+        ax = df.plot(logx=input_log)
+        self._check_ax_scales(ax, xaxis=expected_log)
+        assert ax.get_xscale() == expected_log
+
+        ax = df.plot(loglog=input_log)
+        self._check_ax_scales(ax, xaxis=expected_log, yaxis=expected_log)
+        assert ax.get_xscale() == expected_log
+        assert ax.get_yscale() == expected_log
+
+    @pytest.mark.parametrize("input_param", ["logx", "logy", "loglog"])
+    def test_invalid_logscale(self, input_param):
+        # GH: 24867
+        df = DataFrame({"a": np.arange(100)}, index=np.arange(100))
+
+        msg = "Boolean, None and 'sym' are valid options, 'sm' is given."
+        with pytest.raises(ValueError, match=msg):
+            df.plot(**{input_param: "sm"})
+
+    def test_xcompat(self):
+        df = tm.makeTimeDataFrame()
+        ax = df.plot(x_compat=True)
+        lines = ax.get_lines()
+        assert not isinstance(lines[0].get_xdata(), PeriodIndex)
+        self._check_ticks_props(ax, xrot=30)
+
+        tm.close()
+        plotting.plot_params["xaxis.compat"] = True
+        ax = df.plot()
+        lines = ax.get_lines()
+        assert not isinstance(lines[0].get_xdata(), PeriodIndex)
+        self._check_ticks_props(ax, xrot=30)
+
+        tm.close()
+        plotting.plot_params["x_compat"] = False
+
+        ax = df.plot()
+        lines = ax.get_lines()
+        assert not isinstance(lines[0].get_xdata(), PeriodIndex)
+        assert isinstance(PeriodIndex(lines[0].get_xdata()), PeriodIndex)
+
+        tm.close()
+        # useful if you're plotting a bunch together
+        with plotting.plot_params.use("x_compat", True):
+            ax = df.plot()
+            lines = ax.get_lines()
+            assert not isinstance(lines[0].get_xdata(), PeriodIndex)
+            self._check_ticks_props(ax, xrot=30)
+
+        tm.close()
+        ax = df.plot()
+        lines = ax.get_lines()
+        assert not isinstance(lines[0].get_xdata(), PeriodIndex)
+        assert isinstance(PeriodIndex(lines[0].get_xdata()), PeriodIndex)
+        self._check_ticks_props(ax, xrot=0)
+
+    def test_period_compat(self):
+        # GH 9012
+        # period-array conversions
+        df = DataFrame(
+            np.random.rand(21, 2),
+            index=bdate_range(datetime(2000, 1, 1), datetime(2000, 1, 31)),
+            columns=["a", "b"],
+        )
+
+        df.plot()
+        self.plt.axhline(y=0)
+        tm.close()
+
+    def test_unsorted_index(self):
+        df = DataFrame(
+            {"y": np.arange(100)}, index=np.arange(99, -1, -1), dtype=np.int64
+        )
+        ax = df.plot()
+        lines = ax.get_lines()[0]
+        rs = lines.get_xydata()
+        rs = Series(rs[:, 1], rs[:, 0], dtype=np.int64, name="y")
+        tm.assert_series_equal(rs, df.y, check_index_type=False)
+        tm.close()
+
+        df.index = pd.Index(np.arange(99, -1, -1), dtype=np.float64)
+        ax = df.plot()
+        lines = ax.get_lines()[0]
+        rs = lines.get_xydata()
+        rs = Series(rs[:, 1], rs[:, 0], dtype=np.int64, name="y")
+        tm.assert_series_equal(rs, df.y)
+
+    def test_unsorted_index_lims(self):
+        df = DataFrame({"y": [0.0, 1.0, 2.0, 3.0]}, index=[1.0, 0.0, 3.0, 2.0])
+        ax = df.plot()
+        xmin, xmax = ax.get_xlim()
+        lines = ax.get_lines()
+        assert xmin <= np.nanmin(lines[0].get_data()[0])
+        assert xmax >= np.nanmax(lines[0].get_data()[0])
+
+        df = DataFrame(
+            {"y": [0.0, 1.0, np.nan, 3.0, 4.0, 5.0, 6.0]},
+            index=[1.0, 0.0, 3.0, 2.0, np.nan, 3.0, 2.0],
+        )
+        ax = df.plot()
+        xmin, xmax = ax.get_xlim()
+        lines = ax.get_lines()
+        assert xmin <= np.nanmin(lines[0].get_data()[0])
+        assert xmax >= np.nanmax(lines[0].get_data()[0])
+
+        df = DataFrame({"y": [0.0, 1.0, 2.0, 3.0], "z": [91.0, 90.0, 93.0, 92.0]})
+        ax = df.plot(x="z", y="y")
+        xmin, xmax = ax.get_xlim()
+        lines = ax.get_lines()
+        assert xmin <= np.nanmin(lines[0].get_data()[0])
+        assert xmax >= np.nanmax(lines[0].get_data()[0])
+
+    def test_negative_log(self):
+        df = -DataFrame(
+            np.random.rand(6, 4),
+            index=list(string.ascii_letters[:6]),
+            columns=["x", "y", "z", "four"],
+        )
+        msg = "Log-y scales are not supported in area plot"
+        with pytest.raises(ValueError, match=msg):
+            df.plot.area(logy=True)
+        with pytest.raises(ValueError, match=msg):
+            df.plot.area(loglog=True)
+
+    def _compare_stacked_y_cood(self, normal_lines, stacked_lines):
+        base = np.zeros(len(normal_lines[0].get_data()[1]))
+        for nl, sl in zip(normal_lines, stacked_lines):
+            base += nl.get_data()[1]  # get y coordinates
+            sy = sl.get_data()[1]
+            tm.assert_numpy_array_equal(base, sy)
+
+    @pytest.mark.parametrize("kind", ["line", "area"])
+    def test_line_area_stacked(self, kind):
+        np_random = np.random.RandomState(42)
+        df = DataFrame(np_random.rand(6, 4), columns=["w", "x", "y", "z"])
+        neg_df = -df
+        # each column has either positive or negative value
+        sep_df = DataFrame(
+            {
+                "w": np_random.rand(6),
+                "x": np_random.rand(6),
+                "y": -np_random.rand(6),
+                "z": -np_random.rand(6),
+            }
+        )
+        # each column has positive-negative mixed value
+        mixed_df = DataFrame(
+            np_random.randn(6, 4),
+            index=list(string.ascii_letters[:6]),
+            columns=["w", "x", "y", "z"],
+        )
+
+        ax1 = _check_plot_works(df.plot, kind=kind, stacked=False)
+        ax2 = _check_plot_works(df.plot, kind=kind, stacked=True)
+        self._compare_stacked_y_cood(ax1.lines, ax2.lines)
+
+        ax1 = _check_plot_works(neg_df.plot, kind=kind, stacked=False)
+        ax2 = _check_plot_works(neg_df.plot, kind=kind, stacked=True)
+        self._compare_stacked_y_cood(ax1.lines, ax2.lines)
+
+        ax1 = _check_plot_works(sep_df.plot, kind=kind, stacked=False)
+        ax2 = _check_plot_works(sep_df.plot, kind=kind, stacked=True)
+        self._compare_stacked_y_cood(ax1.lines[:2], ax2.lines[:2])
+        self._compare_stacked_y_cood(ax1.lines[2:], ax2.lines[2:])
+
+        _check_plot_works(mixed_df.plot, stacked=False)
+        msg = (
+            "When stacked is True, each column must be either all positive or "
+            "all negative. Column 'w' contains both positive and negative "
+            "values"
+        )
+        with pytest.raises(ValueError, match=msg):
+            mixed_df.plot(stacked=True)
+
+        # Use an index with strictly positive values, preventing
+        #  matplotlib from warning about ignoring xlim
+        df2 = df.set_index(df.index + 1)
+        _check_plot_works(df2.plot, kind=kind, logx=True, stacked=True)
+
+    def test_line_area_nan_df(self):
+        values1 = [1, 2, np.nan, 3]
+        values2 = [3, np.nan, 2, 1]
+        df = DataFrame({"a": values1, "b": values2})
+        tdf = DataFrame({"a": values1, "b": values2}, index=tm.makeDateIndex(k=4))
+
+        for d in [df, tdf]:
+            ax = _check_plot_works(d.plot)
+            masked1 = ax.lines[0].get_ydata()
+            masked2 = ax.lines[1].get_ydata()
+            # remove nan for comparison purpose
+
+            exp = np.array([1, 2, 3], dtype=np.float64)
+            tm.assert_numpy_array_equal(np.delete(masked1.data, 2), exp)
+
+            exp = np.array([3, 2, 1], dtype=np.float64)
+            tm.assert_numpy_array_equal(np.delete(masked2.data, 1), exp)
+            tm.assert_numpy_array_equal(
+                masked1.mask, np.array([False, False, True, False])
+            )
+            tm.assert_numpy_array_equal(
+                masked2.mask, np.array([False, True, False, False])
+            )
+
+            expected1 = np.array([1, 2, 0, 3], dtype=np.float64)
+            expected2 = np.array([3, 0, 2, 1], dtype=np.float64)
+
+            ax = _check_plot_works(d.plot, stacked=True)
+            tm.assert_numpy_array_equal(ax.lines[0].get_ydata(), expected1)
+            tm.assert_numpy_array_equal(ax.lines[1].get_ydata(), expected1 + expected2)
+
+            ax = _check_plot_works(d.plot.area)
+            tm.assert_numpy_array_equal(ax.lines[0].get_ydata(), expected1)
+            tm.assert_numpy_array_equal(ax.lines[1].get_ydata(), expected1 + expected2)
+
+            ax = _check_plot_works(d.plot.area, stacked=False)
+            tm.assert_numpy_array_equal(ax.lines[0].get_ydata(), expected1)
+            tm.assert_numpy_array_equal(ax.lines[1].get_ydata(), expected2)
+
+    def test_line_lim(self):
+        df = DataFrame(np.random.rand(6, 3), columns=["x", "y", "z"])
+        ax = df.plot()
+        xmin, xmax = ax.get_xlim()
+        lines = ax.get_lines()
+        assert xmin <= lines[0].get_data()[0][0]
+        assert xmax >= lines[0].get_data()[0][-1]
+
+        ax = df.plot(secondary_y=True)
+        xmin, xmax = ax.get_xlim()
+        lines = ax.get_lines()
+        assert xmin <= lines[0].get_data()[0][0]
+        assert xmax >= lines[0].get_data()[0][-1]
+
+        axes = df.plot(secondary_y=True, subplots=True)
+        self._check_axes_shape(axes, axes_num=3, layout=(3, 1))
+        for ax in axes:
+            assert hasattr(ax, "left_ax")
+            assert not hasattr(ax, "right_ax")
+            xmin, xmax = ax.get_xlim()
+            lines = ax.get_lines()
+            assert xmin <= lines[0].get_data()[0][0]
+            assert xmax >= lines[0].get_data()[0][-1]
+
+    @pytest.mark.xfail(
+        strict=False,
+        reason="2020-12-01 this has been failing periodically on the "
+        "ymin==0 assertion for a week or so.",
+    )
+    @pytest.mark.parametrize("stacked", [True, False])
+    def test_area_lim(self, stacked):
+        df = DataFrame(np.random.rand(6, 4), columns=["x", "y", "z", "four"])
+
+        neg_df = -df
+
+        ax = _check_plot_works(df.plot.area, stacked=stacked)
+        xmin, xmax = ax.get_xlim()
+        ymin, ymax = ax.get_ylim()
+        lines = ax.get_lines()
+        assert xmin <= lines[0].get_data()[0][0]
+        assert xmax >= lines[0].get_data()[0][-1]
+        assert ymin == 0
+
+        ax = _check_plot_works(neg_df.plot.area, stacked=stacked)
+        ymin, ymax = ax.get_ylim()
+        assert ymax == 0
+
+    def test_area_sharey_dont_overwrite(self):
+        # GH37942
+        df = DataFrame(np.random.rand(4, 2), columns=["x", "y"])
+        fig, (ax1, ax2) = self.plt.subplots(1, 2, sharey=True)
+
+        df.plot(ax=ax1, kind="area")
+        df.plot(ax=ax2, kind="area")
+
+        assert self.get_y_axis(ax1).joined(ax1, ax2)
+        assert self.get_y_axis(ax2).joined(ax1, ax2)
+
+    def test_bar_linewidth(self):
+        df = DataFrame(np.random.randn(5, 5))
+
+        # regular
+        ax = df.plot.bar(linewidth=2)
+        for r in ax.patches:
+            assert r.get_linewidth() == 2
+
+        # stacked
+        ax = df.plot.bar(stacked=True, linewidth=2)
+        for r in ax.patches:
+            assert r.get_linewidth() == 2
+
+        # subplots
+        axes = df.plot.bar(linewidth=2, subplots=True)
+        self._check_axes_shape(axes, axes_num=5, layout=(5, 1))
+        for ax in axes:
+            for r in ax.patches:
+                assert r.get_linewidth() == 2
+
+    def test_bar_barwidth(self):
+        df = DataFrame(np.random.randn(5, 5))
+
+        width = 0.9
+
+        # regular
+        ax = df.plot.bar(width=width)
+        for r in ax.patches:
+            assert r.get_width() == width / len(df.columns)
+
+        # stacked
+        ax = df.plot.bar(stacked=True, width=width)
+        for r in ax.patches:
+            assert r.get_width() == width
+
+        # horizontal regular
+        ax = df.plot.barh(width=width)
+        for r in ax.patches:
+            assert r.get_height() == width / len(df.columns)
+
+        # horizontal stacked
+        ax = df.plot.barh(stacked=True, width=width)
+        for r in ax.patches:
+            assert r.get_height() == width
+
+        # subplots
+        axes = df.plot.bar(width=width, subplots=True)
+        for ax in axes:
+            for r in ax.patches:
+                assert r.get_width() == width
+
+        # horizontal subplots
+        axes = df.plot.barh(width=width, subplots=True)
+        for ax in axes:
+            for r in ax.patches:
+                assert r.get_height() == width
+
+    def test_bar_bottom_left(self):
+        df = DataFrame(np.random.rand(5, 5))
+        ax = df.plot.bar(stacked=False, bottom=1)
+        result = [p.get_y() for p in ax.patches]
+        assert result == [1] * 25
+
+        ax = df.plot.bar(stacked=True, bottom=[-1, -2, -3, -4, -5])
+        result = [p.get_y() for p in ax.patches[:5]]
+        assert result == [-1, -2, -3, -4, -5]
+
+        ax = df.plot.barh(stacked=False, left=np.array([1, 1, 1, 1, 1]))
+        result = [p.get_x() for p in ax.patches]
+        assert result == [1] * 25
+
+        ax = df.plot.barh(stacked=True, left=[1, 2, 3, 4, 5])
+        result = [p.get_x() for p in ax.patches[:5]]
+        assert result == [1, 2, 3, 4, 5]
+
+        axes = df.plot.bar(subplots=True, bottom=-1)
+        for ax in axes:
+            result = [p.get_y() for p in ax.patches]
+            assert result == [-1] * 5
+
+        axes = df.plot.barh(subplots=True, left=np.array([1, 1, 1, 1, 1]))
+        for ax in axes:
+            result = [p.get_x() for p in ax.patches]
+            assert result == [1] * 5
+
+    def test_bar_nan(self):
+        df = DataFrame({"A": [10, np.nan, 20], "B": [5, 10, 20], "C": [1, 2, 3]})
+        ax = df.plot.bar()
+        expected = [10, 0, 20, 5, 10, 20, 1, 2, 3]
+        result = [p.get_height() for p in ax.patches]
+        assert result == expected
+
+        ax = df.plot.bar(stacked=True)
+        result = [p.get_height() for p in ax.patches]
+        assert result == expected
+
+        result = [p.get_y() for p in ax.patches]
+        expected = [0.0, 0.0, 0.0, 10.0, 0.0, 20.0, 15.0, 10.0, 40.0]
+        assert result == expected
+
+    def test_bar_categorical(self):
+        # GH 13019
+        df1 = DataFrame(
+            np.random.randn(6, 5),
+            index=pd.Index(list("ABCDEF")),
+            columns=pd.Index(list("abcde")),
+        )
+        # categorical index must behave the same
+        df2 = DataFrame(
+            np.random.randn(6, 5),
+            index=pd.CategoricalIndex(list("ABCDEF")),
+            columns=pd.CategoricalIndex(list("abcde")),
+        )
+
+        for df in [df1, df2]:
+            ax = df.plot.bar()
+            ticks = ax.xaxis.get_ticklocs()
+            tm.assert_numpy_array_equal(ticks, np.array([0, 1, 2, 3, 4, 5]))
+            assert ax.get_xlim() == (-0.5, 5.5)
+            # check left-edge of bars
+            assert ax.patches[0].get_x() == -0.25
+            assert ax.patches[-1].get_x() == 5.15
+
+            ax = df.plot.bar(stacked=True)
+            tm.assert_numpy_array_equal(ticks, np.array([0, 1, 2, 3, 4, 5]))
+            assert ax.get_xlim() == (-0.5, 5.5)
+            assert ax.patches[0].get_x() == -0.25
+            assert ax.patches[-1].get_x() == 4.75
+
+    def test_plot_scatter(self):
+        df = DataFrame(
+            np.random.randn(6, 4),
+            index=list(string.ascii_letters[:6]),
+            columns=["x", "y", "z", "four"],
+        )
+
+        _check_plot_works(df.plot.scatter, x="x", y="y")
+        _check_plot_works(df.plot.scatter, x=1, y=2)
+
+        msg = re.escape("scatter() missing 1 required positional argument: 'y'")
+        with pytest.raises(TypeError, match=msg):
+            df.plot.scatter(x="x")
+        msg = re.escape("scatter() missing 1 required positional argument: 'x'")
+        with pytest.raises(TypeError, match=msg):
+            df.plot.scatter(y="y")
+
+        # GH 6951
+        axes = df.plot(x="x", y="y", kind="scatter", subplots=True)
+        self._check_axes_shape(axes, axes_num=1, layout=(1, 1))
+
+    def test_raise_error_on_datetime_time_data(self):
+        # GH 8113, datetime.time type is not supported by matplotlib in scatter
+        df = DataFrame(np.random.randn(10), columns=["a"])
+        df["dtime"] = date_range(start="2014-01-01", freq="h", periods=10).time
+        msg = "must be a string or a (real )?number, not 'datetime.time'"
+
+        with pytest.raises(TypeError, match=msg):
+            df.plot(kind="scatter", x="dtime", y="a")
+
+    def test_scatterplot_datetime_data(self):
+        # GH 30391
+        dates = date_range(start=date(2019, 1, 1), periods=12, freq="W")
+        vals = np.random.normal(0, 1, len(dates))
+        df = DataFrame({"dates": dates, "vals": vals})
+
+        _check_plot_works(df.plot.scatter, x="dates", y="vals")
+        _check_plot_works(df.plot.scatter, x=0, y=1)
+
+    def test_scatterplot_object_data(self):
+        # GH 18755
+        df = DataFrame({"a": ["A", "B", "C"], "b": [2, 3, 4]})
+
+        _check_plot_works(df.plot.scatter, x="a", y="b")
+        _check_plot_works(df.plot.scatter, x=0, y=1)
+
+        df = DataFrame({"a": ["A", "B", "C"], "b": ["a", "b", "c"]})
+
+        _check_plot_works(df.plot.scatter, x="a", y="b")
+        _check_plot_works(df.plot.scatter, x=0, y=1)
+
+    @pytest.mark.parametrize("ordered", [True, False])
+    @pytest.mark.parametrize(
+        "categories",
+        (["setosa", "versicolor", "virginica"], ["versicolor", "virginica", "setosa"]),
+    )
+    def test_scatterplot_color_by_categorical(self, ordered, categories):
+        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"] = pd.Categorical(
+            ["setosa", "setosa", "virginica", "virginica", "versicolor"],
+            ordered=ordered,
+            categories=categories,
+        )
+        ax = df.plot.scatter(x=0, y=1, c="species")
+        (colorbar_collection,) = ax.collections
+        colorbar = colorbar_collection.colorbar
+
+        expected_ticks = np.array([0.5, 1.5, 2.5])
+        result_ticks = colorbar.get_ticks()
+        tm.assert_numpy_array_equal(result_ticks, expected_ticks)
+
+        expected_boundaries = np.array([0.0, 1.0, 2.0, 3.0])
+        result_boundaries = colorbar._boundaries
+        tm.assert_numpy_array_equal(result_boundaries, expected_boundaries)
+
+        expected_yticklabels = categories
+        result_yticklabels = [i.get_text() for i in colorbar.ax.get_ymajorticklabels()]
+        assert all(i == j for i, j in zip(result_yticklabels, expected_yticklabels))
+
+    @pytest.mark.parametrize("x, y", [("x", "y"), ("y", "x"), ("y", "y")])
+    def test_plot_scatter_with_categorical_data(self, x, y):
+        # after fixing GH 18755, should be able to plot categorical data
+        df = DataFrame({"x": [1, 2, 3, 4], "y": pd.Categorical(["a", "b", "a", "c"])})
+
+        _check_plot_works(df.plot.scatter, x=x, y=y)
+
+    def test_plot_scatter_with_c(self):
+        df = DataFrame(
+            np.random.randint(low=0, high=100, size=(6, 4)),
+            index=list(string.ascii_letters[:6]),
+            columns=["x", "y", "z", "four"],
+        )
+
+        axes = [df.plot.scatter(x="x", y="y", c="z"), df.plot.scatter(x=0, y=1, c=2)]
+        for ax in axes:
+            # default to Greys
+            assert ax.collections[0].cmap.name == "Greys"
+
+            assert ax.collections[0].colorbar.ax.get_ylabel() == "z"
+
+        cm = "cubehelix"
+        ax = df.plot.scatter(x="x", y="y", c="z", colormap=cm)
+        assert ax.collections[0].cmap.name == cm
+
+        # verify turning off colorbar works
+        ax = df.plot.scatter(x="x", y="y", c="z", colorbar=False)
+        assert ax.collections[0].colorbar is None
+
+        # verify that we can still plot a solid color
+        ax = df.plot.scatter(x=0, y=1, c="red")
+        assert ax.collections[0].colorbar is None
+        self._check_colors(ax.collections, facecolors=["r"])
+
+        # Ensure that we can pass an np.array straight through to matplotlib,
+        # this functionality was accidentally removed previously.
+        # See https://github.com/pandas-dev/pandas/issues/8852 for bug report
+        #
+        # Exercise colormap path and non-colormap path as they are independent
+        #
+        df = DataFrame({"A": [1, 2], "B": [3, 4]})
+        red_rgba = [1.0, 0.0, 0.0, 1.0]
+        green_rgba = [0.0, 1.0, 0.0, 1.0]
+        rgba_array = np.array([red_rgba, green_rgba])
+        ax = df.plot.scatter(x="A", y="B", c=rgba_array)
+        # expect the face colors of the points in the non-colormap path to be
+        # identical to the values we supplied, normally we'd be on shaky ground
+        # comparing floats for equality but here we expect them to be
+        # identical.
+        tm.assert_numpy_array_equal(ax.collections[0].get_facecolor(), rgba_array)
+        # we don't test the colors of the faces in this next plot because they
+        # are dependent on the spring colormap, which may change its colors
+        # later.
+        float_array = np.array([0.0, 1.0])
+        df.plot.scatter(x="A", y="B", c=float_array, cmap="spring")
+
+    def test_plot_scatter_with_s(self):
+        # this refers to GH 32904
+        df = DataFrame(np.random.random((10, 3)) * 100, columns=["a", "b", "c"])
+
+        ax = df.plot.scatter(x="a", y="b", s="c")
+        tm.assert_numpy_array_equal(df["c"].values, right=ax.collections[0].get_sizes())
+
+    def test_plot_scatter_with_norm(self):
+        # added while fixing GH 45809
+        import matplotlib as mpl
+
+        df = DataFrame(np.random.random((10, 3)) * 100, columns=["a", "b", "c"])
+        norm = mpl.colors.LogNorm()
+        ax = df.plot.scatter(x="a", y="b", c="c", norm=norm)
+        assert ax.collections[0].norm is norm
+
+    def test_plot_scatter_without_norm(self):
+        # added while fixing GH 45809
+        import matplotlib as mpl
+
+        df = DataFrame(np.random.random((10, 3)) * 100, columns=["a", "b", "c"])
+        ax = df.plot.scatter(x="a", y="b", c="c")
+        plot_norm = ax.collections[0].norm
+        color_min_max = (df.c.min(), df.c.max())
+        default_norm = mpl.colors.Normalize(*color_min_max)
+        for value in df.c:
+            assert plot_norm(value) == default_norm(value)
+
+    @pytest.mark.slow
+    def test_plot_bar(self):
+        df = DataFrame(
+            np.random.randn(6, 4),
+            index=list(string.ascii_letters[:6]),
+            columns=["one", "two", "three", "four"],
+        )
+
+        _check_plot_works(df.plot.bar)
+        _check_plot_works(df.plot.bar, legend=False)
+        _check_plot_works(df.plot.bar, default_axes=True, subplots=True)
+        _check_plot_works(df.plot.bar, stacked=True)
+
+        df = DataFrame(
+            np.random.randn(10, 15),
+            index=list(string.ascii_letters[:10]),
+            columns=range(15),
+        )
+        _check_plot_works(df.plot.bar)
+
+        df = DataFrame({"a": [0, 1], "b": [1, 0]})
+        ax = _check_plot_works(df.plot.bar)
+        self._check_ticks_props(ax, xrot=90)
+
+        ax = df.plot.bar(rot=35, fontsize=10)
+        self._check_ticks_props(ax, xrot=35, xlabelsize=10, ylabelsize=10)
+
+        ax = _check_plot_works(df.plot.barh)
+        self._check_ticks_props(ax, yrot=0)
+
+        ax = df.plot.barh(rot=55, fontsize=11)
+        self._check_ticks_props(ax, yrot=55, ylabelsize=11, xlabelsize=11)
+
+    def test_boxplot(self, hist_df):
+        df = hist_df
+        series = df["height"]
+        numeric_cols = df._get_numeric_data().columns
+        labels = [pprint_thing(c) for c in numeric_cols]
+
+        ax = _check_plot_works(df.plot.box)
+        self._check_text_labels(ax.get_xticklabels(), labels)
+        tm.assert_numpy_array_equal(
+            ax.xaxis.get_ticklocs(), np.arange(1, len(numeric_cols) + 1)
+        )
+        assert len(ax.lines) == 7 * len(numeric_cols)
+        tm.close()
+
+        axes = series.plot.box(rot=40)
+        self._check_ticks_props(axes, xrot=40, yrot=0)
+        tm.close()
+
+        ax = _check_plot_works(series.plot.box)
+
+        positions = np.array([1, 6, 7])
+        ax = df.plot.box(positions=positions)
+        numeric_cols = df._get_numeric_data().columns
+        labels = [pprint_thing(c) for c in numeric_cols]
+        self._check_text_labels(ax.get_xticklabels(), labels)
+        tm.assert_numpy_array_equal(ax.xaxis.get_ticklocs(), positions)
+        assert len(ax.lines) == 7 * len(numeric_cols)
+
+    def test_boxplot_vertical(self, hist_df):
+        df = hist_df
+        numeric_cols = df._get_numeric_data().columns
+        labels = [pprint_thing(c) for c in numeric_cols]
+
+        # if horizontal, yticklabels are rotated
+        ax = df.plot.box(rot=50, fontsize=8, vert=False)
+        self._check_ticks_props(ax, xrot=0, yrot=50, ylabelsize=8)
+        self._check_text_labels(ax.get_yticklabels(), labels)
+        assert len(ax.lines) == 7 * len(numeric_cols)
+
+        axes = _check_plot_works(
+            df.plot.box,
+            default_axes=True,
+            subplots=True,
+            vert=False,
+            logx=True,
+        )
+        self._check_axes_shape(axes, axes_num=3, layout=(1, 3))
+        self._check_ax_scales(axes, xaxis="log")
+        for ax, label in zip(axes, labels):
+            self._check_text_labels(ax.get_yticklabels(), [label])
+            assert len(ax.lines) == 7
+
+        positions = np.array([3, 2, 8])
+        ax = df.plot.box(positions=positions, vert=False)
+        self._check_text_labels(ax.get_yticklabels(), labels)
+        tm.assert_numpy_array_equal(ax.yaxis.get_ticklocs(), positions)
+        assert len(ax.lines) == 7 * len(numeric_cols)
+
+    def test_boxplot_return_type(self):
+        df = DataFrame(
+            np.random.randn(6, 4),
+            index=list(string.ascii_letters[:6]),
+            columns=["one", "two", "three", "four"],
+        )
+        msg = "return_type must be {None, 'axes', 'dict', 'both'}"
+        with pytest.raises(ValueError, match=msg):
+            df.plot.box(return_type="not_a_type")
+
+        result = df.plot.box(return_type="dict")
+        self._check_box_return_type(result, "dict")
+
+        result = df.plot.box(return_type="axes")
+        self._check_box_return_type(result, "axes")
+
+        result = df.plot.box()  # default axes
+        self._check_box_return_type(result, "axes")
+
+        result = df.plot.box(return_type="both")
+        self._check_box_return_type(result, "both")
+
+    @td.skip_if_no_scipy
+    def test_kde_df(self):
+        df = DataFrame(np.random.randn(100, 4))
+        ax = _check_plot_works(df.plot, kind="kde")
+        expected = [pprint_thing(c) for c in df.columns]
+        self._check_legend_labels(ax, labels=expected)
+        self._check_ticks_props(ax, xrot=0)
+
+        ax = df.plot(kind="kde", rot=20, fontsize=5)
+        self._check_ticks_props(ax, xrot=20, xlabelsize=5, ylabelsize=5)
+
+        axes = _check_plot_works(
+            df.plot,
+            default_axes=True,
+            kind="kde",
+            subplots=True,
+        )
+        self._check_axes_shape(axes, axes_num=4, layout=(4, 1))
+
+        axes = df.plot(kind="kde", logy=True, subplots=True)
+        self._check_ax_scales(axes, yaxis="log")
+
+    @td.skip_if_no_scipy
+    def test_kde_missing_vals(self):
+        df = DataFrame(np.random.uniform(size=(100, 4)))
+        df.loc[0, 0] = np.nan
+        _check_plot_works(df.plot, kind="kde")
+
+    def test_hist_df(self):
+        from matplotlib.patches import Rectangle
+
+        df = DataFrame(np.random.randn(100, 4))
+        series = df[0]
+
+        ax = _check_plot_works(df.plot.hist)
+        expected = [pprint_thing(c) for c in df.columns]
+        self._check_legend_labels(ax, labels=expected)
+
+        axes = _check_plot_works(
+            df.plot.hist,
+            default_axes=True,
+            subplots=True,
+            logy=True,
+        )
+        self._check_axes_shape(axes, axes_num=4, layout=(4, 1))
+        self._check_ax_scales(axes, yaxis="log")
+
+        axes = series.plot.hist(rot=40)
+        self._check_ticks_props(axes, xrot=40, yrot=0)
+        tm.close()
+
+        ax = series.plot.hist(cumulative=True, bins=4, density=True)
+        # height of last bin (index 5) must be 1.0
+        rects = [x for x in ax.get_children() if isinstance(x, Rectangle)]
+        tm.assert_almost_equal(rects[-1].get_height(), 1.0)
+        tm.close()
+
+        ax = series.plot.hist(cumulative=True, bins=4)
+        rects = [x for x in ax.get_children() if isinstance(x, Rectangle)]
+
+        tm.assert_almost_equal(rects[-2].get_height(), 100.0)
+        tm.close()
+
+        # if horizontal, yticklabels are rotated
+        axes = df.plot.hist(rot=50, fontsize=8, orientation="horizontal")
+        self._check_ticks_props(axes, xrot=0, yrot=50, ylabelsize=8)
+
+    @pytest.mark.parametrize(
+        "weights", [0.1 * np.ones(shape=(100,)), 0.1 * np.ones(shape=(100, 2))]
+    )
+    def test_hist_weights(self, weights):
+        # GH 33173
+        np.random.seed(0)
+        df = DataFrame(dict(zip(["A", "B"], np.random.randn(2, 100))))
+
+        ax1 = _check_plot_works(df.plot, kind="hist", weights=weights)
+        ax2 = _check_plot_works(df.plot, kind="hist")
+
+        patch_height_with_weights = [patch.get_height() for patch in ax1.patches]
+
+        # original heights with no weights, and we manually multiply with example
+        # weights, so after multiplication, they should be almost same
+        expected_patch_height = [0.1 * patch.get_height() for patch in ax2.patches]
+
+        tm.assert_almost_equal(patch_height_with_weights, expected_patch_height)
+
+    def _check_box_coord(
+        self,
+        patches,
+        expected_y=None,
+        expected_h=None,
+        expected_x=None,
+        expected_w=None,
+    ):
+        result_y = np.array([p.get_y() for p in patches])
+        result_height = np.array([p.get_height() for p in patches])
+        result_x = np.array([p.get_x() for p in patches])
+        result_width = np.array([p.get_width() for p in patches])
+        # dtype is depending on above values, no need to check
+
+        if expected_y is not None:
+            tm.assert_numpy_array_equal(result_y, expected_y, check_dtype=False)
+        if expected_h is not None:
+            tm.assert_numpy_array_equal(result_height, expected_h, check_dtype=False)
+        if expected_x is not None:
+            tm.assert_numpy_array_equal(result_x, expected_x, check_dtype=False)
+        if expected_w is not None:
+            tm.assert_numpy_array_equal(result_width, expected_w, check_dtype=False)
+
+    def test_hist_df_coord(self):
+        normal_df = DataFrame(
+            {
+                "A": np.repeat(np.array([1, 2, 3, 4, 5]), np.array([10, 9, 8, 7, 6])),
+                "B": np.repeat(np.array([1, 2, 3, 4, 5]), np.array([8, 8, 8, 8, 8])),
+                "C": np.repeat(np.array([1, 2, 3, 4, 5]), np.array([6, 7, 8, 9, 10])),
+            },
+            columns=["A", "B", "C"],
+        )
+
+        nan_df = DataFrame(
+            {
+                "A": np.repeat(
+                    np.array([np.nan, 1, 2, 3, 4, 5]), np.array([3, 10, 9, 8, 7, 6])
+                ),
+                "B": np.repeat(
+                    np.array([1, np.nan, 2, 3, 4, 5]), np.array([8, 3, 8, 8, 8, 8])
+                ),
+                "C": np.repeat(
+                    np.array([1, 2, 3, np.nan, 4, 5]), np.array([6, 7, 8, 3, 9, 10])
+                ),
+            },
+            columns=["A", "B", "C"],
+        )
+
+        for df in [normal_df, nan_df]:
+            ax = df.plot.hist(bins=5)
+            self._check_box_coord(
+                ax.patches[:5],
+                expected_y=np.array([0, 0, 0, 0, 0]),
+                expected_h=np.array([10, 9, 8, 7, 6]),
+            )
+            self._check_box_coord(
+                ax.patches[5:10],
+                expected_y=np.array([0, 0, 0, 0, 0]),
+                expected_h=np.array([8, 8, 8, 8, 8]),
+            )
+            self._check_box_coord(
+                ax.patches[10:],
+                expected_y=np.array([0, 0, 0, 0, 0]),
+                expected_h=np.array([6, 7, 8, 9, 10]),
+            )
+
+            ax = df.plot.hist(bins=5, stacked=True)
+            self._check_box_coord(
+                ax.patches[:5],
+                expected_y=np.array([0, 0, 0, 0, 0]),
+                expected_h=np.array([10, 9, 8, 7, 6]),
+            )
+            self._check_box_coord(
+                ax.patches[5:10],
+                expected_y=np.array([10, 9, 8, 7, 6]),
+                expected_h=np.array([8, 8, 8, 8, 8]),
+            )
+            self._check_box_coord(
+                ax.patches[10:],
+                expected_y=np.array([18, 17, 16, 15, 14]),
+                expected_h=np.array([6, 7, 8, 9, 10]),
+            )
+
+            axes = df.plot.hist(bins=5, stacked=True, subplots=True)
+            self._check_box_coord(
+                axes[0].patches,
+                expected_y=np.array([0, 0, 0, 0, 0]),
+                expected_h=np.array([10, 9, 8, 7, 6]),
+            )
+            self._check_box_coord(
+                axes[1].patches,
+                expected_y=np.array([0, 0, 0, 0, 0]),
+                expected_h=np.array([8, 8, 8, 8, 8]),
+            )
+            self._check_box_coord(
+                axes[2].patches,
+                expected_y=np.array([0, 0, 0, 0, 0]),
+                expected_h=np.array([6, 7, 8, 9, 10]),
+            )
+
+            # horizontal
+            ax = df.plot.hist(bins=5, orientation="horizontal")
+            self._check_box_coord(
+                ax.patches[:5],
+                expected_x=np.array([0, 0, 0, 0, 0]),
+                expected_w=np.array([10, 9, 8, 7, 6]),
+            )
+            self._check_box_coord(
+                ax.patches[5:10],
+                expected_x=np.array([0, 0, 0, 0, 0]),
+                expected_w=np.array([8, 8, 8, 8, 8]),
+            )
+            self._check_box_coord(
+                ax.patches[10:],
+                expected_x=np.array([0, 0, 0, 0, 0]),
+                expected_w=np.array([6, 7, 8, 9, 10]),
+            )
+
+            ax = df.plot.hist(bins=5, stacked=True, orientation="horizontal")
+            self._check_box_coord(
+                ax.patches[:5],
+                expected_x=np.array([0, 0, 0, 0, 0]),
+                expected_w=np.array([10, 9, 8, 7, 6]),
+            )
+            self._check_box_coord(
+                ax.patches[5:10],
+                expected_x=np.array([10, 9, 8, 7, 6]),
+                expected_w=np.array([8, 8, 8, 8, 8]),
+            )
+            self._check_box_coord(
+                ax.patches[10:],
+                expected_x=np.array([18, 17, 16, 15, 14]),
+                expected_w=np.array([6, 7, 8, 9, 10]),
+            )
+
+            axes = df.plot.hist(
+                bins=5, stacked=True, subplots=True, orientation="horizontal"
+            )
+            self._check_box_coord(
+                axes[0].patches,
+                expected_x=np.array([0, 0, 0, 0, 0]),
+                expected_w=np.array([10, 9, 8, 7, 6]),
+            )
+            self._check_box_coord(
+                axes[1].patches,
+                expected_x=np.array([0, 0, 0, 0, 0]),
+                expected_w=np.array([8, 8, 8, 8, 8]),
+            )
+            self._check_box_coord(
+                axes[2].patches,
+                expected_x=np.array([0, 0, 0, 0, 0]),
+                expected_w=np.array([6, 7, 8, 9, 10]),
+            )
+
+    def test_plot_int_columns(self):
+        df = DataFrame(np.random.randn(100, 4)).cumsum()
+        _check_plot_works(df.plot, legend=True)
+
+    def test_style_by_column(self):
+        import matplotlib.pyplot as plt
+
+        fig = plt.gcf()
+
+        df = DataFrame(np.random.randn(100, 3))
+        for markers in [
+            {0: "^", 1: "+", 2: "o"},
+            {0: "^", 1: "+"},
+            ["^", "+", "o"],
+            ["^", "+"],
+        ]:
+            fig.clf()
+            fig.add_subplot(111)
+            ax = df.plot(style=markers)
+            for idx, line in enumerate(ax.get_lines()[: len(markers)]):
+                assert line.get_marker() == markers[idx]
+
+    def test_line_label_none(self):
+        s = Series([1, 2])
+        ax = s.plot()
+        assert ax.get_legend() is None
+
+        ax = s.plot(legend=True)
+        assert ax.get_legend().get_texts()[0].get_text() == ""
+
+    @pytest.mark.parametrize(
+        "props, expected",
+        [
+            ("boxprops", "boxes"),
+            ("whiskerprops", "whiskers"),
+            ("capprops", "caps"),
+            ("medianprops", "medians"),
+        ],
+    )
+    def test_specified_props_kwd_plot_box(self, props, expected):
+        # GH 30346
+        df = DataFrame({k: np.random.random(100) for k in "ABC"})
+        kwd = {props: {"color": "C1"}}
+        result = df.plot.box(return_type="dict", **kwd)
+
+        assert result[expected][0].get_color() == "C1"
+
+    def test_unordered_ts(self):
+        df = DataFrame(
+            np.array([3.0, 2.0, 1.0]),
+            index=[date(2012, 10, 1), date(2012, 9, 1), date(2012, 8, 1)],
+            columns=["test"],
+        )
+        ax = df.plot()
+        xticks = ax.lines[0].get_xdata()
+        assert xticks[0] < xticks[1]
+        ydata = ax.lines[0].get_ydata()
+        tm.assert_numpy_array_equal(ydata, np.array([1.0, 2.0, 3.0]))
+
+    @td.skip_if_no_scipy
+    def test_kind_both_ways(self):
+        df = DataFrame({"x": [1, 2, 3]})
+        for kind in plotting.PlotAccessor._common_kinds:
+            df.plot(kind=kind)
+            getattr(df.plot, kind)()
+        for kind in ["scatter", "hexbin"]:
+            df.plot("x", "x", kind=kind)
+            getattr(df.plot, kind)("x", "x")
+
+    def test_all_invalid_plot_data(self):
+        df = DataFrame(list("abcd"))
+        for kind in plotting.PlotAccessor._common_kinds:
+            msg = "no numeric data to plot"
+            with pytest.raises(TypeError, match=msg):
+                df.plot(kind=kind)
+
+    def test_partially_invalid_plot_data(self):
+        df = DataFrame(np.random.RandomState(42).randn(10, 2), dtype=object)
+        df[np.random.rand(df.shape[0]) > 0.5] = "a"
+        for kind in plotting.PlotAccessor._common_kinds:
+            msg = "no numeric data to plot"
+            with pytest.raises(TypeError, match=msg):
+                df.plot(kind=kind)
+
+        # area plot doesn't support positive/negative mixed data
+        df = DataFrame(np.random.RandomState(42).rand(10, 2), dtype=object)
+        df[np.random.rand(df.shape[0]) > 0.5] = "a"
+        with pytest.raises(TypeError, match="no numeric data to plot"):
+            df.plot(kind="area")
+
+    def test_invalid_kind(self):
+        df = DataFrame(np.random.randn(10, 2))
+        msg = "invalid_plot_kind is not a valid plot kind"
+        with pytest.raises(ValueError, match=msg):
+            df.plot(kind="invalid_plot_kind")
+
+    @pytest.mark.parametrize(
+        "x,y,lbl",
+        [
+            (["B", "C"], "A", "a"),
+            (["A"], ["B", "C"], ["b", "c"]),
+        ],
+    )
+    def test_invalid_xy_args(self, x, y, lbl):
+        # GH 18671, 19699 allows y to be list-like but not x
+        df = DataFrame({"A": [1, 2], "B": [3, 4], "C": [5, 6]})
+        with pytest.raises(ValueError, match="x must be a label or position"):
+            df.plot(x=x, y=y, label=lbl)
+
+    def test_bad_label(self):
+        df = DataFrame({"A": [1, 2], "B": [3, 4], "C": [5, 6]})
+        msg = "label should be list-like and same length as y"
+        with pytest.raises(ValueError, match=msg):
+            df.plot(x="A", y=["B", "C"], label="bad_label")
+
+    @pytest.mark.parametrize("x,y", [("A", "B"), (["A"], "B")])
+    def test_invalid_xy_args_dup_cols(self, x, y):
+        # GH 18671, 19699 allows y to be list-like but not x
+        df = DataFrame([[1, 3, 5], [2, 4, 6]], columns=list("AAB"))
+        with pytest.raises(ValueError, match="x must be a label or position"):
+            df.plot(x=x, y=y)
+
+    @pytest.mark.parametrize(
+        "x,y,lbl,colors",
+        [
+            ("A", ["B"], ["b"], ["red"]),
+            ("A", ["B", "C"], ["b", "c"], ["red", "blue"]),
+            (0, [1, 2], ["bokeh", "cython"], ["green", "yellow"]),
+        ],
+    )
+    def test_y_listlike(self, x, y, lbl, colors):
+        # GH 19699: tests list-like y and verifies lbls & colors
+        df = DataFrame({"A": [1, 2], "B": [3, 4], "C": [5, 6]})
+        _check_plot_works(df.plot, x="A", y=y, label=lbl)
+
+        ax = df.plot(x=x, y=y, label=lbl, color=colors)
+        assert len(ax.lines) == len(y)
+        self._check_colors(ax.get_lines(), linecolors=colors)
+
+    @pytest.mark.parametrize("x,y,colnames", [(0, 1, ["A", "B"]), (1, 0, [0, 1])])
+    def test_xy_args_integer(self, x, y, colnames):
+        # GH 20056: tests integer args for xy and checks col names
+        df = DataFrame({"A": [1, 2], "B": [3, 4]})
+        df.columns = colnames
+        _check_plot_works(df.plot, x=x, y=y)
+
+    def test_hexbin_basic(self):
+        df = DataFrame(
+            {
+                "A": np.random.uniform(size=20),
+                "B": np.random.uniform(size=20),
+                "C": np.arange(20) + np.random.uniform(size=20),
+            }
+        )
+
+        ax = df.plot.hexbin(x="A", y="B", gridsize=10)
+        # TODO: need better way to test. This just does existence.
+        assert len(ax.collections) == 1
+
+        # GH 6951
+        axes = df.plot.hexbin(x="A", y="B", subplots=True)
+        # hexbin should have 2 axes in the figure, 1 for plotting and another
+        # is colorbar
+        assert len(axes[0].figure.axes) == 2
+        # return value is single axes
+        self._check_axes_shape(axes, axes_num=1, layout=(1, 1))
+
+    def test_hexbin_with_c(self):
+        df = DataFrame(
+            {
+                "A": np.random.uniform(size=20),
+                "B": np.random.uniform(size=20),
+                "C": np.arange(20) + np.random.uniform(size=20),
+            }
+        )
+
+        ax = df.plot.hexbin(x="A", y="B", C="C")
+        assert len(ax.collections) == 1
+
+        ax = df.plot.hexbin(x="A", y="B", C="C", reduce_C_function=np.std)
+        assert len(ax.collections) == 1
+
+    @pytest.mark.parametrize(
+        "kwargs, expected",
+        [
+            ({}, "BuGn"),  # default cmap
+            ({"colormap": "cubehelix"}, "cubehelix"),
+            ({"cmap": "YlGn"}, "YlGn"),
+        ],
+    )
+    def test_hexbin_cmap(self, kwargs, expected):
+        df = DataFrame(
+            {
+                "A": np.random.uniform(size=20),
+                "B": np.random.uniform(size=20),
+                "C": np.arange(20) + np.random.uniform(size=20),
+            }
+        )
+        ax = df.plot.hexbin(x="A", y="B", **kwargs)
+        assert ax.collections[0].cmap.name == expected
+
+    def test_pie_df(self):
+        df = DataFrame(
+            np.random.rand(5, 3),
+            columns=["X", "Y", "Z"],
+            index=["a", "b", "c", "d", "e"],
+        )
+        msg = "pie requires either y column or 'subplots=True'"
+        with pytest.raises(ValueError, match=msg):
+            df.plot.pie()
+
+        ax = _check_plot_works(df.plot.pie, y="Y")
+        self._check_text_labels(ax.texts, df.index)
+
+        ax = _check_plot_works(df.plot.pie, y=2)
+        self._check_text_labels(ax.texts, df.index)
+
+        axes = _check_plot_works(
+            df.plot.pie,
+            default_axes=True,
+            subplots=True,
+        )
+        assert len(axes) == len(df.columns)
+        for ax in axes:
+            self._check_text_labels(ax.texts, df.index)
+        for ax, ylabel in zip(axes, df.columns):
+            assert ax.get_ylabel() == ylabel
+
+        labels = ["A", "B", "C", "D", "E"]
+        color_args = ["r", "g", "b", "c", "m"]
+        axes = _check_plot_works(
+            df.plot.pie,
+            default_axes=True,
+            subplots=True,
+            labels=labels,
+            colors=color_args,
+        )
+        assert len(axes) == len(df.columns)
+
+        for ax in axes:
+            self._check_text_labels(ax.texts, labels)
+            self._check_colors(ax.patches, facecolors=color_args)
+
+    def test_pie_df_nan(self):
+        import matplotlib as mpl
+
+        df = DataFrame(np.random.rand(4, 4))
+        for i in range(4):
+            df.iloc[i, i] = np.nan
+        fig, axes = self.plt.subplots(ncols=4)
+
+        # GH 37668
+        kwargs = {}
+        if mpl.__version__ >= "3.3":
+            kwargs = {"normalize": True}
+
+        with tm.assert_produces_warning(None):
+            df.plot.pie(subplots=True, ax=axes, legend=True, **kwargs)
+
+        base_expected = ["0", "1", "2", "3"]
+        for i, ax in enumerate(axes):
+            expected = list(base_expected)  # force copy
+            expected[i] = ""
+            result = [x.get_text() for x in ax.texts]
+            assert result == expected
+
+            # legend labels
+            # NaN's not included in legend with subplots
+            # see https://github.com/pandas-dev/pandas/issues/8390
+            result_labels = [x.get_text() for x in ax.get_legend().get_texts()]
+            expected_labels = base_expected[:i] + base_expected[i + 1 :]
+            assert result_labels == expected_labels
+
+    @pytest.mark.slow
+    def test_errorbar_plot(self):
+        d = {"x": np.arange(12), "y": np.arange(12, 0, -1)}
+        df = DataFrame(d)
+        d_err = {"x": np.ones(12) * 0.2, "y": np.ones(12) * 0.4}
+        df_err = DataFrame(d_err)
+
+        # check line plots
+        ax = _check_plot_works(df.plot, yerr=df_err, logy=True)
+        self._check_has_errorbars(ax, xerr=0, yerr=2)
+
+        ax = _check_plot_works(df.plot, yerr=df_err, logx=True, logy=True)
+        self._check_has_errorbars(ax, xerr=0, yerr=2)
+
+        ax = _check_plot_works(df.plot, yerr=df_err, loglog=True)
+        self._check_has_errorbars(ax, xerr=0, yerr=2)
+
+        ax = _check_plot_works(
+            (df + 1).plot, yerr=df_err, xerr=df_err, kind="bar", log=True
+        )
+        self._check_has_errorbars(ax, xerr=2, yerr=2)
+
+        # yerr is raw error values
+        ax = _check_plot_works(df["y"].plot, yerr=np.ones(12) * 0.4)
+        self._check_has_errorbars(ax, xerr=0, yerr=1)
+
+        ax = _check_plot_works(df.plot, yerr=np.ones((2, 12)) * 0.4)
+        self._check_has_errorbars(ax, xerr=0, yerr=2)
+
+        # yerr is column name
+        for yerr in ["yerr", "誤差"]:
+            s_df = df.copy()
+            s_df[yerr] = np.ones(12) * 0.2
+
+            ax = _check_plot_works(s_df.plot, yerr=yerr)
+            self._check_has_errorbars(ax, xerr=0, yerr=2)
+
+            ax = _check_plot_works(s_df.plot, y="y", x="x", yerr=yerr)
+            self._check_has_errorbars(ax, xerr=0, yerr=1)
+
+        with tm.external_error_raised(ValueError):
+            df.plot(yerr=np.random.randn(11))
+
+        df_err = DataFrame({"x": ["zzz"] * 12, "y": ["zzz"] * 12})
+        with tm.external_error_raised(TypeError):
+            df.plot(yerr=df_err)
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("kind", ["line", "bar", "barh"])
+    def test_errorbar_plot_different_kinds(self, kind):
+        d = {"x": np.arange(12), "y": np.arange(12, 0, -1)}
+        df = DataFrame(d)
+        d_err = {"x": np.ones(12) * 0.2, "y": np.ones(12) * 0.4}
+        df_err = DataFrame(d_err)
+
+        ax = _check_plot_works(df.plot, yerr=df_err["x"], kind=kind)
+        self._check_has_errorbars(ax, xerr=0, yerr=2)
+
+        ax = _check_plot_works(df.plot, yerr=d_err, kind=kind)
+        self._check_has_errorbars(ax, xerr=0, yerr=2)
+
+        ax = _check_plot_works(df.plot, yerr=df_err, xerr=df_err, kind=kind)
+        self._check_has_errorbars(ax, xerr=2, yerr=2)
+
+        ax = _check_plot_works(df.plot, yerr=df_err["x"], xerr=df_err["x"], kind=kind)
+        self._check_has_errorbars(ax, xerr=2, yerr=2)
+
+        ax = _check_plot_works(df.plot, xerr=0.2, yerr=0.2, kind=kind)
+        self._check_has_errorbars(ax, xerr=2, yerr=2)
+
+        axes = _check_plot_works(
+            df.plot,
+            default_axes=True,
+            yerr=df_err,
+            xerr=df_err,
+            subplots=True,
+            kind=kind,
+        )
+        self._check_has_errorbars(axes, xerr=1, yerr=1)
+
+    @pytest.mark.xfail(reason="Iterator is consumed", raises=ValueError)
+    def test_errorbar_plot_iterator(self):
+        with warnings.catch_warnings():
+            d = {"x": np.arange(12), "y": np.arange(12, 0, -1)}
+            df = DataFrame(d)
+
+            # yerr is iterator
+            ax = _check_plot_works(df.plot, yerr=itertools.repeat(0.1, len(df)))
+            self._check_has_errorbars(ax, xerr=0, yerr=2)
+
+    def test_errorbar_with_integer_column_names(self):
+        # test with integer column names
+        df = DataFrame(np.abs(np.random.randn(10, 2)))
+        df_err = DataFrame(np.abs(np.random.randn(10, 2)))
+        ax = _check_plot_works(df.plot, yerr=df_err)
+        self._check_has_errorbars(ax, xerr=0, yerr=2)
+        ax = _check_plot_works(df.plot, y=0, yerr=1)
+        self._check_has_errorbars(ax, xerr=0, yerr=1)
+
+    @pytest.mark.slow
+    def test_errorbar_with_partial_columns(self):
+        df = DataFrame(np.abs(np.random.randn(10, 3)))
+        df_err = DataFrame(np.abs(np.random.randn(10, 2)), columns=[0, 2])
+        kinds = ["line", "bar"]
+        for kind in kinds:
+            ax = _check_plot_works(df.plot, yerr=df_err, kind=kind)
+            self._check_has_errorbars(ax, xerr=0, yerr=2)
+
+        ix = date_range("1/1/2000", periods=10, freq="M")
+        df.set_index(ix, inplace=True)
+        df_err.set_index(ix, inplace=True)
+        ax = _check_plot_works(df.plot, yerr=df_err, kind="line")
+        self._check_has_errorbars(ax, xerr=0, yerr=2)
+
+        d = {"x": np.arange(12), "y": np.arange(12, 0, -1)}
+        df = DataFrame(d)
+        d_err = {"x": np.ones(12) * 0.2, "z": np.ones(12) * 0.4}
+        df_err = DataFrame(d_err)
+        for err in [d_err, df_err]:
+            ax = _check_plot_works(df.plot, yerr=err)
+            self._check_has_errorbars(ax, xerr=0, yerr=1)
+
+    @pytest.mark.parametrize("kind", ["line", "bar", "barh"])
+    def test_errorbar_timeseries(self, kind):
+        d = {"x": np.arange(12), "y": np.arange(12, 0, -1)}
+        d_err = {"x": np.ones(12) * 0.2, "y": np.ones(12) * 0.4}
+
+        # check time-series plots
+        ix = date_range("1/1/2000", "1/1/2001", freq="M")
+        tdf = DataFrame(d, index=ix)
+        tdf_err = DataFrame(d_err, index=ix)
+
+        ax = _check_plot_works(tdf.plot, yerr=tdf_err, kind=kind)
+        self._check_has_errorbars(ax, xerr=0, yerr=2)
+
+        ax = _check_plot_works(tdf.plot, yerr=d_err, kind=kind)
+        self._check_has_errorbars(ax, xerr=0, yerr=2)
+
+        ax = _check_plot_works(tdf.plot, y="y", yerr=tdf_err["x"], kind=kind)
+        self._check_has_errorbars(ax, xerr=0, yerr=1)
+
+        ax = _check_plot_works(tdf.plot, y="y", yerr="x", kind=kind)
+        self._check_has_errorbars(ax, xerr=0, yerr=1)
+
+        ax = _check_plot_works(tdf.plot, yerr=tdf_err, kind=kind)
+        self._check_has_errorbars(ax, xerr=0, yerr=2)
+
+        axes = _check_plot_works(
+            tdf.plot,
+            default_axes=True,
+            kind=kind,
+            yerr=tdf_err,
+            subplots=True,
+        )
+        self._check_has_errorbars(axes, xerr=0, yerr=1)
+
+    def test_errorbar_asymmetrical(self):
+        np.random.seed(0)
+        err = np.random.rand(3, 2, 5)
+
+        # each column is [0, 1, 2, 3, 4], [3, 4, 5, 6, 7]...
+        df = DataFrame(np.arange(15).reshape(3, 5)).T
+
+        ax = df.plot(yerr=err, xerr=err / 2)
+
+        yerr_0_0 = ax.collections[1].get_paths()[0].vertices[:, 1]
+        expected_0_0 = err[0, :, 0] * np.array([-1, 1])
+        tm.assert_almost_equal(yerr_0_0, expected_0_0)
+
+        msg = re.escape(
+            "Asymmetrical error bars should be provided with the shape (3, 2, 5)"
+        )
+        with pytest.raises(ValueError, match=msg):
+            df.plot(yerr=err.T)
+
+        tm.close()
+
+    def test_table(self):
+        df = DataFrame(np.random.rand(10, 3), index=list(string.ascii_letters[:10]))
+        _check_plot_works(df.plot, table=True)
+        _check_plot_works(df.plot, table=df)
+
+        # GH 35945 UserWarning
+        with tm.assert_produces_warning(None):
+            ax = df.plot()
+            assert len(ax.tables) == 0
+            plotting.table(ax, df.T)
+            assert len(ax.tables) == 1
+
+    def test_errorbar_scatter(self):
+        df = DataFrame(
+            np.abs(np.random.randn(5, 2)), index=range(5), columns=["x", "y"]
+        )
+        df_err = DataFrame(
+            np.abs(np.random.randn(5, 2)) / 5, index=range(5), columns=["x", "y"]
+        )
+
+        ax = _check_plot_works(df.plot.scatter, x="x", y="y")
+        self._check_has_errorbars(ax, xerr=0, yerr=0)
+        ax = _check_plot_works(df.plot.scatter, x="x", y="y", xerr=df_err)
+        self._check_has_errorbars(ax, xerr=1, yerr=0)
+
+        ax = _check_plot_works(df.plot.scatter, x="x", y="y", yerr=df_err)
+        self._check_has_errorbars(ax, xerr=0, yerr=1)
+        ax = _check_plot_works(df.plot.scatter, x="x", y="y", xerr=df_err, yerr=df_err)
+        self._check_has_errorbars(ax, xerr=1, yerr=1)
+
+        def _check_errorbar_color(containers, expected, has_err="has_xerr"):
+            lines = []
+            errs = [c.lines for c in ax.containers if getattr(c, has_err, False)][0]
+            for el in errs:
+                if is_list_like(el):
+                    lines.extend(el)
+                else:
+                    lines.append(el)
+            err_lines = [x for x in lines if x in ax.collections]
+            self._check_colors(
+                err_lines, linecolors=np.array([expected] * len(err_lines))
+            )
+
+        # GH 8081
+        df = DataFrame(
+            np.abs(np.random.randn(10, 5)), columns=["a", "b", "c", "d", "e"]
+        )
+        ax = df.plot.scatter(x="a", y="b", xerr="d", yerr="e", c="red")
+        self._check_has_errorbars(ax, xerr=1, yerr=1)
+        _check_errorbar_color(ax.containers, "red", has_err="has_xerr")
+        _check_errorbar_color(ax.containers, "red", has_err="has_yerr")
+
+        ax = df.plot.scatter(x="a", y="b", yerr="e", color="green")
+        self._check_has_errorbars(ax, xerr=0, yerr=1)
+        _check_errorbar_color(ax.containers, "green", has_err="has_yerr")
+
+    def test_scatter_unknown_colormap(self):
+        # GH#48726
+        df = DataFrame({"a": [1, 2, 3], "b": 4})
+        with pytest.raises((ValueError, KeyError), match="'unknown' is not a"):
+            df.plot(x="a", y="b", colormap="unknown", kind="scatter")
+
+    def test_sharex_and_ax(self):
+        # https://github.com/pandas-dev/pandas/issues/9737 using gridspec,
+        # the axis in fig.get_axis() are sorted differently than pandas
+        # expected them, so make sure that only the right ones are removed
+        import matplotlib.pyplot as plt
+
+        plt.close("all")
+        gs, axes = _generate_4_axes_via_gridspec()
+
+        df = DataFrame(
+            {
+                "a": [1, 2, 3, 4, 5, 6],
+                "b": [1, 2, 3, 4, 5, 6],
+                "c": [1, 2, 3, 4, 5, 6],
+                "d": [1, 2, 3, 4, 5, 6],
+            }
+        )
+
+        def _check(axes):
+            for ax in axes:
+                assert len(ax.lines) == 1
+                self._check_visible(ax.get_yticklabels(), visible=True)
+            for ax in [axes[0], axes[2]]:
+                self._check_visible(ax.get_xticklabels(), visible=False)
+                self._check_visible(ax.get_xticklabels(minor=True), visible=False)
+            for ax in [axes[1], axes[3]]:
+                self._check_visible(ax.get_xticklabels(), visible=True)
+                self._check_visible(ax.get_xticklabels(minor=True), visible=True)
+
+        for ax in axes:
+            df.plot(x="a", y="b", title="title", ax=ax, sharex=True)
+        gs.tight_layout(plt.gcf())
+        _check(axes)
+        tm.close()
+
+        gs, axes = _generate_4_axes_via_gridspec()
+        with tm.assert_produces_warning(UserWarning):
+            axes = df.plot(subplots=True, ax=axes, sharex=True)
+        _check(axes)
+        tm.close()
+
+        gs, axes = _generate_4_axes_via_gridspec()
+        # without sharex, no labels should be touched!
+        for ax in axes:
+            df.plot(x="a", y="b", title="title", ax=ax)
+
+        gs.tight_layout(plt.gcf())
+        for ax in axes:
+            assert len(ax.lines) == 1
+            self._check_visible(ax.get_yticklabels(), visible=True)
+            self._check_visible(ax.get_xticklabels(), visible=True)
+            self._check_visible(ax.get_xticklabels(minor=True), visible=True)
+        tm.close()
+
+    def test_sharey_and_ax(self):
+        # https://github.com/pandas-dev/pandas/issues/9737 using gridspec,
+        # the axis in fig.get_axis() are sorted differently than pandas
+        # expected them, so make sure that only the right ones are removed
+        import matplotlib.pyplot as plt
+
+        gs, axes = _generate_4_axes_via_gridspec()
+
+        df = DataFrame(
+            {
+                "a": [1, 2, 3, 4, 5, 6],
+                "b": [1, 2, 3, 4, 5, 6],
+                "c": [1, 2, 3, 4, 5, 6],
+                "d": [1, 2, 3, 4, 5, 6],
+            }
+        )
+
+        def _check(axes):
+            for ax in axes:
+                assert len(ax.lines) == 1
+                self._check_visible(ax.get_xticklabels(), visible=True)
+                self._check_visible(ax.get_xticklabels(minor=True), visible=True)
+            for ax in [axes[0], axes[1]]:
+                self._check_visible(ax.get_yticklabels(), visible=True)
+            for ax in [axes[2], axes[3]]:
+                self._check_visible(ax.get_yticklabels(), visible=False)
+
+        for ax in axes:
+            df.plot(x="a", y="b", title="title", ax=ax, sharey=True)
+        gs.tight_layout(plt.gcf())
+        _check(axes)
+        tm.close()
+
+        gs, axes = _generate_4_axes_via_gridspec()
+        with tm.assert_produces_warning(UserWarning):
+            axes = df.plot(subplots=True, ax=axes, sharey=True)
+
+        gs.tight_layout(plt.gcf())
+        _check(axes)
+        tm.close()
+
+        gs, axes = _generate_4_axes_via_gridspec()
+        # without sharex, no labels should be touched!
+        for ax in axes:
+            df.plot(x="a", y="b", title="title", ax=ax)
+
+        gs.tight_layout(plt.gcf())
+        for ax in axes:
+            assert len(ax.lines) == 1
+            self._check_visible(ax.get_yticklabels(), visible=True)
+            self._check_visible(ax.get_xticklabels(), visible=True)
+            self._check_visible(ax.get_xticklabels(minor=True), visible=True)
+
+    @td.skip_if_no_scipy
+    def test_memory_leak(self):
+        """Check that every plot type gets properly collected."""
+        results = {}
+        for kind in plotting.PlotAccessor._all_kinds:
+            args = {}
+            if kind in ["hexbin", "scatter", "pie"]:
+                df = DataFrame(
+                    {
+                        "A": np.random.uniform(size=20),
+                        "B": np.random.uniform(size=20),
+                        "C": np.arange(20) + np.random.uniform(size=20),
+                    }
+                )
+                args = {"x": "A", "y": "B"}
+            elif kind == "area":
+                df = tm.makeTimeDataFrame().abs()
+            else:
+                df = tm.makeTimeDataFrame()
+
+            # Use a weakref so we can see if the object gets collected without
+            # also preventing it from being collected
+            results[kind] = weakref.proxy(df.plot(kind=kind, **args))
+
+        # have matplotlib delete all the figures
+        tm.close()
+        # force a garbage collection
+        gc.collect()
+        msg = "weakly-referenced object no longer exists"
+        for result_value in results.values():
+            # check that every plot was collected
+            with pytest.raises(ReferenceError, match=msg):
+                # need to actually access something to get an error
+                result_value.lines
+
+    def test_df_gridspec_patterns(self):
+        # GH 10819
+        from matplotlib import gridspec
+        import matplotlib.pyplot as plt
+
+        ts = Series(np.random.randn(10), index=date_range("1/1/2000", periods=10))
+
+        df = DataFrame(np.random.randn(10, 2), index=ts.index, columns=list("AB"))
+
+        def _get_vertical_grid():
+            gs = gridspec.GridSpec(3, 1)
+            fig = plt.figure()
+            ax1 = fig.add_subplot(gs[:2, :])
+            ax2 = fig.add_subplot(gs[2, :])
+            return ax1, ax2
+
+        def _get_horizontal_grid():
+            gs = gridspec.GridSpec(1, 3)
+            fig = plt.figure()
+            ax1 = fig.add_subplot(gs[:, :2])
+            ax2 = fig.add_subplot(gs[:, 2])
+            return ax1, ax2
+
+        for ax1, ax2 in [_get_vertical_grid(), _get_horizontal_grid()]:
+            ax1 = ts.plot(ax=ax1)
+            assert len(ax1.lines) == 1
+            ax2 = df.plot(ax=ax2)
+            assert len(ax2.lines) == 2
+            for ax in [ax1, ax2]:
+                self._check_visible(ax.get_yticklabels(), visible=True)
+                self._check_visible(ax.get_xticklabels(), visible=True)
+                self._check_visible(ax.get_xticklabels(minor=True), visible=True)
+            tm.close()
+
+        # subplots=True
+        for ax1, ax2 in [_get_vertical_grid(), _get_horizontal_grid()]:
+            axes = df.plot(subplots=True, ax=[ax1, ax2])
+            assert len(ax1.lines) == 1
+            assert len(ax2.lines) == 1
+            for ax in axes:
+                self._check_visible(ax.get_yticklabels(), visible=True)
+                self._check_visible(ax.get_xticklabels(), visible=True)
+                self._check_visible(ax.get_xticklabels(minor=True), visible=True)
+            tm.close()
+
+        # vertical / subplots / sharex=True / sharey=True
+        ax1, ax2 = _get_vertical_grid()
+        with tm.assert_produces_warning(UserWarning):
+            axes = df.plot(subplots=True, ax=[ax1, ax2], sharex=True, sharey=True)
+        assert len(axes[0].lines) == 1
+        assert len(axes[1].lines) == 1
+        for ax in [ax1, ax2]:
+            # yaxis are visible because there is only one column
+            self._check_visible(ax.get_yticklabels(), visible=True)
+        # xaxis of axes0 (top) are hidden
+        self._check_visible(axes[0].get_xticklabels(), visible=False)
+        self._check_visible(axes[0].get_xticklabels(minor=True), visible=False)
+        self._check_visible(axes[1].get_xticklabels(), visible=True)
+        self._check_visible(axes[1].get_xticklabels(minor=True), visible=True)
+        tm.close()
+
+        # horizontal / subplots / sharex=True / sharey=True
+        ax1, ax2 = _get_horizontal_grid()
+        with tm.assert_produces_warning(UserWarning):
+            axes = df.plot(subplots=True, ax=[ax1, ax2], sharex=True, sharey=True)
+        assert len(axes[0].lines) == 1
+        assert len(axes[1].lines) == 1
+        self._check_visible(axes[0].get_yticklabels(), visible=True)
+        # yaxis of axes1 (right) are hidden
+        self._check_visible(axes[1].get_yticklabels(), visible=False)
+        for ax in [ax1, ax2]:
+            # xaxis are visible because there is only one column
+            self._check_visible(ax.get_xticklabels(), visible=True)
+            self._check_visible(ax.get_xticklabels(minor=True), visible=True)
+        tm.close()
+
+        # boxed
+        def _get_boxed_grid():
+            gs = gridspec.GridSpec(3, 3)
+            fig = plt.figure()
+            ax1 = fig.add_subplot(gs[:2, :2])
+            ax2 = fig.add_subplot(gs[:2, 2])
+            ax3 = fig.add_subplot(gs[2, :2])
+            ax4 = fig.add_subplot(gs[2, 2])
+            return ax1, ax2, ax3, ax4
+
+        axes = _get_boxed_grid()
+        df = DataFrame(np.random.randn(10, 4), index=ts.index, columns=list("ABCD"))
+        axes = df.plot(subplots=True, ax=axes)
+        for ax in axes:
+            assert len(ax.lines) == 1
+            # axis are visible because these are not shared
+            self._check_visible(ax.get_yticklabels(), visible=True)
+            self._check_visible(ax.get_xticklabels(), visible=True)
+            self._check_visible(ax.get_xticklabels(minor=True), visible=True)
+        tm.close()
+
+        # subplots / sharex=True / sharey=True
+        axes = _get_boxed_grid()
+        with tm.assert_produces_warning(UserWarning):
+            axes = df.plot(subplots=True, ax=axes, sharex=True, sharey=True)
+        for ax in axes:
+            assert len(ax.lines) == 1
+        for ax in [axes[0], axes[2]]:  # left column
+            self._check_visible(ax.get_yticklabels(), visible=True)
+        for ax in [axes[1], axes[3]]:  # right column
+            self._check_visible(ax.get_yticklabels(), visible=False)
+        for ax in [axes[0], axes[1]]:  # top row
+            self._check_visible(ax.get_xticklabels(), visible=False)
+            self._check_visible(ax.get_xticklabels(minor=True), visible=False)
+        for ax in [axes[2], axes[3]]:  # bottom row
+            self._check_visible(ax.get_xticklabels(), visible=True)
+            self._check_visible(ax.get_xticklabels(minor=True), visible=True)
+        tm.close()
+
+    def test_df_grid_settings(self):
+        # Make sure plot defaults to rcParams['axes.grid'] setting, GH 9792
+        self._check_grid_settings(
+            DataFrame({"a": [1, 2, 3], "b": [2, 3, 4]}),
+            plotting.PlotAccessor._dataframe_kinds,
+            kws={"x": "a", "y": "b"},
+        )
+
+    def test_plain_axes(self):
+        # supplied ax itself is a SubplotAxes, but figure contains also
+        # a plain Axes object (GH11556)
+        fig, ax = self.plt.subplots()
+        fig.add_axes([0.2, 0.2, 0.2, 0.2])
+        Series(np.random.rand(10)).plot(ax=ax)
+
+        # supplied ax itself is a plain Axes, but because the cmap keyword
+        # a new ax is created for the colorbar -> also multiples axes (GH11520)
+        df = DataFrame({"a": np.random.randn(8), "b": np.random.randn(8)})
+        fig = self.plt.figure()
+        ax = fig.add_axes((0, 0, 1, 1))
+        df.plot(kind="scatter", ax=ax, x="a", y="b", c="a", cmap="hsv")
+
+        # other examples
+        fig, ax = self.plt.subplots()
+        from mpl_toolkits.axes_grid1 import make_axes_locatable
+
+        divider = make_axes_locatable(ax)
+        cax = divider.append_axes("right", size="5%", pad=0.05)
+        Series(np.random.rand(10)).plot(ax=ax)
+        Series(np.random.rand(10)).plot(ax=cax)
+
+        fig, ax = self.plt.subplots()
+        from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+
+        iax = inset_axes(ax, width="30%", height=1.0, loc=3)
+        Series(np.random.rand(10)).plot(ax=ax)
+        Series(np.random.rand(10)).plot(ax=iax)
+
+    @pytest.mark.parametrize("method", ["line", "barh", "bar"])
+    def test_secondary_axis_font_size(self, method):
+        # GH: 12565
+        df = (
+            DataFrame(np.random.randn(15, 2), columns=list("AB"))
+            .assign(C=lambda df: df.B.cumsum())
+            .assign(D=lambda df: df.C * 1.1)
+        )
+
+        fontsize = 20
+        sy = ["C", "D"]
+
+        kwargs = {"secondary_y": sy, "fontsize": fontsize, "mark_right": True}
+        ax = getattr(df.plot, method)(**kwargs)
+        self._check_ticks_props(axes=ax.right_ax, ylabelsize=fontsize)
+
+    def test_x_string_values_ticks(self):
+        # Test if string plot index have a fixed xtick position
+        # GH: 7612, GH: 22334
+        df = DataFrame(
+            {
+                "sales": [3, 2, 3],
+                "visits": [20, 42, 28],
+                "day": ["Monday", "Tuesday", "Wednesday"],
+            }
+        )
+        ax = df.plot.area(x="day")
+        ax.set_xlim(-1, 3)
+        xticklabels = [t.get_text() for t in ax.get_xticklabels()]
+        labels_position = dict(zip(xticklabels, ax.get_xticks()))
+        # Testing if the label stayed at the right position
+        assert labels_position["Monday"] == 0.0
+        assert labels_position["Tuesday"] == 1.0
+        assert labels_position["Wednesday"] == 2.0
+
+    def test_x_multiindex_values_ticks(self):
+        # Test if multiindex plot index have a fixed xtick position
+        # GH: 15912
+        index = MultiIndex.from_product([[2012, 2013], [1, 2]])
+        df = DataFrame(np.random.randn(4, 2), columns=["A", "B"], index=index)
+        ax = df.plot()
+        ax.set_xlim(-1, 4)
+        xticklabels = [t.get_text() for t in ax.get_xticklabels()]
+        labels_position = dict(zip(xticklabels, ax.get_xticks()))
+        # Testing if the label stayed at the right position
+        assert labels_position["(2012, 1)"] == 0.0
+        assert labels_position["(2012, 2)"] == 1.0
+        assert labels_position["(2013, 1)"] == 2.0
+        assert labels_position["(2013, 2)"] == 3.0
+
+    @pytest.mark.parametrize("kind", ["line", "area"])
+    def test_xlim_plot_line(self, kind):
+        # test if xlim is set correctly in plot.line and plot.area
+        # GH 27686
+        df = DataFrame([2, 4], index=[1, 2])
+        ax = df.plot(kind=kind)
+        xlims = ax.get_xlim()
+        assert xlims[0] < 1
+        assert xlims[1] > 2
+
+    def test_xlim_plot_line_correctly_in_mixed_plot_type(self):
+        # test if xlim is set correctly when ax contains multiple different kinds
+        # of plots, GH 27686
+        fig, ax = self.plt.subplots()
+
+        indexes = ["k1", "k2", "k3", "k4"]
+        df = DataFrame(
+            {
+                "s1": [1000, 2000, 1500, 2000],
+                "s2": [900, 1400, 2000, 3000],
+                "s3": [1500, 1500, 1600, 1200],
+                "secondary_y": [1, 3, 4, 3],
+            },
+            index=indexes,
+        )
+        df[["s1", "s2", "s3"]].plot.bar(ax=ax, stacked=False)
+        df[["secondary_y"]].plot(ax=ax, secondary_y=True)
+
+        xlims = ax.get_xlim()
+        assert xlims[0] < 0
+        assert xlims[1] > 3
+
+        # make sure axis labels are plotted correctly as well
+        xticklabels = [t.get_text() for t in ax.get_xticklabels()]
+        assert xticklabels == indexes
+
+    def test_plot_no_rows(self):
+        # GH 27758
+        df = DataFrame(columns=["foo"], dtype=int)
+        assert df.empty
+        ax = df.plot()
+        assert len(ax.get_lines()) == 1
+        line = ax.get_lines()[0]
+        assert len(line.get_xdata()) == 0
+        assert len(line.get_ydata()) == 0
+
+    def test_plot_no_numeric_data(self):
+        df = DataFrame(["a", "b", "c"])
+        with pytest.raises(TypeError, match="no numeric data to plot"):
+            df.plot()
+
+    @td.skip_if_no_scipy
+    @pytest.mark.parametrize(
+        "kind", ("line", "bar", "barh", "hist", "kde", "density", "area", "pie")
+    )
+    def test_group_subplot(self, kind):
+        d = {
+            "a": np.arange(10),
+            "b": np.arange(10) + 1,
+            "c": np.arange(10) + 1,
+            "d": np.arange(10),
+            "e": np.arange(10),
+        }
+        df = DataFrame(d)
+
+        axes = df.plot(subplots=[("b", "e"), ("c", "d")], kind=kind)
+        assert len(axes) == 3  # 2 groups + single column a
+
+        expected_labels = (["b", "e"], ["c", "d"], ["a"])
+        for ax, labels in zip(axes, expected_labels):
+            if kind != "pie":
+                self._check_legend_labels(ax, labels=labels)
+            if kind == "line":
+                assert len(ax.lines) == len(labels)
+
+    def test_group_subplot_series_notimplemented(self):
+        ser = Series(range(1))
+        msg = "An iterable subplots for a Series"
+        with pytest.raises(NotImplementedError, match=msg):
+            ser.plot(subplots=[("a",)])
+
+    def test_group_subplot_multiindex_notimplemented(self):
+        df = DataFrame(np.eye(2), columns=MultiIndex.from_tuples([(0, 1), (1, 2)]))
+        msg = "An iterable subplots for a DataFrame with a MultiIndex"
+        with pytest.raises(NotImplementedError, match=msg):
+            df.plot(subplots=[(0, 1)])
+
+    def test_group_subplot_nonunique_cols_notimplemented(self):
+        df = DataFrame(np.eye(2), columns=["a", "a"])
+        msg = "An iterable subplots for a DataFrame with non-unique"
+        with pytest.raises(NotImplementedError, match=msg):
+            df.plot(subplots=[("a",)])
+
+    @pytest.mark.parametrize(
+        "subplots, expected_msg",
+        [
+            (123, "subplots should be a bool or an iterable"),
+            ("a", "each entry should be a list/tuple"),  # iterable of non-iterable
+            ((1,), "each entry should be a list/tuple"),  # iterable of non-iterable
+            (("a",), "each entry should be a list/tuple"),  # iterable of strings
+        ],
+    )
+    def test_group_subplot_bad_input(self, subplots, expected_msg):
+        # Make sure error is raised when subplots is not a properly
+        # formatted iterable. Only iterables of iterables are permitted, and
+        # entries should not be strings.
+        d = {"a": np.arange(10), "b": np.arange(10)}
+        df = DataFrame(d)
+
+        with pytest.raises(ValueError, match=expected_msg):
+            df.plot(subplots=subplots)
+
+    def test_group_subplot_invalid_column_name(self):
+        d = {"a": np.arange(10), "b": np.arange(10)}
+        df = DataFrame(d)
+
+        with pytest.raises(ValueError, match=r"Column label\(s\) \['bad_name'\]"):
+            df.plot(subplots=[("a", "bad_name")])
+
+    def test_group_subplot_duplicated_column(self):
+        d = {"a": np.arange(10), "b": np.arange(10), "c": np.arange(10)}
+        df = DataFrame(d)
+
+        with pytest.raises(ValueError, match="should be in only one subplot"):
+            df.plot(subplots=[("a", "b"), ("a", "c")])
+
+    @pytest.mark.parametrize("kind", ("box", "scatter", "hexbin"))
+    def test_group_subplot_invalid_kind(self, kind):
+        d = {"a": np.arange(10), "b": np.arange(10)}
+        df = DataFrame(d)
+        with pytest.raises(
+            ValueError, match="When subplots is an iterable, kind must be one of"
+        ):
+            df.plot(subplots=[("a", "b")], kind=kind)
+
+    @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_single_plot(
+        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
+        ax = df.plot(kind=kind)
+        assert ax.get_xlabel() == old_label
+        assert ax.get_ylabel() == ""
+
+        # old xlabel will be overridden and assigned ylabel will be used as ylabel
+        ax = df.plot(kind=kind, ylabel=new_label, xlabel=new_label)
+        assert ax.get_ylabel() == str(new_label)
+        assert ax.get_xlabel() == str(new_label)
+
+    @pytest.mark.parametrize(
+        "xlabel, ylabel",
+        [
+            (None, None),
+            ("X Label", None),
+            (None, "Y Label"),
+            ("X Label", "Y Label"),
+        ],
+    )
+    @pytest.mark.parametrize("kind", ["scatter", "hexbin"])
+    def test_xlabel_ylabel_dataframe_plane_plot(self, kind, xlabel, ylabel):
+        # GH 37001
+        xcol = "Type A"
+        ycol = "Type B"
+        df = DataFrame([[1, 2], [2, 5]], columns=[xcol, ycol])
+
+        # default is the labels are column names
+        ax = df.plot(kind=kind, x=xcol, y=ycol, xlabel=xlabel, ylabel=ylabel)
+        assert ax.get_xlabel() == (xcol if xlabel is None else xlabel)
+        assert ax.get_ylabel() == (ycol if ylabel is None else ylabel)
+
+    @pytest.mark.parametrize("secondary_y", (False, True))
+    def test_secondary_y(self, secondary_y):
+        ax_df = DataFrame([0]).plot(
+            secondary_y=secondary_y, ylabel="Y", ylim=(0, 100), yticks=[99]
+        )
+        for ax in ax_df.figure.axes:
+            if ax.yaxis.get_visible():
+                assert ax.get_ylabel() == "Y"
+                assert ax.get_ylim() == (0, 100)
+                assert ax.get_yticks()[0] == 99
+
+
+def _generate_4_axes_via_gridspec():
+    import matplotlib as mpl
+    import matplotlib.gridspec
+    import matplotlib.pyplot as plt
+
+    gs = mpl.gridspec.GridSpec(2, 2)
+    ax_tl = plt.subplot(gs[0, 0])
+    ax_ll = plt.subplot(gs[1, 0])
+    ax_tr = plt.subplot(gs[0, 1])
+    ax_lr = plt.subplot(gs[1, 1])
+
+    return gs, [ax_tl, ax_ll, ax_tr, ax_lr]

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

@@ -0,0 +1,661 @@
+""" Test cases for DataFrame.plot """
+import re
+
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import DataFrame
+import pandas._testing as tm
+from pandas.tests.plotting.common import (
+    TestPlotBase,
+    _check_plot_works,
+)
+from pandas.util.version import Version
+
+
+@td.skip_if_no_mpl
+class TestDataFrameColor(TestPlotBase):
+    @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.randn(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.randn(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.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):
+        import matplotlib.pyplot as plt
+
+        default_colors = self._unpack_cycler(plt.rcParams)
+
+        df = DataFrame(np.random.randn(5, 5))
+        ax = df.plot.bar()
+        self._check_colors(ax.patches[::5], facecolors=default_colors[:5])
+        tm.close()
+
+        custom_colors = "rgcby"
+        ax = df.plot.bar(color=custom_colors)
+        self._check_colors(ax.patches[::5], facecolors=custom_colors)
+        tm.close()
+
+        from matplotlib import cm
+
+        # Test str -> colormap functionality
+        ax = df.plot.bar(colormap="jet")
+        rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, 5)]
+        self._check_colors(ax.patches[::5], facecolors=rgba_colors)
+        tm.close()
+
+        # Test colormap functionality
+        ax = df.plot.bar(colormap=cm.jet)
+        rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, 5)]
+        self._check_colors(ax.patches[::5], facecolors=rgba_colors)
+        tm.close()
+
+        ax = df.loc[:, [0]].plot.bar(color="DodgerBlue")
+        self._check_colors([ax.patches[0]], facecolors=["DodgerBlue"])
+        tm.close()
+
+        ax = df.plot(kind="bar", color="green")
+        self._check_colors(ax.patches[::5], facecolors=["green"] * 5)
+        tm.close()
+
+    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.random((1000, 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.random((1000, 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):
+        import matplotlib.pyplot as plt
+
+        random_array = np.random.random((1000, 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")
+
+        default_colors = self._unpack_cycler(self.plt.rcParams)
+
+        ax = df.plot.scatter(x="a", y="b", c="c")
+        tm.assert_numpy_array_equal(
+            ax.collections[0].get_facecolor()[0],
+            np.array(self.colorconverter.to_rgba(default_colors[0])),
+        )
+
+        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
+        import matplotlib.pyplot as plt
+
+        df = DataFrame({"x": [1, 2, 3], "y": [1, 3, 2], "c": [1, 2, 3]})
+        df["x2"] = df["x"] + 1
+
+        fig, 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):
+        from matplotlib import cm
+
+        custom_colors = "rgcby"
+        df = DataFrame(np.random.randn(5, 5))
+
+        ax = df.plot(color=custom_colors)
+        self._check_colors(ax.get_lines(), linecolors=custom_colors)
+
+        tm.close()
+
+        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()
+
+        tm.close()
+
+        ax = df.plot(colormap="jet")
+        rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, len(df))]
+        self._check_colors(ax.get_lines(), linecolors=rgba_colors)
+        tm.close()
+
+        ax = df.plot(colormap=cm.jet)
+        rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, len(df))]
+        self._check_colors(ax.get_lines(), linecolors=rgba_colors)
+        tm.close()
+
+        # make color a list if plotting one column frame
+        # handles cases like df.plot(color='DodgerBlue')
+        ax = df.loc[:, [0]].plot(color="DodgerBlue")
+        self._check_colors(ax.lines, linecolors=["DodgerBlue"])
+
+        ax = df.plot(color="red")
+        self._check_colors(ax.get_lines(), linecolors=["red"] * 5)
+        tm.close()
+
+        # GH 10299
+        custom_colors = ["#FF0000", "#0000FF", "#FFFF00", "#000000", "#FFFFFF"]
+        ax = df.plot(color=custom_colors)
+        self._check_colors(ax.get_lines(), linecolors=custom_colors)
+        tm.close()
+
+    def test_dont_modify_colors(self):
+        colors = ["r", "g", "b"]
+        DataFrame(np.random.rand(10, 2)).plot(color=colors)
+        assert len(colors) == 3
+
+    def test_line_colors_and_styles_subplots(self):
+        # GH 9894
+        from matplotlib import cm
+
+        default_colors = self._unpack_cycler(self.plt.rcParams)
+
+        df = DataFrame(np.random.randn(5, 5))
+
+        axes = df.plot(subplots=True)
+        for ax, c in zip(axes, list(default_colors)):
+            self._check_colors(ax.get_lines(), linecolors=[c])
+        tm.close()
+
+        # single color char
+        axes = df.plot(subplots=True, color="k")
+        for ax in axes:
+            self._check_colors(ax.get_lines(), linecolors=["k"])
+        tm.close()
+
+        # single color str
+        axes = df.plot(subplots=True, color="green")
+        for ax in axes:
+            self._check_colors(ax.get_lines(), linecolors=["green"])
+        tm.close()
+
+        custom_colors = "rgcby"
+        axes = df.plot(color=custom_colors, subplots=True)
+        for ax, c in zip(axes, list(custom_colors)):
+            self._check_colors(ax.get_lines(), linecolors=[c])
+        tm.close()
+
+        axes = df.plot(color=list(custom_colors), subplots=True)
+        for ax, c in zip(axes, list(custom_colors)):
+            self._check_colors(ax.get_lines(), linecolors=[c])
+        tm.close()
+
+        # 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)):
+            self._check_colors(ax.get_lines(), linecolors=[c])
+        tm.close()
+
+        rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, len(df))]
+        for cmap in ["jet", cm.jet]:
+            axes = df.plot(colormap=cmap, subplots=True)
+            for ax, c in zip(axes, rgba_colors):
+                self._check_colors(ax.get_lines(), linecolors=[c])
+            tm.close()
+
+        # 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)
+        self._check_colors(axes[0].lines, linecolors=["DodgerBlue"])
+
+        # single character style
+        axes = df.plot(style="r", subplots=True)
+        for ax in axes:
+            self._check_colors(ax.get_lines(), linecolors=["r"])
+        tm.close()
+
+        # list of styles
+        styles = list("rgcby")
+        axes = df.plot(style=styles, subplots=True)
+        for ax, c in zip(axes, styles):
+            self._check_colors(ax.get_lines(), linecolors=[c])
+        tm.close()
+
+    def test_area_colors(self):
+        from matplotlib import cm
+        from matplotlib.collections import PolyCollection
+
+        custom_colors = "rgcby"
+        df = DataFrame(np.random.rand(5, 5))
+
+        ax = df.plot.area(color=custom_colors)
+        self._check_colors(ax.get_lines(), linecolors=custom_colors)
+        poly = [o for o in ax.get_children() if isinstance(o, PolyCollection)]
+        self._check_colors(poly, facecolors=custom_colors)
+
+        handles, labels = ax.get_legend_handles_labels()
+        self._check_colors(handles, facecolors=custom_colors)
+
+        for h in handles:
+            assert h.get_alpha() is None
+        tm.close()
+
+        ax = df.plot.area(colormap="jet")
+        jet_colors = [cm.jet(n) for n in np.linspace(0, 1, len(df))]
+        self._check_colors(ax.get_lines(), linecolors=jet_colors)
+        poly = [o for o in ax.get_children() if isinstance(o, PolyCollection)]
+        self._check_colors(poly, facecolors=jet_colors)
+
+        handles, labels = ax.get_legend_handles_labels()
+        self._check_colors(handles, facecolors=jet_colors)
+        for h in handles:
+            assert h.get_alpha() is None
+        tm.close()
+
+        # When stacked=False, alpha is set to 0.5
+        ax = df.plot.area(colormap=cm.jet, stacked=False)
+        self._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]
+        self._check_colors(poly, facecolors=jet_with_alpha)
+
+        handles, labels = ax.get_legend_handles_labels()
+        linecolors = jet_with_alpha
+        self._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 = self._unpack_cycler(self.plt.rcParams)
+
+        df = DataFrame(np.random.randn(5, 5))
+        ax = df.plot.hist()
+        self._check_colors(ax.patches[::10], facecolors=default_colors[:5])
+        tm.close()
+
+        custom_colors = "rgcby"
+        ax = df.plot.hist(color=custom_colors)
+        self._check_colors(ax.patches[::10], facecolors=custom_colors)
+        tm.close()
+
+        from matplotlib import cm
+
+        # Test str -> colormap functionality
+        ax = df.plot.hist(colormap="jet")
+        rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, 5)]
+        self._check_colors(ax.patches[::10], facecolors=rgba_colors)
+        tm.close()
+
+        # Test colormap functionality
+        ax = df.plot.hist(colormap=cm.jet)
+        rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, 5)]
+        self._check_colors(ax.patches[::10], facecolors=rgba_colors)
+        tm.close()
+
+        ax = df.loc[:, [0]].plot.hist(color="DodgerBlue")
+        self._check_colors([ax.patches[0]], facecolors=["DodgerBlue"])
+
+        ax = df.plot(kind="hist", color="green")
+        self._check_colors(ax.patches[::10], facecolors=["green"] * 5)
+        tm.close()
+
+    @td.skip_if_no_scipy
+    def test_kde_colors(self):
+        from matplotlib import cm
+
+        custom_colors = "rgcby"
+        df = DataFrame(np.random.rand(5, 5))
+
+        ax = df.plot.kde(color=custom_colors)
+        self._check_colors(ax.get_lines(), linecolors=custom_colors)
+        tm.close()
+
+        ax = df.plot.kde(colormap="jet")
+        rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, len(df))]
+        self._check_colors(ax.get_lines(), linecolors=rgba_colors)
+        tm.close()
+
+        ax = df.plot.kde(colormap=cm.jet)
+        rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, len(df))]
+        self._check_colors(ax.get_lines(), linecolors=rgba_colors)
+
+    @td.skip_if_no_scipy
+    def test_kde_colors_and_styles_subplots(self):
+        from matplotlib import cm
+
+        default_colors = self._unpack_cycler(self.plt.rcParams)
+
+        df = DataFrame(np.random.randn(5, 5))
+
+        axes = df.plot(kind="kde", subplots=True)
+        for ax, c in zip(axes, list(default_colors)):
+            self._check_colors(ax.get_lines(), linecolors=[c])
+        tm.close()
+
+        # single color char
+        axes = df.plot(kind="kde", color="k", subplots=True)
+        for ax in axes:
+            self._check_colors(ax.get_lines(), linecolors=["k"])
+        tm.close()
+
+        # single color str
+        axes = df.plot(kind="kde", color="red", subplots=True)
+        for ax in axes:
+            self._check_colors(ax.get_lines(), linecolors=["red"])
+        tm.close()
+
+        custom_colors = "rgcby"
+        axes = df.plot(kind="kde", color=custom_colors, subplots=True)
+        for ax, c in zip(axes, list(custom_colors)):
+            self._check_colors(ax.get_lines(), linecolors=[c])
+        tm.close()
+
+        rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, len(df))]
+        for cmap in ["jet", cm.jet]:
+            axes = df.plot(kind="kde", colormap=cmap, subplots=True)
+            for ax, c in zip(axes, rgba_colors):
+                self._check_colors(ax.get_lines(), linecolors=[c])
+            tm.close()
+
+        # 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)
+        self._check_colors(axes[0].lines, linecolors=["DodgerBlue"])
+
+        # single character style
+        axes = df.plot(kind="kde", style="r", subplots=True)
+        for ax in axes:
+            self._check_colors(ax.get_lines(), linecolors=["r"])
+        tm.close()
+
+        # list of styles
+        styles = list("rgcby")
+        axes = df.plot(kind="kde", style=styles, subplots=True)
+        for ax, c in zip(axes, styles):
+            self._check_colors(ax.get_lines(), linecolors=[c])
+        tm.close()
+
+    def test_boxplot_colors(self):
+        def _check_colors(bp, box_c, whiskers_c, medians_c, caps_c="k", fliers_c=None):
+            # TODO: outside this func?
+            if fliers_c is None:
+                fliers_c = "k"
+            self._check_colors(bp["boxes"], linecolors=[box_c] * len(bp["boxes"]))
+            self._check_colors(
+                bp["whiskers"], linecolors=[whiskers_c] * len(bp["whiskers"])
+            )
+            self._check_colors(
+                bp["medians"], linecolors=[medians_c] * len(bp["medians"])
+            )
+            self._check_colors(bp["fliers"], linecolors=[fliers_c] * len(bp["fliers"]))
+            self._check_colors(bp["caps"], linecolors=[caps_c] * len(bp["caps"]))
+
+        default_colors = self._unpack_cycler(self.plt.rcParams)
+
+        df = DataFrame(np.random.randn(5, 5))
+        bp = df.plot.box(return_type="dict")
+        _check_colors(
+            bp,
+            default_colors[0],
+            default_colors[0],
+            default_colors[2],
+            default_colors[0],
+        )
+        tm.close()
+
+        dict_colors = {
+            "boxes": "#572923",
+            "whiskers": "#982042",
+            "medians": "#804823",
+            "caps": "#123456",
+        }
+        bp = df.plot.box(color=dict_colors, sym="r+", return_type="dict")
+        _check_colors(
+            bp,
+            dict_colors["boxes"],
+            dict_colors["whiskers"],
+            dict_colors["medians"],
+            dict_colors["caps"],
+            "r",
+        )
+        tm.close()
+
+        # partial colors
+        dict_colors = {"whiskers": "c", "medians": "m"}
+        bp = df.plot.box(color=dict_colors, return_type="dict")
+        _check_colors(bp, default_colors[0], "c", "m", default_colors[0])
+        tm.close()
+
+        from matplotlib import cm
+
+        # Test str -> colormap functionality
+        bp = df.plot.box(colormap="jet", return_type="dict")
+        jet_colors = [cm.jet(n) for n in np.linspace(0, 1, 3)]
+        _check_colors(bp, jet_colors[0], jet_colors[0], jet_colors[2], jet_colors[0])
+        tm.close()
+
+        # Test colormap functionality
+        bp = df.plot.box(colormap=cm.jet, return_type="dict")
+        _check_colors(bp, jet_colors[0], jet_colors[0], jet_colors[2], jet_colors[0])
+        tm.close()
+
+        # string color is applied to all artists except fliers
+        bp = df.plot.box(color="DodgerBlue", return_type="dict")
+        _check_colors(bp, "DodgerBlue", "DodgerBlue", "DodgerBlue", "DodgerBlue")
+
+        # tuple is also applied to all artists except fliers
+        bp = df.plot.box(color=(0, 1, 0), sym="#123456", return_type="dict")
+        _check_colors(bp, (0, 1, 0), (0, 1, 0), (0, 1, 0), (0, 1, 0), "#123456")
+
+        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
+        import matplotlib.pyplot as plt
+
+        colors = list("rgbk")
+        plt.rcParams["axes.prop_cycle"] = cycler.cycler("color", colors)
+
+        df = DataFrame(np.random.randn(5, 3))
+        ax = df.plot()
+
+        expected = self._unpack_cycler(plt.rcParams)[:3]
+        self._check_colors(ax.get_lines(), linecolors=expected)
+
+    def test_no_color_bar(self):
+        df = DataFrame(
+            {
+                "A": np.random.uniform(size=20),
+                "B": np.random.uniform(size=20),
+                "C": np.arange(20) + np.random.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.uniform(size=20),
+                "B": np.random.uniform(size=20),
+                "C": np.arange(20) + np.random.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):
+        import matplotlib as mpl
+
+        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):
+        import matplotlib as mpl
+
+        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.
+        import matplotlib as mpl
+
+        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.randn(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")

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

@@ -0,0 +1,73 @@
+""" Test cases for DataFrame.plot """
+
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import DataFrame
+from pandas.tests.plotting.common import TestPlotBase
+
+
+@td.skip_if_no_mpl
+class TestDataFramePlotsGroupby(TestPlotBase):
+    def _assert_ytickslabels_visibility(self, axes, expected):
+        for ax, exp in zip(axes, expected):
+            self._check_visible(ax.get_yticklabels(), visible=exp)
+
+    def _assert_xtickslabels_visibility(self, axes, expected):
+        for ax, exp in zip(axes, expected):
+            self._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)