"""

def __init__(self, attr_name, method_name, *, doc_sub=None):

self.attr_name = attr_name

self.method_name = method_name

# Immediately put the docstring in ``self.__doc__`` so that docstring

# manipulations within the class body work as expected.

doc = inspect.getdoc(getattr(maxis.Axis, method_name))

self._missing_subs = []

if doc:

doc_sub = {"this Axis": f"the {self.attr_name}", **(doc_sub or {})}

for k, v in doc_sub.items():

if k not in doc: # Delay raising error until we know qualname.

self._missing_subs.append(k)

doc = doc.replace(k, v)

self.__doc__ = doc

def __set_name__(self, owner, name):

# This is called at the end of the class body as

# ``self.__set_name__(cls, name_under_which_self_is_assigned)``; we

# rely on that to give the wrapper the correct __name__/__qualname__.

get_method = attrgetter(f"{self.attr_name}.{self.method_name}")

def wrapper(self, *args, **kwargs):

return get_method(self)(*args, **kwargs)

wrapper.__module__ = owner.__module__

wrapper.__name__ = name

wrapper.__qualname__ = f"{owner.__qualname__}.{name}"

wrapper.__doc__ = self.__doc__

# Manually copy the signature instead of using functools.wraps because

# displaying the Axis method source when asking for the Axes method

# source would be confusing.

wrapper.__signature__ = inspect.signature(

getattr(maxis.Axis, self.method_name))

if self._missing_subs:

raise ValueError(

"The definition of {} expected that the docstring of Axis.{} "

"contains {!r} as substrings".format(

wrapper.__qualname__, self.method_name,

", ".join(map(repr, self._missing_subs))))

"""

def __init__(self, bounds, transform):

"""

self._bounds = bounds

self._transform = transform

def __call__(self, ax, renderer):

# Subtracting transSubfigure will typically rely on inverted(),

# freezing the transform; thus, this needs to be delayed until draw

# time as transSubfigure may otherwise change after this is evaluated.

return mtransforms.TransformedBbox(

mtransforms.Bbox.from_bounds(*self._bounds),

"""

linestyle = None

marker = None

color = None

# Is fmt just a colorspec?

try:

color = mcolors.to_rgba(fmt)

# We need to differentiate grayscale '1.0' from tri_down marker '1'

try:

fmtint = str(int(fmt))

except ValueError:

return linestyle, marker, color # Yes

else:

if fmt != fmtint:

# user definitely doesn't want tri_down marker

return linestyle, marker, color # Yes

else:

# ignore converted color

color = None

except ValueError:

pass # No, not just a color.

i = 0

while i < len(fmt):

c = fmt[i]

if fmt[i:i+2] in mlines.lineStyles: # First, the two-char styles.

if linestyle is not None:

raise ValueError(

'Illegal format string "%s"; two linestyle symbols' % fmt)

linestyle = fmt[i:i+2]

i += 2

elif c in mlines.lineStyles:

if linestyle is not None:

raise ValueError(

'Illegal format string "%s"; two linestyle symbols' % fmt)

linestyle = c

i += 1

elif c in mlines.lineMarkers:

if marker is not None:

raise ValueError(

'Illegal format string "%s"; two marker symbols' % fmt)

marker = c

i += 1

elif c in mcolors.get_named_colors_mapping():

if color is not None:

raise ValueError(

'Illegal format string "%s"; two color symbols' % fmt)

color = c

i += 1

elif c == 'C' and i < len(fmt) - 1:

color_cycle_number = int(fmt[i + 1])

color = mcolors.to_rgba("C{}".format(color_cycle_number))

i += 2

else:

raise ValueError(

'Unrecognized character %c in format string' % c)

if linestyle is None and marker is None:

linestyle = mpl.rcParams['lines.linestyle']

if linestyle is None:

linestyle = 'None'

if marker is None:

marker = 'None'

"""

def __init__(self, axes, command='plot'):

self.axes = axes

self.command = command

self.set_prop_cycle(None)

def __getstate__(self):

# note: it is not possible to pickle a generator (and thus a cycler).

return {'axes': self.axes, 'command': self.command}

def __setstate__(self, state):

self.__dict__ = state.copy()

self.set_prop_cycle(None)

def set_prop_cycle(self, cycler):

if cycler is None:

cycler = mpl.rcParams['axes.prop_cycle']

self.prop_cycler = itertools.cycle(cycler)

self._prop_keys = cycler.keys # This should make a copy

def __call__(self, *args, data=None, **kwargs):

self.axes._process_unit_info(kwargs=kwargs)

for pos_only in "xy":

if pos_only in kwargs:

raise TypeError("{} got an unexpected keyword argument {!r}"

.format(self.command, pos_only))

if not args:

return

if data is None: # Process dict views

args = [cbook.sanitize_sequence(a) for a in args]

else: # Process the 'data' kwarg.

replaced = [mpl._replacer(data, arg) for arg in args]

if len(args) == 1:

label_namer_idx = 0

elif len(args) == 2: # Can be x, y or y, c.

# Figure out what the second argument is.

# 1) If the second argument cannot be a format shorthand, the

# second argument is the label_namer.

# 2) Otherwise (it could have been a format shorthand),

# a) if we did perform a substitution, emit a warning, and

# use it as label_namer.

# b) otherwise, it is indeed a format shorthand; use the

# first argument as label_namer.

try:

_process_plot_format(args[1])

except ValueError: # case 1)

label_namer_idx = 1

else:

if replaced[1] is not args[1]: # case 2a)

_api.warn_external(

f"Second argument {args[1]!r} is ambiguous: could "

f"be a format string but is in 'data'; using as "

f"data. If it was intended as data, set the "

f"format string to an empty string to suppress "

f"this warning. If it was intended as a format "

f"string, explicitly pass the x-values as well. "

f"Alternatively, rename the entry in 'data'.",

RuntimeWarning)

label_namer_idx = 1

else: # case 2b)

label_namer_idx = 0

elif len(args) == 3:

label_namer_idx = 1

else:

raise ValueError(

"Using arbitrary long args with data is not supported due "

"to ambiguity of arguments; use multiple plotting calls "

"instead")

if kwargs.get("label") is None:

kwargs["label"] = mpl._label_from_arg(

replaced[label_namer_idx], args[label_namer_idx])

args = replaced

if len(args) >= 4 and not cbook.is_scalar_or_string(

kwargs.get("label")):

raise ValueError("plot() with multiple groups of data (i.e., "

"pairs of x and y) does not support multiple "

"labels")

# Repeatedly grab (x, y) or (x, y, format) from the front of args and

# massage them into arguments to plot() or fill().

while args:

this, args = args[:2], args[2:]

if args and isinstance(args[0], str):

this += args[0],

args = args[1:]

yield from self._plot_args(this, kwargs)

def get_next_color(self):

"""Return the next color in the cycle."""

if 'color' not in self._prop_keys:

return 'k'

return next(self.prop_cycler)['color']

def _getdefaults(self, ignore, kw):

"""

prop_keys = self._prop_keys - ignore

if any(kw.get(k, None) is None for k in prop_keys):

# Need to copy this dictionary or else the next time around

# in the cycle, the dictionary could be missing entries.

default_dict = next(self.prop_cycler).copy()

for p in ignore:

default_dict.pop(p, None)

else:

default_dict = {}

return default_dict

def _setdefaults(self, defaults, kw):

"""

for k in defaults:

if kw.get(k, None) is None:

kw[k] = defaults[k]

def _makeline(self, x, y, kw, kwargs):

kw = {**kw, **kwargs} # Don't modify the original kw.

default_dict = self._getdefaults(set(), kw)

self._setdefaults(default_dict, kw)

seg = mlines.Line2D(x, y, **kw)

return seg, kw

def _makefill(self, x, y, kw, kwargs):

# Polygon doesn't directly support unitized inputs.

x = self.axes.convert_xunits(x)

y = self.axes.convert_yunits(y)

kw = kw.copy() # Don't modify the original kw.

kwargs = kwargs.copy()

# Ignore 'marker'-related properties as they aren't Polygon

# properties, but they are Line2D properties, and so they are

# likely to appear in the default cycler construction.

# This is done here to the defaults dictionary as opposed to the

# other two dictionaries because we do want to capture when a

# *user* explicitly specifies a marker which should be an error.

# We also want to prevent advancing the cycler if there are no

# defaults needed after ignoring the given properties.

ignores = {'marker', 'markersize', 'markeredgecolor',

'markerfacecolor', 'markeredgewidth'}

# Also ignore anything provided by *kwargs*.

for k, v in kwargs.items():

if v is not None:

ignores.add(k)

# Only using the first dictionary to use as basis

# for getting defaults for back-compat reasons.

# Doing it with both seems to mess things up in

# various places (probably due to logic bugs elsewhere).

default_dict = self._getdefaults(ignores, kw)

self._setdefaults(default_dict, kw)

# Looks like we don't want "color" to be interpreted to

# mean both facecolor and edgecolor for some reason.

# So the "kw" dictionary is thrown out, and only its

# 'color' value is kept and translated as a 'facecolor'.

# This design should probably be revisited as it increases

# complexity.

facecolor = kw.get('color', None)

# Throw out 'color' as it is now handled as a facecolor

default_dict.pop('color', None)

# To get other properties set from the cycler

# modify the kwargs dictionary.

self._setdefaults(default_dict, kwargs)

seg = mpatches.Polygon(np.column_stack((x, y)),

facecolor=facecolor,

fill=kwargs.get('fill', True),

closed=kw['closed'])

seg.set(**kwargs)

return seg, kwargs

def _plot_args(self, tup, kwargs, return_kwargs=False):

"""

if len(tup) > 1 and isinstance(tup[-1], str):

# xy is tup with fmt stripped (could still be (y,) only)

*xy, fmt = tup

linestyle, marker, color = _process_plot_format(fmt)

elif len(tup) == 3:

raise ValueError('third arg must be a format string')

else:

xy = tup

linestyle, marker, color = None, None, None

# Don't allow any None value; these would be up-converted to one

# element array of None which causes problems downstream.

if any(v is None for v in tup):

raise ValueError("x, y, and format string must not be None")

kw = {}

for prop_name, val in zip(('linestyle', 'marker', 'color'),

(linestyle, marker, color)):

if val is not None:

# check for conflicts between fmt and kwargs

if (fmt.lower() != 'none'

and prop_name in kwargs

and val != 'None'):

# Technically ``plot(x, y, 'o', ls='--')`` is a conflict

# because 'o' implicitly unsets the linestyle

# (linestyle='None').

# We'll gracefully not warn in this case because an

# explicit set via kwargs can be seen as intention to

# override an implicit unset.

# Note: We don't val.lower() != 'none' because val is not

# necessarily a string (can be a tuple for colors). This

# is safe, because *val* comes from _process_plot_format()

# which only returns 'None'.

_api.warn_external(

f"{prop_name} is redundantly defined by the "

f"'{prop_name}' keyword argument and the fmt string "

f'"{fmt}" (-> {prop_name}={val!r}). The keyword '

f"argument will take precedence.")

kw[prop_name] = val

if len(xy) == 2:

x = _check_1d(xy[0])

y = _check_1d(xy[1])

else:

x, y = index_of(xy[-1])

if self.axes.xaxis is not None:

self.axes.xaxis.update_units(x)

if self.axes.yaxis is not None:

self.axes.yaxis.update_units(y)

if x.shape[0] != y.shape[0]:

raise ValueError(f"x and y must have same first dimension, but "

f"have shapes {x.shape} and {y.shape}")

if x.ndim > 2 or y.ndim > 2:

raise ValueError(f"x and y can be no greater than 2D, but have "

f"shapes {x.shape} and {y.shape}")

if x.ndim == 1:

x = x[:, np.newaxis]

if y.ndim == 1:

y = y[:, np.newaxis]

if self.command == 'plot':

make_artist = self._makeline

else:

kw['closed'] = kwargs.get('closed', True)

make_artist = self._makefill

ncx, ncy = x.shape[1], y.shape[1]

if ncx > 1 and ncy > 1 and ncx != ncy:

raise ValueError(f"x has {ncx} columns but y has {ncy} columns")

if ncx == 0 or ncy == 0:

return []

label = kwargs.get('label')

n_datasets = max(ncx, ncy)

if n_datasets > 1 and not cbook.is_scalar_or_string(label):

if len(label) != n_datasets:

raise ValueError(f"label must be scalar or have the same "

f"length as the input data, but found "

f"{len(label)} for {n_datasets} datasets.")

labels = label

else:

labels = [label] * n_datasets

result = (make_artist(x[:, j % ncx], y[:, j % ncy], kw,

{**kwargs, 'label': label})

for j, label in enumerate(labels))

if return_kwargs:

return list(result)

else:

name = "rectilinear"

_axis_names = ("x", "y") # See _get_axis_map.

_shared_axes = {name: cbook.Grouper() for name in _axis_names}

_twinned_axes = cbook.Grouper()

def __str__(self):

return "{0}({1[0]:g},{1[1]:g};{1[2]:g}x{1[3]:g})".format(

type(self).__name__, self._position.bounds)

@_api.make_keyword_only("3.4", "facecolor")

def __init__(self, fig, rect,

facecolor=None, # defaults to rc axes.facecolor

frameon=True,

sharex=None, # use Axes instance's xaxis info

sharey=None, # use Axes instance's yaxis info

label='',

xscale=None,

yscale=None,

box_aspect=None,

**kwargs

):

"""

super().__init__()

if isinstance(rect, mtransforms.Bbox):

self._position = rect

else:

self._position = mtransforms.Bbox.from_bounds(*rect)

if self._position.width < 0 or self._position.height < 0:

raise ValueError('Width and height specified must be non-negative')

self._originalPosition = self._position.frozen()

self.axes = self

self._aspect = 'auto'

self._adjustable = 'box'

self._anchor = 'C'

self._stale_viewlims = {name: False for name in self._axis_names}

self._sharex = sharex

self._sharey = sharey

self.set_label(label)

self.set_figure(fig)

self.set_box_aspect(box_aspect)

self._axes_locator = None # Optionally set via update(kwargs).

# placeholder for any colorbars added that use this Axes.

# (see colorbar.py):

self._colorbars = []

self.spines = mspines.Spines.from_dict(self._gen_axes_spines())

# this call may differ for non-sep axes, e.g., polar

self._init_axis()

if facecolor is None:

facecolor = mpl.rcParams['axes.facecolor']

self._facecolor = facecolor

self._frameon = frameon

self.set_axisbelow(mpl.rcParams['axes.axisbelow'])

self._rasterization_zorder = None

self.cla()

# funcs used to format x and y - fall back on major formatters

self.fmt_xdata = None

self.fmt_ydata = None

self.set_navigate(True)

self.set_navigate_mode(None)

if xscale:

self.set_xscale(xscale)

if yscale:

self.set_yscale(yscale)

self.update(kwargs)

for name, axis in self._get_axis_map().items():

axis.callbacks._pickled_cids.add(

axis.callbacks.connect(

'units', self._unit_change_handler(name)))

rcParams = mpl.rcParams

self.tick_params(

top=rcParams['xtick.top'] and rcParams['xtick.minor.top'],

bottom=rcParams['xtick.bottom'] and rcParams['xtick.minor.bottom'],

labeltop=(rcParams['xtick.labeltop'] and

rcParams['xtick.minor.top']),

labelbottom=(rcParams['xtick.labelbottom'] and

rcParams['xtick.minor.bottom']),

left=rcParams['ytick.left'] and rcParams['ytick.minor.left'],

right=rcParams['ytick.right'] and rcParams['ytick.minor.right'],

labelleft=(rcParams['ytick.labelleft'] and

rcParams['ytick.minor.left']),

labelright=(rcParams['ytick.labelright'] and

rcParams['ytick.minor.right']),

which='minor')

self.tick_params(

top=rcParams['xtick.top'] and rcParams['xtick.major.top'],

bottom=rcParams['xtick.bottom'] and rcParams['xtick.major.bottom'],

labeltop=(rcParams['xtick.labeltop'] and

rcParams['xtick.major.top']),

labelbottom=(rcParams['xtick.labelbottom'] and

rcParams['xtick.major.bottom']),

left=rcParams['ytick.left'] and rcParams['ytick.major.left'],

right=rcParams['ytick.right'] and rcParams['ytick.major.right'],

labelleft=(rcParams['ytick.labelleft'] and

rcParams['ytick.major.left']),

labelright=(rcParams['ytick.labelright'] and

rcParams['ytick.major.right']),

which='major')

def __getstate__(self):

# The renderer should be re-created by the figure, and then cached at

# that point.

state = super().__getstate__()

# Prune the sharing & twinning info to only contain the current group.

state["_shared_axes"] = {

name: self._shared_axes[name].get_siblings(self)

for name in self._axis_names if self in self._shared_axes[name]}

state["_twinned_axes"] = (self._twinned_axes.get_siblings(self)

if self in self._twinned_axes else None)

return state

def __setstate__(self, state):

# Merge the grouping info back into the global groupers.

shared_axes = state.pop("_shared_axes")

for name, shared_siblings in shared_axes.items():

self._shared_axes[name].join(*shared_siblings)

twinned_siblings = state.pop("_twinned_axes")

if twinned_siblings:

self._twinned_axes.join(*twinned_siblings)

self.__dict__ = state

self._stale = True

def __repr__(self):

fields = []

if self.get_label():

fields += [f"label={self.get_label()!r}"]

titles = []

for k in ["left", "center", "right"]:

title = self.get_title(loc=k)

if title:

titles.append(f"{k!r}:{title!r}")

if titles:

fields += ["title={" + ",".join(titles) + "}"]

if self.get_xlabel():

fields += [f"xlabel={self.get_xlabel()!r}"]

if self.get_ylabel():

fields += [f"ylabel={self.get_ylabel()!r}"]

return f"<{self.__class__.__name__}:" + ", ".join(fields) + ">"

def get_window_extent(self, *args, **kwargs):

"""

return self.bbox

def _init_axis(self):

# This is moved out of __init__ because non-separable axes don't use it

self.xaxis = maxis.XAxis(self)

self.spines.bottom.register_axis(self.xaxis)

self.spines.top.register_axis(self.xaxis)

self.yaxis = maxis.YAxis(self)

self.spines.left.register_axis(self.yaxis)

self.spines.right.register_axis(self.yaxis)

self._update_transScale()

def set_figure(self, fig):

# docstring inherited

super().set_figure(fig)

self.bbox = mtransforms.TransformedBbox(self._position,

fig.transSubfigure)

# these will be updated later as data is added

self.dataLim = mtransforms.Bbox.null()

self._viewLim = mtransforms.Bbox.unit()

self.transScale = mtransforms.TransformWrapper(

mtransforms.IdentityTransform())

self._set_lim_and_transforms()

def _unstale_viewLim(self):

# We should arrange to store this information once per share-group

# instead of on every axis.

need_scale = {

name: any(ax._stale_viewlims[name]

for ax in self._shared_axes[name].get_siblings(self))

for name in self._axis_names}

if any(need_scale.values()):

for name in need_scale:

for ax in self._shared_axes[name].get_siblings(self):

ax._stale_viewlims[name] = False

self.autoscale_view(**{f"scale{name}": scale

for name, scale in need_scale.items()})

@property

def viewLim(self):

self._unstale_viewLim()

return self._viewLim

# API could be better, right now this is just to match the old calls to

# autoscale_view() after each plotting method.

def _request_autoscale_view(self, tight=None, **kwargs):

# kwargs are "scalex", "scaley" (& "scalez" for 3D) and default to True

want_scale = {name: True for name in self._axis_names}

for k, v in kwargs.items(): # Validate args before changing anything.

if k.startswith("scale"):

name = k[5:]

if name in want_scale:

want_scale[name] = v

continue

raise TypeError(

f"_request_autoscale_view() got an unexpected argument {k!r}")

if tight is not None:

self._tight = tight

for k, v in want_scale.items():

if v:

self._stale_viewlims[k] = True # Else keep old state.

def _set_lim_and_transforms(self):

"""

self.transAxes = mtransforms.BboxTransformTo(self.bbox)

# Transforms the x and y axis separately by a scale factor.

# It is assumed that this part will have non-linear components

# (e.g., for a log scale).

self.transScale = mtransforms.TransformWrapper(

mtransforms.IdentityTransform())

# An affine transformation on the data, generally to limit the

# range of the axes

self.transLimits = mtransforms.BboxTransformFrom(

mtransforms.TransformedBbox(self._viewLim, self.transScale))

# The parentheses are important for efficiency here -- they

# group the last two (which are usually affines) separately

# from the first (which, with log-scaling can be non-affine).

self.transData = self.transScale + (self.transLimits + self.transAxes)

self._xaxis_transform = mtransforms.blended_transform_factory(

self.transData, self.transAxes)

self._yaxis_transform = mtransforms.blended_transform_factory(

self.transAxes, self.transData)

def get_xaxis_transform(self, which='grid'):

"""

if which == 'grid':

return self._xaxis_transform

elif which == 'tick1':

# for cartesian projection, this is bottom spine

return self.spines.bottom.get_spine_transform()

elif which == 'tick2':

# for cartesian projection, this is top spine

return self.spines.top.get_spine_transform()

else:

raise ValueError('unknown value for which')

def get_xaxis_text1_transform(self, pad_points):

"""

labels_align = mpl.rcParams["xtick.alignment"]

return (self.get_xaxis_transform(which='tick1') +

mtransforms.ScaledTranslation(0, -1 * pad_points / 72,

self.figure.dpi_scale_trans),

"top", labels_align)

def get_xaxis_text2_transform(self, pad_points):

"""

labels_align = mpl.rcParams["xtick.alignment"]

return (self.get_xaxis_transform(which='tick2') +

mtransforms.ScaledTranslation(0, pad_points / 72,

self.figure.dpi_scale_trans),

"bottom", labels_align)

def get_yaxis_transform(self, which='grid'):

"""

if which == 'grid':

return self._yaxis_transform

elif which == 'tick1':

# for cartesian projection, this is bottom spine

return self.spines.left.get_spine_transform()

elif which == 'tick2':

# for cartesian projection, this is top spine

return self.spines.right.get_spine_transform()

else:

raise ValueError('unknown value for which')

def get_yaxis_text1_transform(self, pad_points):

"""

labels_align = mpl.rcParams["ytick.alignment"]

return (self.get_yaxis_transform(which='tick1') +

mtransforms.ScaledTranslation(-1 * pad_points / 72, 0,

self.figure.dpi_scale_trans),

labels_align, "right")

def get_yaxis_text2_transform(self, pad_points):

"""

labels_align = mpl.rcParams["ytick.alignment"]

return (self.get_yaxis_transform(which='tick2') +

mtransforms.ScaledTranslation(pad_points / 72, 0,

self.figure.dpi_scale_trans),

labels_align, "left")

def _update_transScale(self):

self.transScale.set(

mtransforms.blended_transform_factory(

self.xaxis.get_transform(), self.yaxis.get_transform()))

for line in getattr(self, "_children", []): # Not set during init.

if not isinstance(line, mlines.Line2D):

continue

try:

line._transformed_path.invalidate()

except AttributeError: