from collections import OrderedDict

from collections.abc import MutableSequence

from contextlib import ExitStack

import functools

import inspect

import itertools

import logging

from numbers import Real

from operator import attrgetter

import types

import numpy as np

import matplotlib as mpl

from matplotlib import _api, cbook, docstring

import matplotlib.artist as martist

import matplotlib.axis as maxis

from matplotlib.cbook import _OrderedSet, _check_1d, index_of

import matplotlib.collections as mcoll

import matplotlib.colors as mcolors

import matplotlib.font_manager as font_manager

import matplotlib.image as mimage

import matplotlib.lines as mlines

import matplotlib.patches as mpatches

import matplotlib.path as mpath

from matplotlib.rcsetup import cycler, validate_axisbelow

import matplotlib.spines as mspines

import matplotlib.table as mtable

import matplotlib.text as mtext

import matplotlib.ticker as mticker

import matplotlib.transforms as mtransforms

_log = logging.getLogger(__name__)

class _axis_method_wrapper:

"""

Helper to generate Axes methods wrapping Axis methods.

After ::

get_foo = _axis_method_wrapper("xaxis", "get_bar")

(in the body of a class) ``get_foo`` is a method that forwards it arguments

to the ``get_bar`` method of the ``xaxis`` attribute, and gets its

signature and docstring from ``Axis.get_bar``.

The docstring of ``get_foo`` is built by replacing "this Axis" by "the

{attr_name}" (i.e., "the xaxis", "the yaxis") in the wrapped method's

dedented docstring; additional replacements can by given in *doc_sub*.

"""

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

setattr(owner, name, wrapper)

class _TransformedBoundsLocator:

"""

Axes locator for `.Axes.inset_axes` and similarly positioned Axes.

The locator is a callable object used in `.Axes.set_aspect` to compute the

axes location depending on the renderer.

"""

def __init__(self, bounds, transform):

"""

*bounds* (a ``[l, b, w, h]`` rectangle) and *transform* together

specify the position of the inset Axes.

"""

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

self._transform - ax.figure.transSubfigure)

def _process_plot_format(fmt):

"""

Convert a MATLAB style color/line style format string to a (*linestyle*,

*marker*, *color*) tuple.

Example format strings include:

* 'ko': black circles

* '.b': blue dots

* 'r--': red dashed lines

* 'C2--': the third color in the color cycle, dashed lines

The format is absolute in the sense that if a linestyle or marker is not

defined in *fmt*, there is no line or marker. This is expressed by

returning 'None' for the respective quantity.

See Also

--------

matplotlib.Line2D.lineStyles, matplotlib.colors.cnames

All possible styles and color format strings.

"""

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'

return linestyle, marker, color

class _process_plot_var_args:

"""

Process variable length arguments to `~.Axes.plot`, to support ::

plot(t, s)

plot(t1, s1, t2, s2)

plot(t1, s1, 'ko', t2, s2)

plot(t1, s1, 'ko', t2, s2, 'r--', t3, e3)

an arbitrary number of *x*, *y*, *fmt* are allowed

"""

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

"""

If some keys in the property cycle (excluding those in the set

*ignore*) are absent or set to None in the dict *kw*, return a copy

of the next entry in the property cycle, excluding keys in *ignore*.

Otherwise, don't advance the property cycle, and return an empty dict.

"""

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

"""

Add to the dict *kw* the entries in the dict *default* that are absent

or set to None in *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):

"""

Process the arguments of ``plot([x], y, [fmt], **kwargs)`` calls.

This processes a single set of ([x], y, [fmt]) parameters; i.e. for

``plot(x, y, x2, y2)`` it will be called twice. Once for (x, y) and

once for (x2, y2).

x and y may be 2D and thus can still represent multiple datasets.

For multiple datasets, if the keyword argument *label* is a list, this

will unpack the list and assign the individual labels to the datasets.

Parameters

----------

tup : tuple

A tuple of the positional parameters. This can be one of

- (y,)

- (x, y)

- (y, fmt)

- (x, y, fmt)

kwargs : dict

The keyword arguments passed to ``plot()``.

return_kwargs : bool

If true, return the effective keyword arguments after label

unpacking as well.

Returns

-------

result

If *return_kwargs* is false, a list of Artists representing the

dataset(s).

If *return_kwargs* is true, a list of (Artist, effective_kwargs)

representing the dataset(s). See *return_kwargs*.

The Artist is either `.Line2D` (if called from ``plot()``) or

`.Polygon` otherwise.

"""

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:

return [l[0] for l in result]

@cbook._define_aliases({"facecolor": ["fc"]})

class _AxesBase(martist.Artist):

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

):

"""

Build an Axes in a figure.

Parameters

----------

fig : `~matplotlib.figure.Figure`

The Axes is built in the `.Figure` *fig*.

rect : [left, bottom, width, height]

The Axes is built in the rectangle *rect*. *rect* is in

`.Figure` coordinates.

sharex, sharey : `~.axes.Axes`, optional

The x or y `~.matplotlib.axis` is shared with the x or

y axis in the input `~.axes.Axes`.

frameon : bool, default: True

Whether the Axes frame is visible.

box_aspect : float, optional

Set a fixed aspect for the Axes box, i.e. the ratio of height to

width. See `~.axes.Axes.set_box_aspect` for details.

**kwargs

Other optional keyword arguments:

%(Axes:kwdoc)s

Returns

-------

`~.axes.Axes`

The new `~.axes.Axes` object.

"""

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"]:

if hasattr(self, 'get_title'):

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 the Axes bounding box in display space; *args* and *kwargs*

are empty.

This bounding box does not include the spines, ticks, ticklables,

or other labels. For a bounding box including these elements use

`~matplotlib.axes.Axes.get_tightbbox`.

See Also

--------

matplotlib.axes.Axes.get_tightbbox

matplotlib.axis.Axis.get_tightbbox

matplotlib.spines.Spine.get_window_extent

"""

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

"""

Set the *_xaxis_transform*, *_yaxis_transform*, *transScale*,

*transData*, *transLimits* and *transAxes* transformations.

.. note::

This method is primarily used by rectilinear projections of the

`~matplotlib.axes.Axes` class, and is meant to be overridden by

new kinds of projection Axes that need different transformations

and limits. (See `~matplotlib.projections.polar.PolarAxes` for an

example.)

"""

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

"""

Get the transformation used for drawing x-axis labels, ticks

and gridlines. The x-direction is in data coordinates and the

y-direction is in axis coordinates.

.. note::

This transformation is primarily used by the

`~matplotlib.axis.Axis` class, and is meant to be

overridden by new kinds of projections that may need to

place axis elements in different locations.

"""

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

"""

Returns

-------

transform : Transform

The transform used for drawing x-axis labels, which will add

*pad_points* of padding (in points) between the axis and the label.

The x-direction is in data coordinates and the y-direction is in

axis coordinates

valign : {'center', 'top', 'bottom', 'baseline', 'center_baseline'}

The text vertical alignment.

halign : {'center', 'left', 'right'}

The text horizontal alignment.

Notes

-----

This transformation is primarily used by the `~matplotlib.axis.Axis`

class, and is meant to be overridden by new kinds of projections that

may need to place axis elements in different locations.

"""

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

"""

Returns

-------

transform : Transform

The transform used for drawing secondary x-axis labels, which will

add *pad_points* of padding (in points) between the axis and the

label. The x-direction is in data coordinates and the y-direction

is in axis coordinates

valign : {'center', 'top', 'bottom', 'baseline', 'center_baseline'}

The text vertical alignment.

halign : {'center', 'left', 'right'}

The text horizontal alignment.

Notes

-----

This transformation is primarily used by the `~matplotlib.axis.Axis`

class, and is meant to be overridden by new kinds of projections that

may need to place axis elements in different locations.

"""

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

"""

Get the transformation used for drawing y-axis labels, ticks

and gridlines. The x-direction is in axis coordinates and the

y-direction is in data coordinates.

.. note::

This transformation is primarily used by the

`~matplotlib.axis.Axis` class, and is meant to be

overridden by new kinds of projections that may need to

place axis elements in different locations.

"""

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

"""

Returns

-------

transform : Transform

The transform used for drawing y-axis labels, which will add

*pad_points* of padding (in points) between the axis and the label.

The x-direction is in axis coordinates and the y-direction is in

data coordinates

valign : {'center', 'top', 'bottom', 'baseline', 'center_baseline'}

The text vertical alignment.

halign : {'center', 'left', 'right'}

The text horizontal alignment.

Notes

-----

This transformation is primarily used by the `~matplotlib.axis.Axis`

class, and is meant to be overridden by new kinds of projections that

may need to place axis elements in different locations.

"""

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

"""

Returns

-------

transform : Transform

The transform used for drawing secondart y-axis labels, which will

add *pad_points* of padding (in points) between the axis and the

label. The x-direction is in axis coordinates and the y-direction

is in data coordinates

valign : {'center', 'top', 'bottom', 'baseline', 'center_baseline'}

The text vertical alignment.

halign : {'center', 'left', 'right'}

The text horizontal alignment.

Notes

-----

This transformation is primarily used by the `~matplotlib.axis.Axis`

class, and is meant to be overridden by new kinds of projections that

may need to place axis elements in different locations.

"""

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