"""

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 transFigure will typically rely on inverted(), freezing

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

# transFigure 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()

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()

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

# Can't do `args == (None,)` as that crashes cycler.

if not (args or kwargs) or (len(args) == 1 and args[0] is None):

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

else:

prop_cycler = cycler(*args, **kwargs)

self.prop_cycler = itertools.cycle(prop_cycler)

# This should make a copy

self._prop_keys = prop_cycler.keys

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)

cbook._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

# 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):

linestyle, marker, color = _process_plot_format(tup[-1])

tup = tup[:-1]

elif len(tup) == 3:

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

else:

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 k, v in zip(('linestyle', 'marker', 'color'),

(linestyle, marker, color)):

if v is not None:

kw[k] = v

if len(tup) == 2:

x = _check_1d(tup[0])

y = _check_1d(tup[-1])

else:

x, y = index_of(tup[-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':

func = self._makeline

else:

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

func = 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")

result = (func(x[:, j % ncx], y[:, j % ncy], kw, kwargs)

for j in range(max(ncx, ncy)))

if return_kwargs:

return list(result)

else:

name = "rectilinear"

_shared_x_axes = cbook.Grouper()

_shared_y_axes = cbook.Grouper()

_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)

@cbook._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_viewlim_x = False

self._stale_viewlim_y = False

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 = 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)

if self.xaxis is not None:

self._xcid = self.xaxis.callbacks.connect(

'units finalize', lambda: self._on_units_changed(scalex=True))

if self.yaxis is not None:

self._ycid = self.yaxis.callbacks.connect(

'units finalize', lambda: self._on_units_changed(scaley=True))

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.

for grouper_name in [

'_shared_x_axes', '_shared_y_axes', '_twinned_axes']:

grouper = getattr(self, grouper_name)

state[grouper_name] = (grouper.get_siblings(self)

if self in grouper else None)

return state

def __setstate__(self, state):

# Merge the grouping info back into the global groupers.

for grouper_name in [

'_shared_x_axes', '_shared_y_axes', '_twinned_axes']:

siblings = state.pop(grouper_name)

if siblings:

getattr(self, grouper_name).join(*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.

scalex = any(ax._stale_viewlim_x

for ax in self._shared_x_axes.get_siblings(self))

scaley = any(ax._stale_viewlim_y

for ax in self._shared_y_axes.get_siblings(self))

if scalex or scaley:

for ax in self._shared_x_axes.get_siblings(self):

ax._stale_viewlim_x = False

for ax in self._shared_y_axes.get_siblings(self):

ax._stale_viewlim_y = False

self.autoscale_view(scalex=scalex, scaley=scaley)

@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, scalex=True, scaley=True):

if tight is not None:

self._tight = tight

if scalex:

self._stale_viewlim_x = True # Else keep old state.

if scaley:

self._stale_viewlim_y = True

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, "lines", []): # Not set during init.

try:

line._transformed_path.invalidate()

except AttributeError:

pass

def get_position(self, original=False):

"""

if original:

return self._originalPosition.frozen()

else:

locator = self.get_axes_locator()

if not locator:

self.apply_aspect()

return self._position.frozen()

def set_position(self, pos, which='both'):

"""

self._set_position(pos, which=which)

# because this is being called externally to the library we

# don't let it be in the layout.

self.set_in_layout(False)

def _set_position(self, pos, which='both'):

"""

if not isinstance(pos, mtransforms.BboxBase):

pos = mtransforms.Bbox.from_bounds(*pos)

for ax in self._twinned_axes.get_siblings(self):

if which in ('both', 'active'):

ax._position.set(pos)

if which in ('both', 'original'):

ax._originalPosition.set(pos)

self.stale = True

def reset_position(self):

"""

for ax in self._twinned_axes.get_siblings(self):

pos = ax.get_position(original=True)

ax.set_position(pos, which='active')

def set_axes_locator(self, locator):

"""

self._axes_locator = locator

self.stale = True