from __future__ import annotations
|
|
from abc import (
|
ABC,
|
abstractmethod,
|
)
|
from collections.abc import (
|
Hashable,
|
Iterable,
|
Iterator,
|
Sequence,
|
)
|
from typing import (
|
TYPE_CHECKING,
|
Any,
|
Literal,
|
cast,
|
final,
|
)
|
import warnings
|
|
import matplotlib as mpl
|
import numpy as np
|
|
from pandas._libs import lib
|
from pandas.errors import AbstractMethodError
|
from pandas.util._decorators import cache_readonly
|
from pandas.util._exceptions import find_stack_level
|
|
from pandas.core.dtypes.common import (
|
is_any_real_numeric_dtype,
|
is_bool,
|
is_float,
|
is_float_dtype,
|
is_hashable,
|
is_integer,
|
is_integer_dtype,
|
is_iterator,
|
is_list_like,
|
is_number,
|
is_numeric_dtype,
|
)
|
from pandas.core.dtypes.dtypes import (
|
CategoricalDtype,
|
ExtensionDtype,
|
)
|
from pandas.core.dtypes.generic import (
|
ABCDataFrame,
|
ABCDatetimeIndex,
|
ABCIndex,
|
ABCMultiIndex,
|
ABCPeriodIndex,
|
ABCSeries,
|
)
|
from pandas.core.dtypes.missing import isna
|
|
import pandas.core.common as com
|
from pandas.core.frame import DataFrame
|
from pandas.util.version import Version
|
|
from pandas.io.formats.printing import pprint_thing
|
from pandas.plotting._matplotlib import tools
|
from pandas.plotting._matplotlib.converter import register_pandas_matplotlib_converters
|
from pandas.plotting._matplotlib.groupby import reconstruct_data_with_by
|
from pandas.plotting._matplotlib.misc import unpack_single_str_list
|
from pandas.plotting._matplotlib.style import get_standard_colors
|
from pandas.plotting._matplotlib.timeseries import (
|
decorate_axes,
|
format_dateaxis,
|
maybe_convert_index,
|
maybe_resample,
|
use_dynamic_x,
|
)
|
from pandas.plotting._matplotlib.tools import (
|
create_subplots,
|
flatten_axes,
|
format_date_labels,
|
get_all_lines,
|
get_xlim,
|
handle_shared_axes,
|
)
|
|
if TYPE_CHECKING:
|
from matplotlib.artist import Artist
|
from matplotlib.axes import Axes
|
from matplotlib.axis import Axis
|
from matplotlib.figure import Figure
|
|
from pandas._typing import (
|
IndexLabel,
|
NDFrameT,
|
PlottingOrientation,
|
npt,
|
)
|
|
from pandas import Series
|
|
|
def _color_in_style(style: str) -> bool:
|
"""
|
Check if there is a color letter in the style string.
|
"""
|
from matplotlib.colors import BASE_COLORS
|
|
return not set(BASE_COLORS).isdisjoint(style)
|
|
|
class MPLPlot(ABC):
|
"""
|
Base class for assembling a pandas plot using matplotlib
|
|
Parameters
|
----------
|
data :
|
|
"""
|
|
@property
|
@abstractmethod
|
def _kind(self) -> str:
|
"""Specify kind str. Must be overridden in child class"""
|
raise NotImplementedError
|
|
_layout_type = "vertical"
|
_default_rot = 0
|
|
@property
|
def orientation(self) -> str | None:
|
return None
|
|
data: DataFrame
|
|
def __init__(
|
self,
|
data,
|
kind=None,
|
by: IndexLabel | None = None,
|
subplots: bool | Sequence[Sequence[str]] = False,
|
sharex: bool | None = None,
|
sharey: bool = False,
|
use_index: bool = True,
|
figsize: tuple[float, float] | None = None,
|
grid=None,
|
legend: bool | str = True,
|
rot=None,
|
ax=None,
|
fig=None,
|
title=None,
|
xlim=None,
|
ylim=None,
|
xticks=None,
|
yticks=None,
|
xlabel: Hashable | None = None,
|
ylabel: Hashable | None = None,
|
fontsize: int | None = None,
|
secondary_y: bool | tuple | list | np.ndarray = False,
|
colormap=None,
|
table: bool = False,
|
layout=None,
|
include_bool: bool = False,
|
column: IndexLabel | None = None,
|
*,
|
logx: bool | None | Literal["sym"] = False,
|
logy: bool | None | Literal["sym"] = False,
|
loglog: bool | None | Literal["sym"] = False,
|
mark_right: bool = True,
|
stacked: bool = False,
|
label: Hashable | None = None,
|
style=None,
|
**kwds,
|
) -> None:
|
import matplotlib.pyplot as plt
|
|
# if users assign an empty list or tuple, raise `ValueError`
|
# similar to current `df.box` and `df.hist` APIs.
|
if by in ([], ()):
|
raise ValueError("No group keys passed!")
|
self.by = com.maybe_make_list(by)
|
|
# Assign the rest of columns into self.columns if by is explicitly defined
|
# while column is not, only need `columns` in hist/box plot when it's DF
|
# TODO: Might deprecate `column` argument in future PR (#28373)
|
if isinstance(data, DataFrame):
|
if column:
|
self.columns = com.maybe_make_list(column)
|
elif self.by is None:
|
self.columns = [
|
col for col in data.columns if is_numeric_dtype(data[col])
|
]
|
else:
|
self.columns = [
|
col
|
for col in data.columns
|
if col not in self.by and is_numeric_dtype(data[col])
|
]
|
|
# For `hist` plot, need to get grouped original data before `self.data` is
|
# updated later
|
if self.by is not None and self._kind == "hist":
|
self._grouped = data.groupby(unpack_single_str_list(self.by))
|
|
self.kind = kind
|
|
self.subplots = type(self)._validate_subplots_kwarg(
|
subplots, data, kind=self._kind
|
)
|
|
self.sharex = type(self)._validate_sharex(sharex, ax, by)
|
self.sharey = sharey
|
self.figsize = figsize
|
self.layout = layout
|
|
self.xticks = xticks
|
self.yticks = yticks
|
self.xlim = xlim
|
self.ylim = ylim
|
self.title = title
|
self.use_index = use_index
|
self.xlabel = xlabel
|
self.ylabel = ylabel
|
|
self.fontsize = fontsize
|
|
if rot is not None:
|
self.rot = rot
|
# need to know for format_date_labels since it's rotated to 30 by
|
# default
|
self._rot_set = True
|
else:
|
self._rot_set = False
|
self.rot = self._default_rot
|
|
if grid is None:
|
grid = False if secondary_y else plt.rcParams["axes.grid"]
|
|
self.grid = grid
|
self.legend = legend
|
self.legend_handles: list[Artist] = []
|
self.legend_labels: list[Hashable] = []
|
|
self.logx = type(self)._validate_log_kwd("logx", logx)
|
self.logy = type(self)._validate_log_kwd("logy", logy)
|
self.loglog = type(self)._validate_log_kwd("loglog", loglog)
|
self.label = label
|
self.style = style
|
self.mark_right = mark_right
|
self.stacked = stacked
|
|
# ax may be an Axes object or (if self.subplots) an ndarray of
|
# Axes objects
|
self.ax = ax
|
# TODO: deprecate fig keyword as it is ignored, not passed in tests
|
# as of 2023-11-05
|
|
# parse errorbar input if given
|
xerr = kwds.pop("xerr", None)
|
yerr = kwds.pop("yerr", None)
|
nseries = self._get_nseries(data)
|
xerr, data = type(self)._parse_errorbars("xerr", xerr, data, nseries)
|
yerr, data = type(self)._parse_errorbars("yerr", yerr, data, nseries)
|
self.errors = {"xerr": xerr, "yerr": yerr}
|
self.data = data
|
|
if not isinstance(secondary_y, (bool, tuple, list, np.ndarray, ABCIndex)):
|
secondary_y = [secondary_y]
|
self.secondary_y = secondary_y
|
|
# ugly TypeError if user passes matplotlib's `cmap` name.
|
# Probably better to accept either.
|
if "cmap" in kwds and colormap:
|
raise TypeError("Only specify one of `cmap` and `colormap`.")
|
if "cmap" in kwds:
|
self.colormap = kwds.pop("cmap")
|
else:
|
self.colormap = colormap
|
|
self.table = table
|
self.include_bool = include_bool
|
|
self.kwds = kwds
|
|
color = kwds.pop("color", lib.no_default)
|
self.color = self._validate_color_args(color, self.colormap)
|
assert "color" not in self.kwds
|
|
self.data = self._ensure_frame(self.data)
|
|
@final
|
@staticmethod
|
def _validate_sharex(sharex: bool | None, ax, by) -> bool:
|
if sharex is None:
|
# if by is defined, subplots are used and sharex should be False
|
if ax is None and by is None: # pylint: disable=simplifiable-if-statement
|
sharex = True
|
else:
|
# if we get an axis, the users should do the visibility
|
# setting...
|
sharex = False
|
elif not is_bool(sharex):
|
raise TypeError("sharex must be a bool or None")
|
return bool(sharex)
|
|
@classmethod
|
def _validate_log_kwd(
|
cls,
|
kwd: str,
|
value: bool | None | Literal["sym"],
|
) -> bool | None | Literal["sym"]:
|
if (
|
value is None
|
or isinstance(value, bool)
|
or (isinstance(value, str) and value == "sym")
|
):
|
return value
|
raise ValueError(
|
f"keyword '{kwd}' should be bool, None, or 'sym', not '{value}'"
|
)
|
|
@final
|
@staticmethod
|
def _validate_subplots_kwarg(
|
subplots: bool | Sequence[Sequence[str]], data: Series | DataFrame, kind: str
|
) -> bool | list[tuple[int, ...]]:
|
"""
|
Validate the subplots parameter
|
|
- check type and content
|
- check for duplicate columns
|
- check for invalid column names
|
- convert column names into indices
|
- add missing columns in a group of their own
|
See comments in code below for more details.
|
|
Parameters
|
----------
|
subplots : subplots parameters as passed to PlotAccessor
|
|
Returns
|
-------
|
validated subplots : a bool or a list of tuples of column indices. Columns
|
in the same tuple will be grouped together in the resulting plot.
|
"""
|
|
if isinstance(subplots, bool):
|
return subplots
|
elif not isinstance(subplots, Iterable):
|
raise ValueError("subplots should be a bool or an iterable")
|
|
supported_kinds = (
|
"line",
|
"bar",
|
"barh",
|
"hist",
|
"kde",
|
"density",
|
"area",
|
"pie",
|
)
|
if kind not in supported_kinds:
|
raise ValueError(
|
"When subplots is an iterable, kind must be "
|
f"one of {', '.join(supported_kinds)}. Got {kind}."
|
)
|
|
if isinstance(data, ABCSeries):
|
raise NotImplementedError(
|
"An iterable subplots for a Series is not supported."
|
)
|
|
columns = data.columns
|
if isinstance(columns, ABCMultiIndex):
|
raise NotImplementedError(
|
"An iterable subplots for a DataFrame with a MultiIndex column "
|
"is not supported."
|
)
|
|
if columns.nunique() != len(columns):
|
raise NotImplementedError(
|
"An iterable subplots for a DataFrame with non-unique column "
|
"labels is not supported."
|
)
|
|
# subplots is a list of tuples where each tuple is a group of
|
# columns to be grouped together (one ax per group).
|
# we consolidate the subplots list such that:
|
# - the tuples contain indices instead of column names
|
# - the columns that aren't yet in the list are added in a group
|
# of their own.
|
# For example with columns from a to g, and
|
# subplots = [(a, c), (b, f, e)],
|
# we end up with [(ai, ci), (bi, fi, ei), (di,), (gi,)]
|
# This way, we can handle self.subplots in a homogeneous manner
|
# later.
|
# TODO: also accept indices instead of just names?
|
|
out = []
|
seen_columns: set[Hashable] = set()
|
for group in subplots:
|
if not is_list_like(group):
|
raise ValueError(
|
"When subplots is an iterable, each entry "
|
"should be a list/tuple of column names."
|
)
|
idx_locs = columns.get_indexer_for(group)
|
if (idx_locs == -1).any():
|
bad_labels = np.extract(idx_locs == -1, group)
|
raise ValueError(
|
f"Column label(s) {list(bad_labels)} not found in the DataFrame."
|
)
|
unique_columns = set(group)
|
duplicates = seen_columns.intersection(unique_columns)
|
if duplicates:
|
raise ValueError(
|
"Each column should be in only one subplot. "
|
f"Columns {duplicates} were found in multiple subplots."
|
)
|
seen_columns = seen_columns.union(unique_columns)
|
out.append(tuple(idx_locs))
|
|
unseen_columns = columns.difference(seen_columns)
|
for column in unseen_columns:
|
idx_loc = columns.get_loc(column)
|
out.append((idx_loc,))
|
return out
|
|
def _validate_color_args(self, color, colormap):
|
if color is lib.no_default:
|
# It was not provided by the user
|
if "colors" in self.kwds and colormap is not None:
|
warnings.warn(
|
"'color' and 'colormap' cannot be used simultaneously. "
|
"Using 'color'",
|
stacklevel=find_stack_level(),
|
)
|
return None
|
if self.nseries == 1 and color is not None and not is_list_like(color):
|
# support series.plot(color='green')
|
color = [color]
|
|
if isinstance(color, tuple) and self.nseries == 1 and len(color) in (3, 4):
|
# support RGB and RGBA tuples in series plot
|
color = [color]
|
|
if colormap is not None:
|
warnings.warn(
|
"'color' and 'colormap' cannot be used simultaneously. Using 'color'",
|
stacklevel=find_stack_level(),
|
)
|
|
if self.style is not None:
|
if is_list_like(self.style):
|
styles = self.style
|
else:
|
styles = [self.style]
|
# need only a single match
|
for s in styles:
|
if _color_in_style(s):
|
raise ValueError(
|
"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"
|
)
|
return color
|
|
@final
|
@staticmethod
|
def _iter_data(
|
data: DataFrame | dict[Hashable, Series | DataFrame]
|
) -> Iterator[tuple[Hashable, np.ndarray]]:
|
for col, values in data.items():
|
# This was originally written to use values.values before EAs
|
# were implemented; adding np.asarray(...) to keep consistent
|
# typing.
|
yield col, np.asarray(values.values)
|
|
def _get_nseries(self, data: Series | DataFrame) -> int:
|
# When `by` is explicitly assigned, grouped data size will be defined, and
|
# this will determine number of subplots to have, aka `self.nseries`
|
if data.ndim == 1:
|
return 1
|
elif self.by is not None and self._kind == "hist":
|
return len(self._grouped)
|
elif self.by is not None and self._kind == "box":
|
return len(self.columns)
|
else:
|
return data.shape[1]
|
|
@final
|
@property
|
def nseries(self) -> int:
|
return self._get_nseries(self.data)
|
|
@final
|
def draw(self) -> None:
|
self.plt.draw_if_interactive()
|
|
@final
|
def generate(self) -> None:
|
self._compute_plot_data()
|
fig = self.fig
|
self._make_plot(fig)
|
self._add_table()
|
self._make_legend()
|
self._adorn_subplots(fig)
|
|
for ax in self.axes:
|
self._post_plot_logic_common(ax)
|
self._post_plot_logic(ax, self.data)
|
|
@final
|
@staticmethod
|
def _has_plotted_object(ax: Axes) -> bool:
|
"""check whether ax has data"""
|
return len(ax.lines) != 0 or len(ax.artists) != 0 or len(ax.containers) != 0
|
|
@final
|
def _maybe_right_yaxis(self, ax: Axes, axes_num: int) -> Axes:
|
if not self.on_right(axes_num):
|
# secondary axes may be passed via ax kw
|
return self._get_ax_layer(ax)
|
|
if hasattr(ax, "right_ax"):
|
# if it has right_ax property, ``ax`` must be left axes
|
return ax.right_ax
|
elif hasattr(ax, "left_ax"):
|
# if it has left_ax property, ``ax`` must be right axes
|
return ax
|
else:
|
# otherwise, create twin axes
|
orig_ax, new_ax = ax, ax.twinx()
|
# TODO: use Matplotlib public API when available
|
new_ax._get_lines = orig_ax._get_lines # type: ignore[attr-defined]
|
# TODO #54485
|
new_ax._get_patches_for_fill = ( # type: ignore[attr-defined]
|
orig_ax._get_patches_for_fill # type: ignore[attr-defined]
|
)
|
# TODO #54485
|
orig_ax.right_ax, new_ax.left_ax = ( # type: ignore[attr-defined]
|
new_ax,
|
orig_ax,
|
)
|
|
if not self._has_plotted_object(orig_ax): # no data on left y
|
orig_ax.get_yaxis().set_visible(False)
|
|
if self.logy is True or self.loglog is True:
|
new_ax.set_yscale("log")
|
elif self.logy == "sym" or self.loglog == "sym":
|
new_ax.set_yscale("symlog")
|
return new_ax
|
|
@final
|
@cache_readonly
|
def fig(self) -> Figure:
|
return self._axes_and_fig[1]
|
|
@final
|
@cache_readonly
|
# TODO: can we annotate this as both a Sequence[Axes] and ndarray[object]?
|
def axes(self) -> Sequence[Axes]:
|
return self._axes_and_fig[0]
|
|
@final
|
@cache_readonly
|
def _axes_and_fig(self) -> tuple[Sequence[Axes], Figure]:
|
if self.subplots:
|
naxes = (
|
self.nseries if isinstance(self.subplots, bool) else len(self.subplots)
|
)
|
fig, axes = create_subplots(
|
naxes=naxes,
|
sharex=self.sharex,
|
sharey=self.sharey,
|
figsize=self.figsize,
|
ax=self.ax,
|
layout=self.layout,
|
layout_type=self._layout_type,
|
)
|
elif self.ax is None:
|
fig = self.plt.figure(figsize=self.figsize)
|
axes = fig.add_subplot(111)
|
else:
|
fig = self.ax.get_figure()
|
if self.figsize is not None:
|
fig.set_size_inches(self.figsize)
|
axes = self.ax
|
|
axes = flatten_axes(axes)
|
|
if self.logx is True or self.loglog is True:
|
[a.set_xscale("log") for a in axes]
|
elif self.logx == "sym" or self.loglog == "sym":
|
[a.set_xscale("symlog") for a in axes]
|
|
if self.logy is True or self.loglog is True:
|
[a.set_yscale("log") for a in axes]
|
elif self.logy == "sym" or self.loglog == "sym":
|
[a.set_yscale("symlog") for a in axes]
|
|
axes_seq = cast(Sequence["Axes"], axes)
|
return axes_seq, fig
|
|
@property
|
def result(self):
|
"""
|
Return result axes
|
"""
|
if self.subplots:
|
if self.layout is not None and not is_list_like(self.ax):
|
# error: "Sequence[Any]" has no attribute "reshape"
|
return self.axes.reshape(*self.layout) # type: ignore[attr-defined]
|
else:
|
return self.axes
|
else:
|
sec_true = isinstance(self.secondary_y, bool) and self.secondary_y
|
# error: Argument 1 to "len" has incompatible type "Union[bool,
|
# Tuple[Any, ...], List[Any], ndarray[Any, Any]]"; expected "Sized"
|
all_sec = (
|
is_list_like(self.secondary_y)
|
and len(self.secondary_y) == self.nseries # type: ignore[arg-type]
|
)
|
if sec_true or all_sec:
|
# if all data is plotted on secondary, return right axes
|
return self._get_ax_layer(self.axes[0], primary=False)
|
else:
|
return self.axes[0]
|
|
@final
|
@staticmethod
|
def _convert_to_ndarray(data):
|
# GH31357: categorical columns are processed separately
|
if isinstance(data.dtype, CategoricalDtype):
|
return data
|
|
# GH32073: cast to float if values contain nulled integers
|
if (is_integer_dtype(data.dtype) or is_float_dtype(data.dtype)) and isinstance(
|
data.dtype, ExtensionDtype
|
):
|
return data.to_numpy(dtype="float", na_value=np.nan)
|
|
# GH25587: cast ExtensionArray of pandas (IntegerArray, etc.) to
|
# np.ndarray before plot.
|
if len(data) > 0:
|
return np.asarray(data)
|
|
return data
|
|
@final
|
def _ensure_frame(self, data) -> DataFrame:
|
if isinstance(data, ABCSeries):
|
label = self.label
|
if label is None and data.name is None:
|
label = ""
|
if label is None:
|
# We'll end up with columns of [0] instead of [None]
|
data = data.to_frame()
|
else:
|
data = data.to_frame(name=label)
|
elif self._kind in ("hist", "box"):
|
cols = self.columns if self.by is None else self.columns + self.by
|
data = data.loc[:, cols]
|
return data
|
|
@final
|
def _compute_plot_data(self) -> None:
|
data = self.data
|
|
# GH15079 reconstruct data if by is defined
|
if self.by is not None:
|
self.subplots = True
|
data = reconstruct_data_with_by(self.data, by=self.by, cols=self.columns)
|
|
# GH16953, infer_objects is needed as fallback, for ``Series``
|
# with ``dtype == object``
|
data = data.infer_objects(copy=False)
|
include_type = [np.number, "datetime", "datetimetz", "timedelta"]
|
|
# GH23719, allow plotting boolean
|
if self.include_bool is True:
|
include_type.append(np.bool_)
|
|
# GH22799, exclude datetime-like type for boxplot
|
exclude_type = None
|
if self._kind == "box":
|
# TODO: change after solving issue 27881
|
include_type = [np.number]
|
exclude_type = ["timedelta"]
|
|
# GH 18755, include object and category type for scatter plot
|
if self._kind == "scatter":
|
include_type.extend(["object", "category", "string"])
|
|
numeric_data = data.select_dtypes(include=include_type, exclude=exclude_type)
|
|
is_empty = numeric_data.shape[-1] == 0
|
# no non-numeric frames or series allowed
|
if is_empty:
|
raise TypeError("no numeric data to plot")
|
|
self.data = numeric_data.apply(type(self)._convert_to_ndarray)
|
|
def _make_plot(self, fig: Figure) -> None:
|
raise AbstractMethodError(self)
|
|
@final
|
def _add_table(self) -> None:
|
if self.table is False:
|
return
|
elif self.table is True:
|
data = self.data.transpose()
|
else:
|
data = self.table
|
ax = self._get_ax(0)
|
tools.table(ax, data)
|
|
@final
|
def _post_plot_logic_common(self, ax: Axes) -> None:
|
"""Common post process for each axes"""
|
if self.orientation == "vertical" or self.orientation is None:
|
type(self)._apply_axis_properties(
|
ax.xaxis, rot=self.rot, fontsize=self.fontsize
|
)
|
type(self)._apply_axis_properties(ax.yaxis, fontsize=self.fontsize)
|
|
if hasattr(ax, "right_ax"):
|
type(self)._apply_axis_properties(
|
ax.right_ax.yaxis, fontsize=self.fontsize
|
)
|
|
elif self.orientation == "horizontal":
|
type(self)._apply_axis_properties(
|
ax.yaxis, rot=self.rot, fontsize=self.fontsize
|
)
|
type(self)._apply_axis_properties(ax.xaxis, fontsize=self.fontsize)
|
|
if hasattr(ax, "right_ax"):
|
type(self)._apply_axis_properties(
|
ax.right_ax.yaxis, fontsize=self.fontsize
|
)
|
else: # pragma no cover
|
raise ValueError
|
|
@abstractmethod
|
def _post_plot_logic(self, ax: Axes, data) -> None:
|
"""Post process for each axes. Overridden in child classes"""
|
|
@final
|
def _adorn_subplots(self, fig: Figure) -> None:
|
"""Common post process unrelated to data"""
|
if len(self.axes) > 0:
|
all_axes = self._get_subplots(fig)
|
nrows, ncols = self._get_axes_layout(fig)
|
handle_shared_axes(
|
axarr=all_axes,
|
nplots=len(all_axes),
|
naxes=nrows * ncols,
|
nrows=nrows,
|
ncols=ncols,
|
sharex=self.sharex,
|
sharey=self.sharey,
|
)
|
|
for ax in self.axes:
|
ax = getattr(ax, "right_ax", ax)
|
if self.yticks is not None:
|
ax.set_yticks(self.yticks)
|
|
if self.xticks is not None:
|
ax.set_xticks(self.xticks)
|
|
if self.ylim is not None:
|
ax.set_ylim(self.ylim)
|
|
if self.xlim is not None:
|
ax.set_xlim(self.xlim)
|
|
# GH9093, currently Pandas does not show ylabel, so if users provide
|
# ylabel will set it as ylabel in the plot.
|
if self.ylabel is not None:
|
ax.set_ylabel(pprint_thing(self.ylabel))
|
|
ax.grid(self.grid)
|
|
if self.title:
|
if self.subplots:
|
if is_list_like(self.title):
|
if len(self.title) != self.nseries:
|
raise ValueError(
|
"The length of `title` must equal the number "
|
"of columns if using `title` of type `list` "
|
"and `subplots=True`.\n"
|
f"length of title = {len(self.title)}\n"
|
f"number of columns = {self.nseries}"
|
)
|
|
for ax, title in zip(self.axes, self.title):
|
ax.set_title(title)
|
else:
|
fig.suptitle(self.title)
|
else:
|
if is_list_like(self.title):
|
msg = (
|
"Using `title` of type `list` is not supported "
|
"unless `subplots=True` is passed"
|
)
|
raise ValueError(msg)
|
self.axes[0].set_title(self.title)
|
|
@final
|
@staticmethod
|
def _apply_axis_properties(
|
axis: Axis, rot=None, fontsize: int | None = None
|
) -> None:
|
"""
|
Tick creation within matplotlib is reasonably expensive and is
|
internally deferred until accessed as Ticks are created/destroyed
|
multiple times per draw. It's therefore beneficial for us to avoid
|
accessing unless we will act on the Tick.
|
"""
|
if rot is not None or fontsize is not None:
|
# rot=0 is a valid setting, hence the explicit None check
|
labels = axis.get_majorticklabels() + axis.get_minorticklabels()
|
for label in labels:
|
if rot is not None:
|
label.set_rotation(rot)
|
if fontsize is not None:
|
label.set_fontsize(fontsize)
|
|
@final
|
@property
|
def legend_title(self) -> str | None:
|
if not isinstance(self.data.columns, ABCMultiIndex):
|
name = self.data.columns.name
|
if name is not None:
|
name = pprint_thing(name)
|
return name
|
else:
|
stringified = map(pprint_thing, self.data.columns.names)
|
return ",".join(stringified)
|
|
@final
|
def _mark_right_label(self, label: str, index: int) -> str:
|
"""
|
Append ``(right)`` to the label of a line if it's plotted on the right axis.
|
|
Note that ``(right)`` is only appended when ``subplots=False``.
|
"""
|
if not self.subplots and self.mark_right and self.on_right(index):
|
label += " (right)"
|
return label
|
|
@final
|
def _append_legend_handles_labels(self, handle: Artist, label: str) -> None:
|
"""
|
Append current handle and label to ``legend_handles`` and ``legend_labels``.
|
|
These will be used to make the legend.
|
"""
|
self.legend_handles.append(handle)
|
self.legend_labels.append(label)
|
|
def _make_legend(self) -> None:
|
ax, leg = self._get_ax_legend(self.axes[0])
|
|
handles = []
|
labels = []
|
title = ""
|
|
if not self.subplots:
|
if leg is not None:
|
title = leg.get_title().get_text()
|
# Replace leg.legend_handles because it misses marker info
|
if Version(mpl.__version__) < Version("3.7"):
|
handles = leg.legendHandles
|
else:
|
handles = leg.legend_handles
|
labels = [x.get_text() for x in leg.get_texts()]
|
|
if self.legend:
|
if self.legend == "reverse":
|
handles += reversed(self.legend_handles)
|
labels += reversed(self.legend_labels)
|
else:
|
handles += self.legend_handles
|
labels += self.legend_labels
|
|
if self.legend_title is not None:
|
title = self.legend_title
|
|
if len(handles) > 0:
|
ax.legend(handles, labels, loc="best", title=title)
|
|
elif self.subplots and self.legend:
|
for ax in self.axes:
|
if ax.get_visible():
|
with warnings.catch_warnings():
|
warnings.filterwarnings(
|
"ignore",
|
"No artists with labels found to put in legend.",
|
UserWarning,
|
)
|
ax.legend(loc="best")
|
|
@final
|
@staticmethod
|
def _get_ax_legend(ax: Axes):
|
"""
|
Take in axes and return ax and legend under different scenarios
|
"""
|
leg = ax.get_legend()
|
|
other_ax = getattr(ax, "left_ax", None) or getattr(ax, "right_ax", None)
|
other_leg = None
|
if other_ax is not None:
|
other_leg = other_ax.get_legend()
|
if leg is None and other_leg is not None:
|
leg = other_leg
|
ax = other_ax
|
return ax, leg
|
|
@final
|
@cache_readonly
|
def plt(self):
|
import matplotlib.pyplot as plt
|
|
return plt
|
|
_need_to_set_index = False
|
|
@final
|
def _get_xticks(self):
|
index = self.data.index
|
is_datetype = index.inferred_type in ("datetime", "date", "datetime64", "time")
|
|
# TODO: be stricter about x?
|
x: list[int] | np.ndarray
|
if self.use_index:
|
if isinstance(index, ABCPeriodIndex):
|
# test_mixed_freq_irreg_period
|
x = index.to_timestamp()._mpl_repr()
|
# TODO: why do we need to do to_timestamp() here but not other
|
# places where we call mpl_repr?
|
elif is_any_real_numeric_dtype(index.dtype):
|
# Matplotlib supports numeric values or datetime objects as
|
# xaxis values. Taking LBYL approach here, by the time
|
# matplotlib raises exception when using non numeric/datetime
|
# values for xaxis, several actions are already taken by plt.
|
x = index._mpl_repr()
|
elif isinstance(index, ABCDatetimeIndex) or is_datetype:
|
x = index._mpl_repr()
|
else:
|
self._need_to_set_index = True
|
x = list(range(len(index)))
|
else:
|
x = list(range(len(index)))
|
|
return x
|
|
@classmethod
|
@register_pandas_matplotlib_converters
|
def _plot(
|
cls, ax: Axes, x, y: np.ndarray, style=None, is_errorbar: bool = False, **kwds
|
):
|
mask = isna(y)
|
if mask.any():
|
y = np.ma.array(y)
|
y = np.ma.masked_where(mask, y)
|
|
if isinstance(x, ABCIndex):
|
x = x._mpl_repr()
|
|
if is_errorbar:
|
if "xerr" in kwds:
|
kwds["xerr"] = np.array(kwds.get("xerr"))
|
if "yerr" in kwds:
|
kwds["yerr"] = np.array(kwds.get("yerr"))
|
return ax.errorbar(x, y, **kwds)
|
else:
|
# prevent style kwarg from going to errorbar, where it is unsupported
|
args = (x, y, style) if style is not None else (x, y)
|
return ax.plot(*args, **kwds)
|
|
def _get_custom_index_name(self):
|
"""Specify whether xlabel/ylabel should be used to override index name"""
|
return self.xlabel
|
|
@final
|
def _get_index_name(self) -> str | None:
|
if isinstance(self.data.index, ABCMultiIndex):
|
name = self.data.index.names
|
if com.any_not_none(*name):
|
name = ",".join([pprint_thing(x) for x in name])
|
else:
|
name = None
|
else:
|
name = self.data.index.name
|
if name is not None:
|
name = pprint_thing(name)
|
|
# GH 45145, override the default axis label if one is provided.
|
index_name = self._get_custom_index_name()
|
if index_name is not None:
|
name = pprint_thing(index_name)
|
|
return name
|
|
@final
|
@classmethod
|
def _get_ax_layer(cls, ax, primary: bool = True):
|
"""get left (primary) or right (secondary) axes"""
|
if primary:
|
return getattr(ax, "left_ax", ax)
|
else:
|
return getattr(ax, "right_ax", ax)
|
|
@final
|
def _col_idx_to_axis_idx(self, col_idx: int) -> int:
|
"""Return the index of the axis where the column at col_idx should be plotted"""
|
if isinstance(self.subplots, list):
|
# Subplots is a list: some columns will be grouped together in the same ax
|
return next(
|
group_idx
|
for (group_idx, group) in enumerate(self.subplots)
|
if col_idx in group
|
)
|
else:
|
# subplots is True: one ax per column
|
return col_idx
|
|
@final
|
def _get_ax(self, i: int):
|
# get the twinx ax if appropriate
|
if self.subplots:
|
i = self._col_idx_to_axis_idx(i)
|
ax = self.axes[i]
|
ax = self._maybe_right_yaxis(ax, i)
|
# error: Unsupported target for indexed assignment ("Sequence[Any]")
|
self.axes[i] = ax # type: ignore[index]
|
else:
|
ax = self.axes[0]
|
ax = self._maybe_right_yaxis(ax, i)
|
|
ax.get_yaxis().set_visible(True)
|
return ax
|
|
@final
|
def on_right(self, i: int):
|
if isinstance(self.secondary_y, bool):
|
return self.secondary_y
|
|
if isinstance(self.secondary_y, (tuple, list, np.ndarray, ABCIndex)):
|
return self.data.columns[i] in self.secondary_y
|
|
@final
|
def _apply_style_colors(
|
self, colors, kwds: dict[str, Any], col_num: int, label: str
|
):
|
"""
|
Manage style and color based on column number and its label.
|
Returns tuple of appropriate style and kwds which "color" may be added.
|
"""
|
style = None
|
if self.style is not None:
|
if isinstance(self.style, list):
|
try:
|
style = self.style[col_num]
|
except IndexError:
|
pass
|
elif isinstance(self.style, dict):
|
style = self.style.get(label, style)
|
else:
|
style = self.style
|
|
has_color = "color" in kwds or self.colormap is not None
|
nocolor_style = style is None or not _color_in_style(style)
|
if (has_color or self.subplots) and nocolor_style:
|
if isinstance(colors, dict):
|
kwds["color"] = colors[label]
|
else:
|
kwds["color"] = colors[col_num % len(colors)]
|
return style, kwds
|
|
def _get_colors(
|
self,
|
num_colors: int | None = None,
|
color_kwds: str = "color",
|
):
|
if num_colors is None:
|
num_colors = self.nseries
|
if color_kwds == "color":
|
color = self.color
|
else:
|
color = self.kwds.get(color_kwds)
|
return get_standard_colors(
|
num_colors=num_colors,
|
colormap=self.colormap,
|
color=color,
|
)
|
|
# TODO: tighter typing for first return?
|
@final
|
@staticmethod
|
def _parse_errorbars(
|
label: str, err, data: NDFrameT, nseries: int
|
) -> tuple[Any, NDFrameT]:
|
"""
|
Look for error keyword arguments and return the actual errorbar data
|
or return the error DataFrame/dict
|
|
Error bars can be specified in several ways:
|
Series: the user provides a pandas.Series object of the same
|
length as the data
|
ndarray: provides a np.ndarray of the same length as the data
|
DataFrame/dict: error values are paired with keys matching the
|
key in the plotted DataFrame
|
str: the name of the column within the plotted DataFrame
|
|
Asymmetrical error bars are also supported, however raw error values
|
must be provided in this case. For a ``N`` length :class:`Series`, a
|
``2xN`` array should be provided indicating lower and upper (or left
|
and right) errors. For a ``MxN`` :class:`DataFrame`, asymmetrical errors
|
should be in a ``Mx2xN`` array.
|
"""
|
if err is None:
|
return None, data
|
|
def match_labels(data, e):
|
e = e.reindex(data.index)
|
return e
|
|
# key-matched DataFrame
|
if isinstance(err, ABCDataFrame):
|
err = match_labels(data, err)
|
# key-matched dict
|
elif isinstance(err, dict):
|
pass
|
|
# Series of error values
|
elif isinstance(err, ABCSeries):
|
# broadcast error series across data
|
err = match_labels(data, err)
|
err = np.atleast_2d(err)
|
err = np.tile(err, (nseries, 1))
|
|
# errors are a column in the dataframe
|
elif isinstance(err, str):
|
evalues = data[err].values
|
data = data[data.columns.drop(err)]
|
err = np.atleast_2d(evalues)
|
err = np.tile(err, (nseries, 1))
|
|
elif is_list_like(err):
|
if is_iterator(err):
|
err = np.atleast_2d(list(err))
|
else:
|
# raw error values
|
err = np.atleast_2d(err)
|
|
err_shape = err.shape
|
|
# asymmetrical error bars
|
if isinstance(data, ABCSeries) and err_shape[0] == 2:
|
err = np.expand_dims(err, 0)
|
err_shape = err.shape
|
if err_shape[2] != len(data):
|
raise ValueError(
|
"Asymmetrical error bars should be provided "
|
f"with the shape (2, {len(data)})"
|
)
|
elif isinstance(data, ABCDataFrame) and err.ndim == 3:
|
if (
|
(err_shape[0] != nseries)
|
or (err_shape[1] != 2)
|
or (err_shape[2] != len(data))
|
):
|
raise ValueError(
|
"Asymmetrical error bars should be provided "
|
f"with the shape ({nseries}, 2, {len(data)})"
|
)
|
|
# broadcast errors to each data series
|
if len(err) == 1:
|
err = np.tile(err, (nseries, 1))
|
|
elif is_number(err):
|
err = np.tile(
|
[err],
|
(nseries, len(data)),
|
)
|
|
else:
|
msg = f"No valid {label} detected"
|
raise ValueError(msg)
|
|
return err, data
|
|
@final
|
def _get_errorbars(
|
self, label=None, index=None, xerr: bool = True, yerr: bool = True
|
) -> dict[str, Any]:
|
errors = {}
|
|
for kw, flag in zip(["xerr", "yerr"], [xerr, yerr]):
|
if flag:
|
err = self.errors[kw]
|
# user provided label-matched dataframe of errors
|
if isinstance(err, (ABCDataFrame, dict)):
|
if label is not None and label in err.keys():
|
err = err[label]
|
else:
|
err = None
|
elif index is not None and err is not None:
|
err = err[index]
|
|
if err is not None:
|
errors[kw] = err
|
return errors
|
|
@final
|
def _get_subplots(self, fig: Figure):
|
if Version(mpl.__version__) < Version("3.8"):
|
from matplotlib.axes import Subplot as Klass
|
else:
|
from matplotlib.axes import Axes as Klass
|
|
return [
|
ax
|
for ax in fig.get_axes()
|
if (isinstance(ax, Klass) and ax.get_subplotspec() is not None)
|
]
|
|
@final
|
def _get_axes_layout(self, fig: Figure) -> tuple[int, int]:
|
axes = self._get_subplots(fig)
|
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))
|
|
|
class PlanePlot(MPLPlot, ABC):
|
"""
|
Abstract class for plotting on plane, currently scatter and hexbin.
|
"""
|
|
_layout_type = "single"
|
|
def __init__(self, data, x, y, **kwargs) -> None:
|
MPLPlot.__init__(self, data, **kwargs)
|
if x is None or y is None:
|
raise ValueError(self._kind + " requires an x and y column")
|
if is_integer(x) and not self.data.columns._holds_integer():
|
x = self.data.columns[x]
|
if is_integer(y) and not self.data.columns._holds_integer():
|
y = self.data.columns[y]
|
|
self.x = x
|
self.y = y
|
|
@final
|
def _get_nseries(self, data: Series | DataFrame) -> int:
|
return 1
|
|
@final
|
def _post_plot_logic(self, ax: Axes, data) -> None:
|
x, y = self.x, self.y
|
xlabel = self.xlabel if self.xlabel is not None else pprint_thing(x)
|
ylabel = self.ylabel if self.ylabel is not None else pprint_thing(y)
|
# error: Argument 1 to "set_xlabel" of "_AxesBase" has incompatible
|
# type "Hashable"; expected "str"
|
ax.set_xlabel(xlabel) # type: ignore[arg-type]
|
ax.set_ylabel(ylabel) # type: ignore[arg-type]
|
|
@final
|
def _plot_colorbar(self, ax: Axes, *, fig: Figure, **kwds):
|
# Addresses issues #10611 and #10678:
|
# When plotting scatterplots and hexbinplots in IPython
|
# inline backend the colorbar axis height tends not to
|
# exactly match the parent axis height.
|
# The difference is due to small fractional differences
|
# in floating points with similar representation.
|
# To deal with this, this method forces the colorbar
|
# height to take the height of the parent axes.
|
# For a more detailed description of the issue
|
# see the following link:
|
# https://github.com/ipython/ipython/issues/11215
|
|
# GH33389, if ax is used multiple times, we should always
|
# use the last one which contains the latest information
|
# about the ax
|
img = ax.collections[-1]
|
return fig.colorbar(img, ax=ax, **kwds)
|
|
|
class ScatterPlot(PlanePlot):
|
@property
|
def _kind(self) -> Literal["scatter"]:
|
return "scatter"
|
|
def __init__(
|
self,
|
data,
|
x,
|
y,
|
s=None,
|
c=None,
|
*,
|
colorbar: bool | lib.NoDefault = lib.no_default,
|
norm=None,
|
**kwargs,
|
) -> None:
|
if s is None:
|
# hide the matplotlib default for size, in case we want to change
|
# the handling of this argument later
|
s = 20
|
elif is_hashable(s) and s in data.columns:
|
s = data[s]
|
self.s = s
|
|
self.colorbar = colorbar
|
self.norm = norm
|
|
super().__init__(data, x, y, **kwargs)
|
if is_integer(c) and not self.data.columns._holds_integer():
|
c = self.data.columns[c]
|
self.c = c
|
|
def _make_plot(self, fig: Figure) -> None:
|
x, y, c, data = self.x, self.y, self.c, self.data
|
ax = self.axes[0]
|
|
c_is_column = is_hashable(c) and c in self.data.columns
|
|
color_by_categorical = c_is_column and isinstance(
|
self.data[c].dtype, CategoricalDtype
|
)
|
|
color = self.color
|
c_values = self._get_c_values(color, color_by_categorical, c_is_column)
|
norm, cmap = self._get_norm_and_cmap(c_values, color_by_categorical)
|
cb = self._get_colorbar(c_values, c_is_column)
|
|
if self.legend:
|
label = self.label
|
else:
|
label = None
|
scatter = ax.scatter(
|
data[x].values,
|
data[y].values,
|
c=c_values,
|
label=label,
|
cmap=cmap,
|
norm=norm,
|
s=self.s,
|
**self.kwds,
|
)
|
if cb:
|
cbar_label = c if c_is_column else ""
|
cbar = self._plot_colorbar(ax, fig=fig, label=cbar_label)
|
if color_by_categorical:
|
n_cats = len(self.data[c].cat.categories)
|
cbar.set_ticks(np.linspace(0.5, n_cats - 0.5, n_cats))
|
cbar.ax.set_yticklabels(self.data[c].cat.categories)
|
|
if label is not None:
|
self._append_legend_handles_labels(
|
# error: Argument 2 to "_append_legend_handles_labels" of
|
# "MPLPlot" has incompatible type "Hashable"; expected "str"
|
scatter,
|
label, # type: ignore[arg-type]
|
)
|
|
errors_x = self._get_errorbars(label=x, index=0, yerr=False)
|
errors_y = self._get_errorbars(label=y, index=0, xerr=False)
|
if len(errors_x) > 0 or len(errors_y) > 0:
|
err_kwds = dict(errors_x, **errors_y)
|
err_kwds["ecolor"] = scatter.get_facecolor()[0]
|
ax.errorbar(data[x].values, data[y].values, linestyle="none", **err_kwds)
|
|
def _get_c_values(self, color, color_by_categorical: bool, c_is_column: bool):
|
c = self.c
|
if c is not None and color is not None:
|
raise TypeError("Specify exactly one of `c` and `color`")
|
if c is None and color is None:
|
c_values = self.plt.rcParams["patch.facecolor"]
|
elif color is not None:
|
c_values = color
|
elif color_by_categorical:
|
c_values = self.data[c].cat.codes
|
elif c_is_column:
|
c_values = self.data[c].values
|
else:
|
c_values = c
|
return c_values
|
|
def _get_norm_and_cmap(self, c_values, color_by_categorical: bool):
|
c = self.c
|
if self.colormap is not None:
|
cmap = mpl.colormaps.get_cmap(self.colormap)
|
# cmap is only used if c_values are integers, otherwise UserWarning.
|
# GH-53908: additionally call isinstance() because is_integer_dtype
|
# returns True for "b" (meaning "blue" and not int8 in this context)
|
elif not isinstance(c_values, str) and is_integer_dtype(c_values):
|
# pandas uses colormap, matplotlib uses cmap.
|
cmap = mpl.colormaps["Greys"]
|
else:
|
cmap = None
|
|
if color_by_categorical and cmap is not None:
|
from matplotlib import colors
|
|
n_cats = len(self.data[c].cat.categories)
|
cmap = colors.ListedColormap([cmap(i) for i in range(cmap.N)])
|
bounds = np.linspace(0, n_cats, n_cats + 1)
|
norm = colors.BoundaryNorm(bounds, cmap.N)
|
# TODO: warn that we are ignoring self.norm if user specified it?
|
# Doesn't happen in any tests 2023-11-09
|
else:
|
norm = self.norm
|
return norm, cmap
|
|
def _get_colorbar(self, c_values, c_is_column: bool) -> bool:
|
# plot colorbar if
|
# 1. colormap is assigned, and
|
# 2.`c` is a column containing only numeric values
|
plot_colorbar = self.colormap or c_is_column
|
cb = self.colorbar
|
if cb is lib.no_default:
|
return is_numeric_dtype(c_values) and plot_colorbar
|
return cb
|
|
|
class HexBinPlot(PlanePlot):
|
@property
|
def _kind(self) -> Literal["hexbin"]:
|
return "hexbin"
|
|
def __init__(self, data, x, y, C=None, *, colorbar: bool = True, **kwargs) -> None:
|
super().__init__(data, x, y, **kwargs)
|
if is_integer(C) and not self.data.columns._holds_integer():
|
C = self.data.columns[C]
|
self.C = C
|
|
self.colorbar = colorbar
|
|
# Scatter plot allows to plot objects data
|
if len(self.data[self.x]._get_numeric_data()) == 0:
|
raise ValueError(self._kind + " requires x column to be numeric")
|
if len(self.data[self.y]._get_numeric_data()) == 0:
|
raise ValueError(self._kind + " requires y column to be numeric")
|
|
def _make_plot(self, fig: Figure) -> None:
|
x, y, data, C = self.x, self.y, self.data, self.C
|
ax = self.axes[0]
|
# pandas uses colormap, matplotlib uses cmap.
|
cmap = self.colormap or "BuGn"
|
cmap = mpl.colormaps.get_cmap(cmap)
|
cb = self.colorbar
|
|
if C is None:
|
c_values = None
|
else:
|
c_values = data[C].values
|
|
ax.hexbin(data[x].values, data[y].values, C=c_values, cmap=cmap, **self.kwds)
|
if cb:
|
self._plot_colorbar(ax, fig=fig)
|
|
def _make_legend(self) -> None:
|
pass
|
|
|
class LinePlot(MPLPlot):
|
_default_rot = 0
|
|
@property
|
def orientation(self) -> PlottingOrientation:
|
return "vertical"
|
|
@property
|
def _kind(self) -> Literal["line", "area", "hist", "kde", "box"]:
|
return "line"
|
|
def __init__(self, data, **kwargs) -> None:
|
from pandas.plotting import plot_params
|
|
MPLPlot.__init__(self, data, **kwargs)
|
if self.stacked:
|
self.data = self.data.fillna(value=0)
|
self.x_compat = plot_params["x_compat"]
|
if "x_compat" in self.kwds:
|
self.x_compat = bool(self.kwds.pop("x_compat"))
|
|
@final
|
def _is_ts_plot(self) -> bool:
|
# this is slightly deceptive
|
return not self.x_compat and self.use_index and self._use_dynamic_x()
|
|
@final
|
def _use_dynamic_x(self) -> bool:
|
return use_dynamic_x(self._get_ax(0), self.data)
|
|
def _make_plot(self, fig: Figure) -> None:
|
if self._is_ts_plot():
|
data = maybe_convert_index(self._get_ax(0), self.data)
|
|
x = data.index # dummy, not used
|
plotf = self._ts_plot
|
it = data.items()
|
else:
|
x = self._get_xticks()
|
# error: Incompatible types in assignment (expression has type
|
# "Callable[[Any, Any, Any, Any, Any, Any, KwArg(Any)], Any]", variable has
|
# type "Callable[[Any, Any, Any, Any, KwArg(Any)], Any]")
|
plotf = self._plot # type: ignore[assignment]
|
# error: Incompatible types in assignment (expression has type
|
# "Iterator[tuple[Hashable, ndarray[Any, Any]]]", variable has
|
# type "Iterable[tuple[Hashable, Series]]")
|
it = self._iter_data(data=self.data) # type: ignore[assignment]
|
|
stacking_id = self._get_stacking_id()
|
is_errorbar = com.any_not_none(*self.errors.values())
|
|
colors = self._get_colors()
|
for i, (label, y) in enumerate(it):
|
ax = self._get_ax(i)
|
kwds = self.kwds.copy()
|
if self.color is not None:
|
kwds["color"] = self.color
|
style, kwds = self._apply_style_colors(
|
colors,
|
kwds,
|
i,
|
# error: Argument 4 to "_apply_style_colors" of "MPLPlot" has
|
# incompatible type "Hashable"; expected "str"
|
label, # type: ignore[arg-type]
|
)
|
|
errors = self._get_errorbars(label=label, index=i)
|
kwds = dict(kwds, **errors)
|
|
label = pprint_thing(label)
|
label = self._mark_right_label(label, index=i)
|
kwds["label"] = label
|
|
newlines = plotf(
|
ax,
|
x,
|
y,
|
style=style,
|
column_num=i,
|
stacking_id=stacking_id,
|
is_errorbar=is_errorbar,
|
**kwds,
|
)
|
self._append_legend_handles_labels(newlines[0], label)
|
|
if self._is_ts_plot():
|
# reset of xlim should be used for ts data
|
# TODO: GH28021, should find a way to change view limit on xaxis
|
lines = get_all_lines(ax)
|
left, right = get_xlim(lines)
|
ax.set_xlim(left, right)
|
|
# error: Signature of "_plot" incompatible with supertype "MPLPlot"
|
@classmethod
|
def _plot( # type: ignore[override]
|
cls,
|
ax: Axes,
|
x,
|
y: np.ndarray,
|
style=None,
|
column_num=None,
|
stacking_id=None,
|
**kwds,
|
):
|
# column_num is used to get the target column from plotf in line and
|
# area plots
|
if column_num == 0:
|
cls._initialize_stacker(ax, stacking_id, len(y))
|
y_values = cls._get_stacked_values(ax, stacking_id, y, kwds["label"])
|
lines = MPLPlot._plot(ax, x, y_values, style=style, **kwds)
|
cls._update_stacker(ax, stacking_id, y)
|
return lines
|
|
@final
|
def _ts_plot(self, ax: Axes, x, data: Series, style=None, **kwds):
|
# accept x to be consistent with normal plot func,
|
# x is not passed to tsplot as it uses data.index as x coordinate
|
# column_num must be in kwds for stacking purpose
|
freq, data = maybe_resample(data, ax, kwds)
|
|
# Set ax with freq info
|
decorate_axes(ax, freq)
|
# digging deeper
|
if hasattr(ax, "left_ax"):
|
decorate_axes(ax.left_ax, freq)
|
if hasattr(ax, "right_ax"):
|
decorate_axes(ax.right_ax, freq)
|
# TODO #54485
|
ax._plot_data.append((data, self._kind, kwds)) # type: ignore[attr-defined]
|
|
lines = self._plot(ax, data.index, np.asarray(data.values), style=style, **kwds)
|
# set date formatter, locators and rescale limits
|
# TODO #54485
|
format_dateaxis(ax, ax.freq, data.index) # type: ignore[arg-type, attr-defined]
|
return lines
|
|
@final
|
def _get_stacking_id(self) -> int | None:
|
if self.stacked:
|
return id(self.data)
|
else:
|
return None
|
|
@final
|
@classmethod
|
def _initialize_stacker(cls, ax: Axes, stacking_id, n: int) -> None:
|
if stacking_id is None:
|
return
|
if not hasattr(ax, "_stacker_pos_prior"):
|
# TODO #54485
|
ax._stacker_pos_prior = {} # type: ignore[attr-defined]
|
if not hasattr(ax, "_stacker_neg_prior"):
|
# TODO #54485
|
ax._stacker_neg_prior = {} # type: ignore[attr-defined]
|
# TODO #54485
|
ax._stacker_pos_prior[stacking_id] = np.zeros(n) # type: ignore[attr-defined]
|
# TODO #54485
|
ax._stacker_neg_prior[stacking_id] = np.zeros(n) # type: ignore[attr-defined]
|
|
@final
|
@classmethod
|
def _get_stacked_values(
|
cls, ax: Axes, stacking_id: int | None, values: np.ndarray, label
|
) -> np.ndarray:
|
if stacking_id is None:
|
return values
|
if not hasattr(ax, "_stacker_pos_prior"):
|
# stacker may not be initialized for subplots
|
cls._initialize_stacker(ax, stacking_id, len(values))
|
|
if (values >= 0).all():
|
# TODO #54485
|
return (
|
ax._stacker_pos_prior[stacking_id] # type: ignore[attr-defined]
|
+ values
|
)
|
elif (values <= 0).all():
|
# TODO #54485
|
return (
|
ax._stacker_neg_prior[stacking_id] # type: ignore[attr-defined]
|
+ values
|
)
|
|
raise ValueError(
|
"When stacked is True, each column must be either "
|
"all positive or all negative. "
|
f"Column '{label}' contains both positive and negative values"
|
)
|
|
@final
|
@classmethod
|
def _update_stacker(cls, ax: Axes, stacking_id: int | None, values) -> None:
|
if stacking_id is None:
|
return
|
if (values >= 0).all():
|
# TODO #54485
|
ax._stacker_pos_prior[stacking_id] += values # type: ignore[attr-defined]
|
elif (values <= 0).all():
|
# TODO #54485
|
ax._stacker_neg_prior[stacking_id] += values # type: ignore[attr-defined]
|
|
def _post_plot_logic(self, ax: Axes, data) -> None:
|
from matplotlib.ticker import FixedLocator
|
|
def get_label(i):
|
if is_float(i) and i.is_integer():
|
i = int(i)
|
try:
|
return pprint_thing(data.index[i])
|
except Exception:
|
return ""
|
|
if self._need_to_set_index:
|
xticks = ax.get_xticks()
|
xticklabels = [get_label(x) for x in xticks]
|
# error: Argument 1 to "FixedLocator" has incompatible type "ndarray[Any,
|
# Any]"; expected "Sequence[float]"
|
ax.xaxis.set_major_locator(FixedLocator(xticks)) # type: ignore[arg-type]
|
ax.set_xticklabels(xticklabels)
|
|
# If the index is an irregular time series, then by default
|
# we rotate the tick labels. The exception is if there are
|
# subplots which don't share their x-axes, in which we case
|
# we don't rotate the ticklabels as by default the subplots
|
# would be too close together.
|
condition = (
|
not self._use_dynamic_x()
|
and (data.index._is_all_dates and self.use_index)
|
and (not self.subplots or (self.subplots and self.sharex))
|
)
|
|
index_name = self._get_index_name()
|
|
if condition:
|
# irregular TS rotated 30 deg. by default
|
# probably a better place to check / set this.
|
if not self._rot_set:
|
self.rot = 30
|
format_date_labels(ax, rot=self.rot)
|
|
if index_name is not None and self.use_index:
|
ax.set_xlabel(index_name)
|
|
|
class AreaPlot(LinePlot):
|
@property
|
def _kind(self) -> Literal["area"]:
|
return "area"
|
|
def __init__(self, data, **kwargs) -> None:
|
kwargs.setdefault("stacked", True)
|
with warnings.catch_warnings():
|
warnings.filterwarnings(
|
"ignore",
|
"Downcasting object dtype arrays",
|
category=FutureWarning,
|
)
|
data = data.fillna(value=0)
|
LinePlot.__init__(self, data, **kwargs)
|
|
if not self.stacked:
|
# use smaller alpha to distinguish overlap
|
self.kwds.setdefault("alpha", 0.5)
|
|
if self.logy or self.loglog:
|
raise ValueError("Log-y scales are not supported in area plot")
|
|
# error: Signature of "_plot" incompatible with supertype "MPLPlot"
|
@classmethod
|
def _plot( # type: ignore[override]
|
cls,
|
ax: Axes,
|
x,
|
y: np.ndarray,
|
style=None,
|
column_num=None,
|
stacking_id=None,
|
is_errorbar: bool = False,
|
**kwds,
|
):
|
if column_num == 0:
|
cls._initialize_stacker(ax, stacking_id, len(y))
|
y_values = cls._get_stacked_values(ax, stacking_id, y, kwds["label"])
|
|
# need to remove label, because subplots uses mpl legend as it is
|
line_kwds = kwds.copy()
|
line_kwds.pop("label")
|
lines = MPLPlot._plot(ax, x, y_values, style=style, **line_kwds)
|
|
# get data from the line to get coordinates for fill_between
|
xdata, y_values = lines[0].get_data(orig=False)
|
|
# unable to use ``_get_stacked_values`` here to get starting point
|
if stacking_id is None:
|
start = np.zeros(len(y))
|
elif (y >= 0).all():
|
# TODO #54485
|
start = ax._stacker_pos_prior[stacking_id] # type: ignore[attr-defined]
|
elif (y <= 0).all():
|
# TODO #54485
|
start = ax._stacker_neg_prior[stacking_id] # type: ignore[attr-defined]
|
else:
|
start = np.zeros(len(y))
|
|
if "color" not in kwds:
|
kwds["color"] = lines[0].get_color()
|
|
rect = ax.fill_between(xdata, start, y_values, **kwds)
|
cls._update_stacker(ax, stacking_id, y)
|
|
# LinePlot expects list of artists
|
res = [rect]
|
return res
|
|
def _post_plot_logic(self, ax: Axes, data) -> None:
|
LinePlot._post_plot_logic(self, ax, data)
|
|
is_shared_y = len(list(ax.get_shared_y_axes())) > 0
|
# do not override the default axis behaviour in case of shared y axes
|
if self.ylim is None and not is_shared_y:
|
if (data >= 0).all().all():
|
ax.set_ylim(0, None)
|
elif (data <= 0).all().all():
|
ax.set_ylim(None, 0)
|
|
|
class BarPlot(MPLPlot):
|
@property
|
def _kind(self) -> Literal["bar", "barh"]:
|
return "bar"
|
|
_default_rot = 90
|
|
@property
|
def orientation(self) -> PlottingOrientation:
|
return "vertical"
|
|
def __init__(
|
self,
|
data,
|
*,
|
align="center",
|
bottom=0,
|
left=0,
|
width=0.5,
|
position=0.5,
|
log=False,
|
**kwargs,
|
) -> None:
|
# we have to treat a series differently than a
|
# 1-column DataFrame w.r.t. color handling
|
self._is_series = isinstance(data, ABCSeries)
|
self.bar_width = width
|
self._align = align
|
self._position = position
|
self.tick_pos = np.arange(len(data))
|
|
if is_list_like(bottom):
|
bottom = np.array(bottom)
|
if is_list_like(left):
|
left = np.array(left)
|
self.bottom = bottom
|
self.left = left
|
|
self.log = log
|
|
MPLPlot.__init__(self, data, **kwargs)
|
|
@cache_readonly
|
def ax_pos(self) -> np.ndarray:
|
return self.tick_pos - self.tickoffset
|
|
@cache_readonly
|
def tickoffset(self):
|
if self.stacked or self.subplots:
|
return self.bar_width * self._position
|
elif self._align == "edge":
|
w = self.bar_width / self.nseries
|
return self.bar_width * (self._position - 0.5) + w * 0.5
|
else:
|
return self.bar_width * self._position
|
|
@cache_readonly
|
def lim_offset(self):
|
if self.stacked or self.subplots:
|
if self._align == "edge":
|
return self.bar_width / 2
|
else:
|
return 0
|
elif self._align == "edge":
|
w = self.bar_width / self.nseries
|
return w * 0.5
|
else:
|
return 0
|
|
# error: Signature of "_plot" incompatible with supertype "MPLPlot"
|
@classmethod
|
def _plot( # type: ignore[override]
|
cls,
|
ax: Axes,
|
x,
|
y: np.ndarray,
|
w,
|
start: int | npt.NDArray[np.intp] = 0,
|
log: bool = False,
|
**kwds,
|
):
|
return ax.bar(x, y, w, bottom=start, log=log, **kwds)
|
|
@property
|
def _start_base(self):
|
return self.bottom
|
|
def _make_plot(self, fig: Figure) -> None:
|
colors = self._get_colors()
|
ncolors = len(colors)
|
|
pos_prior = neg_prior = np.zeros(len(self.data))
|
K = self.nseries
|
|
data = self.data.fillna(0)
|
for i, (label, y) in enumerate(self._iter_data(data=data)):
|
ax = self._get_ax(i)
|
kwds = self.kwds.copy()
|
if self._is_series:
|
kwds["color"] = colors
|
elif isinstance(colors, dict):
|
kwds["color"] = colors[label]
|
else:
|
kwds["color"] = colors[i % ncolors]
|
|
errors = self._get_errorbars(label=label, index=i)
|
kwds = dict(kwds, **errors)
|
|
label = pprint_thing(label)
|
label = self._mark_right_label(label, index=i)
|
|
if (("yerr" in kwds) or ("xerr" in kwds)) and (kwds.get("ecolor") is None):
|
kwds["ecolor"] = mpl.rcParams["xtick.color"]
|
|
start = 0
|
if self.log and (y >= 1).all():
|
start = 1
|
start = start + self._start_base
|
|
kwds["align"] = self._align
|
if self.subplots:
|
w = self.bar_width / 2
|
rect = self._plot(
|
ax,
|
self.ax_pos + w,
|
y,
|
self.bar_width,
|
start=start,
|
label=label,
|
log=self.log,
|
**kwds,
|
)
|
ax.set_title(label)
|
elif self.stacked:
|
mask = y > 0
|
start = np.where(mask, pos_prior, neg_prior) + self._start_base
|
w = self.bar_width / 2
|
rect = self._plot(
|
ax,
|
self.ax_pos + w,
|
y,
|
self.bar_width,
|
start=start,
|
label=label,
|
log=self.log,
|
**kwds,
|
)
|
pos_prior = pos_prior + np.where(mask, y, 0)
|
neg_prior = neg_prior + np.where(mask, 0, y)
|
else:
|
w = self.bar_width / K
|
rect = self._plot(
|
ax,
|
self.ax_pos + (i + 0.5) * w,
|
y,
|
w,
|
start=start,
|
label=label,
|
log=self.log,
|
**kwds,
|
)
|
self._append_legend_handles_labels(rect, label)
|
|
def _post_plot_logic(self, ax: Axes, data) -> None:
|
if self.use_index:
|
str_index = [pprint_thing(key) for key in data.index]
|
else:
|
str_index = [pprint_thing(key) for key in range(data.shape[0])]
|
|
s_edge = self.ax_pos[0] - 0.25 + self.lim_offset
|
e_edge = self.ax_pos[-1] + 0.25 + self.bar_width + self.lim_offset
|
|
self._decorate_ticks(ax, self._get_index_name(), str_index, s_edge, e_edge)
|
|
def _decorate_ticks(
|
self,
|
ax: Axes,
|
name: str | None,
|
ticklabels: list[str],
|
start_edge: float,
|
end_edge: float,
|
) -> None:
|
ax.set_xlim((start_edge, end_edge))
|
|
if self.xticks is not None:
|
ax.set_xticks(np.array(self.xticks))
|
else:
|
ax.set_xticks(self.tick_pos)
|
ax.set_xticklabels(ticklabels)
|
|
if name is not None and self.use_index:
|
ax.set_xlabel(name)
|
|
|
class BarhPlot(BarPlot):
|
@property
|
def _kind(self) -> Literal["barh"]:
|
return "barh"
|
|
_default_rot = 0
|
|
@property
|
def orientation(self) -> Literal["horizontal"]:
|
return "horizontal"
|
|
@property
|
def _start_base(self):
|
return self.left
|
|
# error: Signature of "_plot" incompatible with supertype "MPLPlot"
|
@classmethod
|
def _plot( # type: ignore[override]
|
cls,
|
ax: Axes,
|
x,
|
y: np.ndarray,
|
w,
|
start: int | npt.NDArray[np.intp] = 0,
|
log: bool = False,
|
**kwds,
|
):
|
return ax.barh(x, y, w, left=start, log=log, **kwds)
|
|
def _get_custom_index_name(self):
|
return self.ylabel
|
|
def _decorate_ticks(
|
self,
|
ax: Axes,
|
name: str | None,
|
ticklabels: list[str],
|
start_edge: float,
|
end_edge: float,
|
) -> None:
|
# horizontal bars
|
ax.set_ylim((start_edge, end_edge))
|
ax.set_yticks(self.tick_pos)
|
ax.set_yticklabels(ticklabels)
|
if name is not None and self.use_index:
|
ax.set_ylabel(name)
|
# error: Argument 1 to "set_xlabel" of "_AxesBase" has incompatible type
|
# "Hashable | None"; expected "str"
|
ax.set_xlabel(self.xlabel) # type: ignore[arg-type]
|
|
|
class PiePlot(MPLPlot):
|
@property
|
def _kind(self) -> Literal["pie"]:
|
return "pie"
|
|
_layout_type = "horizontal"
|
|
def __init__(self, data, kind=None, **kwargs) -> None:
|
data = data.fillna(value=0)
|
if (data < 0).any().any():
|
raise ValueError(f"{self._kind} plot doesn't allow negative values")
|
MPLPlot.__init__(self, data, kind=kind, **kwargs)
|
|
@classmethod
|
def _validate_log_kwd(
|
cls,
|
kwd: str,
|
value: bool | None | Literal["sym"],
|
) -> bool | None | Literal["sym"]:
|
super()._validate_log_kwd(kwd=kwd, value=value)
|
if value is not False:
|
warnings.warn(
|
f"PiePlot ignores the '{kwd}' keyword",
|
UserWarning,
|
stacklevel=find_stack_level(),
|
)
|
return False
|
|
def _validate_color_args(self, color, colormap) -> None:
|
# TODO: warn if color is passed and ignored?
|
return None
|
|
def _make_plot(self, fig: Figure) -> None:
|
colors = self._get_colors(num_colors=len(self.data), color_kwds="colors")
|
self.kwds.setdefault("colors", colors)
|
|
for i, (label, y) in enumerate(self._iter_data(data=self.data)):
|
ax = self._get_ax(i)
|
if label is not None:
|
label = pprint_thing(label)
|
ax.set_ylabel(label)
|
|
kwds = self.kwds.copy()
|
|
def blank_labeler(label, value):
|
if value == 0:
|
return ""
|
else:
|
return label
|
|
idx = [pprint_thing(v) for v in self.data.index]
|
labels = kwds.pop("labels", idx)
|
# labels is used for each wedge's labels
|
# Blank out labels for values of 0 so they don't overlap
|
# with nonzero wedges
|
if labels is not None:
|
blabels = [blank_labeler(left, value) for left, value in zip(labels, y)]
|
else:
|
blabels = None
|
results = ax.pie(y, labels=blabels, **kwds)
|
|
if kwds.get("autopct", None) is not None:
|
patches, texts, autotexts = results
|
else:
|
patches, texts = results
|
autotexts = []
|
|
if self.fontsize is not None:
|
for t in texts + autotexts:
|
t.set_fontsize(self.fontsize)
|
|
# leglabels is used for legend labels
|
leglabels = labels if labels is not None else idx
|
for _patch, _leglabel in zip(patches, leglabels):
|
self._append_legend_handles_labels(_patch, _leglabel)
|
|
def _post_plot_logic(self, ax: Axes, data) -> None:
|
pass
|
