"""

def __init__(self):

self._axes = {} # Mapping of Axes to "gca" order.

self._counter = itertools.count()

def as_list(self):

"""List the Axes that have been added to the figure."""

return [*self._axes] # This relies on dict preserving order.

def remove(self, a):

"""Remove the Axes from the stack."""

self._axes.pop(a)

def bubble(self, a):

"""Move an Axes, which must already exist in the stack, to the top."""

if a not in self._axes:

raise ValueError("Axes has not been added yet")

self._axes[a] = next(self._counter)

def add(self, a):

"""Add an Axes to the stack, ignoring it if already present."""

if a not in self._axes:

self._axes[a] = next(self._counter)

def current(self):

"""Return the active Axes, or None if the stack is empty."""

return max(self._axes, key=self._axes.__getitem__, default=None)

def __getstate__(self):

return {

**vars(self),

"_counter": max(self._axes.values(), default=0)

}

def __setstate__(self, state):

next_counter = state.pop('_counter')

vars(self).update(state)

"""

def __init__(self, **kwargs):

super().__init__()

# remove the non-figure artist _axes property

# as it makes no sense for a figure to be _in_ an Axes

# this is used by the property methods in the artist base class

# which are over-ridden in this class

del self._axes

self._suptitle = None

self._supxlabel = None

self._supylabel = None

# groupers to keep track of x, y labels and title we want to align.

# see self.align_xlabels, self.align_ylabels,

# self.align_titles, and axis._get_tick_boxes_siblings

self._align_label_groups = {

"x": cbook.Grouper(),

"y": cbook.Grouper(),

"title": cbook.Grouper()

}

self._localaxes = [] # track all Axes

self.artists = []

self.lines = []

self.patches = []

self.texts = []

self.images = []

self.legends = []

self.subfigs = []

self.stale = True

self.suppressComposite = None

self.set(**kwargs)

def _get_draw_artists(self, renderer):

"""Also runs apply_aspect"""

artists = self.get_children()

artists.remove(self.patch)

artists = sorted(

(artist for artist in artists if not artist.get_animated()),

key=lambda artist: artist.get_zorder())

for ax in self._localaxes:

locator = ax.get_axes_locator()

ax.apply_aspect(locator(ax, renderer) if locator else None)

for child in ax.get_children():

if hasattr(child, 'apply_aspect'):

locator = child.get_axes_locator()

child.apply_aspect(

locator(child, renderer) if locator else None)

return artists

def autofmt_xdate(

self, bottom=0.2, rotation=30, ha='right', which='major'):

"""

_api.check_in_list(['major', 'minor', 'both'], which=which)

axes = [ax for ax in self.axes if ax._label != '<colorbar>']

allsubplots = all(ax.get_subplotspec() for ax in axes)

if len(axes) == 1:

for label in self.axes[0].get_xticklabels(which=which):

label.set_ha(ha)

label.set_rotation(rotation)

else:

if allsubplots:

for ax in axes:

if ax.get_subplotspec().is_last_row():

for label in ax.get_xticklabels(which=which):

label.set_ha(ha)

label.set_rotation(rotation)

else:

for label in ax.get_xticklabels(which=which):

label.set_visible(False)

ax.set_xlabel('')

engine = self.get_layout_engine()

if allsubplots and (engine is None or engine.adjust_compatible):

self.subplots_adjust(bottom=bottom)

self.stale = True

def get_children(self):

"""Get a list of artists contained in the figure."""

return [self.patch,

*self.artists,

*self._localaxes,

*self.lines,

*self.patches,

*self.texts,

*self.images,

*self.legends,

*self.subfigs]

def get_figure(self, root=None):

"""

if self._root_figure is self:

# Top level Figure

return self

if self._parent is self._root_figure:

# Return early to prevent the deprecation warning when *root* does not

# matter

return self._parent

if root is None:

# When deprecation expires, consider removing the docstring and just

# inheriting the one from Artist.

message = ('From Matplotlib 3.12 SubFigure.get_figure will by default '

'return the direct parent figure, which may be a SubFigure. '

'To suppress this warning, pass the root parameter. Pass '

'`True` to maintain the old behavior and `False` to opt-in to '

'the future behavior.')

_api.warn_deprecated('3.10', message=message)

root = True

if root:

return self._root_figure

return self._parent

def set_figure(self, fig):

"""

no_switch = ("The parent and root figures of a (Sub)Figure are set at "

"instantiation and cannot be changed.")

if fig is self._root_figure:

_api.warn_deprecated(

"3.10",

message=(f"{no_switch} From Matplotlib 3.12 this operation will raise "

"an exception."))

return

raise ValueError(no_switch)

figure = property(functools.partial(get_figure, root=True), set_figure,

doc=("The root `Figure`. To get the parent of a `SubFigure`, "

"use the `get_figure` method."))

def contains(self, mouseevent):

"""

if self._different_canvas(mouseevent):

return False, {}

inside = self.bbox.contains(mouseevent.x, mouseevent.y)

return inside, {}

def get_window_extent(self, renderer=None):

# docstring inherited

return self.bbox

def _suplabels(self, t, info, **kwargs):

"""

x = kwargs.pop('x', None)

y = kwargs.pop('y', None)

if info['name'] in ['_supxlabel', '_suptitle']:

autopos = y is None

elif info['name'] == '_supylabel':

autopos = x is None

if x is None:

x = info['x0']

if y is None:

y = info['y0']

kwargs = cbook.normalize_kwargs(kwargs, Text)

kwargs.setdefault('horizontalalignment', info['ha'])

kwargs.setdefault('verticalalignment', info['va'])

kwargs.setdefault('rotation', info['rotation'])

if 'fontproperties' not in kwargs:

kwargs.setdefault('fontsize', mpl.rcParams[info['size']])

kwargs.setdefault('fontweight', mpl.rcParams[info['weight']])

suplab = getattr(self, info['name'])

if suplab is not None:

suplab.set_text(t)

suplab.set_position((x, y))

suplab.set(**kwargs)

else:

suplab = self.text(x, y, t, **kwargs)

setattr(self, info['name'], suplab)

suplab._remove_method = functools.partial(self._remove_suplabel,

name=info['name'])

suplab._autopos = autopos

self.stale = True

return suplab

def _remove_suplabel(self, label, name):

self.texts.remove(label)

setattr(self, name, None)

@_docstring.Substitution(x0=0.5, y0=0.98, name='super title', ha='center',

@_docstring.copy(_suplabels)

def suptitle(self, t, **kwargs):

# docstring from _suplabels...

info = {'name': '_suptitle', 'x0': 0.5, 'y0': 0.98,

'ha': 'center', 'va': 'top', 'rotation': 0,

'size': 'figure.titlesize', 'weight': 'figure.titleweight'}

return self._suplabels(t, info, **kwargs)

def get_suptitle(self):

"""Return the suptitle as string or an empty string if not set."""

text_obj = self._suptitle

return "" if text_obj is None else text_obj.get_text()

@_docstring.Substitution(x0=0.5, y0=0.01, name='super xlabel', ha='center',

@_docstring.copy(_suplabels)

def supxlabel(self, t, **kwargs):

# docstring from _suplabels...

info = {'name': '_supxlabel', 'x0': 0.5, 'y0': 0.01,

'ha': 'center', 'va': 'bottom', 'rotation': 0,

'size': 'figure.labelsize', 'weight': 'figure.labelweight'}

return self._suplabels(t, info, **kwargs)

def get_supxlabel(self):

"""Return the supxlabel as string or an empty string if not set."""

text_obj = self._supxlabel

return "" if text_obj is None else text_obj.get_text()

@_docstring.Substitution(x0=0.02, y0=0.5, name='super ylabel', ha='left',

@_docstring.copy(_suplabels)

def supylabel(self, t, **kwargs):

# docstring from _suplabels...

info = {'name': '_supylabel', 'x0': 0.02, 'y0': 0.5,

'ha': 'left', 'va': 'center', 'rotation': 'vertical',

'rotation_mode': 'anchor', 'size': 'figure.labelsize',

'weight': 'figure.labelweight'}

return self._suplabels(t, info, **kwargs)

def get_supylabel(self):

"""Return the supylabel as string or an empty string if not set."""

text_obj = self._supylabel

return "" if text_obj is None else text_obj.get_text()

def get_edgecolor(self):

"""Get the edge color of the Figure rectangle."""

return self.patch.get_edgecolor()

def get_facecolor(self):

"""Get the face color of the Figure rectangle."""

return self.patch.get_facecolor()

def get_frameon(self):

"""

return self.patch.get_visible()

def set_linewidth(self, linewidth):

"""

self.patch.set_linewidth(linewidth)

def get_linewidth(self):

"""

return self.patch.get_linewidth()

def set_edgecolor(self, color):

"""

self.patch.set_edgecolor(color)

def set_facecolor(self, color):

"""

self.patch.set_facecolor(color)

def set_frameon(self, b):

"""

self.patch.set_visible(b)

self.stale = True

frameon = property(get_frameon, set_frameon)

def add_artist(self, artist, clip=False):

"""

artist.set_figure(self)

self.artists.append(artist)

artist._remove_method = self.artists.remove

if not artist.is_transform_set():

artist.set_transform(self.transSubfigure)

if clip and artist.get_clip_path() is None:

artist.set_clip_path(self.patch)

self.stale = True

return artist

@_docstring.interpd

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

"""

if not len(args) and 'rect' not in kwargs:

raise TypeError("add_axes() missing 1 required positional argument: 'rect'")

elif 'rect' in kwargs:

if len(args):

raise TypeError("add_axes() got multiple values for argument 'rect'")

args = (kwargs.pop('rect'), )

if len(args) != 1:

raise _api.nargs_error("add_axes", 1, len(args))

if isinstance(args[0], Axes):

a, = args

key = a._projection_init

if a.get_figure(root=False) is not self:

raise ValueError(

"The Axes must have been created in the present figure")

else:

rect, = args

if not np.isfinite(rect).all():

raise ValueError(f'all entries in rect must be finite not {rect}')

projection_class, pkw = self._process_projection_requirements(**kwargs)

# create the new Axes using the Axes class given

a = projection_class(self, rect, **pkw)

key = (projection_class, pkw)

return self._add_axes_internal(a, key)

@_docstring.interpd

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

"""

if 'figure' in kwargs:

# Axes itself allows for a 'figure' kwarg, but since we want to

# bind the created Axes to self, it is not allowed here.

raise _api.kwarg_error("add_subplot", "figure")

if (len(args) == 1

and isinstance(args[0], mpl.axes._base._AxesBase)

and args[0].get_subplotspec()):

ax = args[0]

key = ax._projection_init

if ax.get_figure(root=False) is not self:

raise ValueError("The Axes must have been created in "

"the present figure")

else:

if not args:

args = (1, 1, 1)

# Normalize correct ijk values to (i, j, k) here so that

# add_subplot(211) == add_subplot(2, 1, 1). Invalid values will

# trigger errors later (via SubplotSpec._from_subplot_args).

if (len(args) == 1 and isinstance(args[0], Integral)

and 100 <= args[0] <= 999):

args = tuple(map(int, str(args[0])))

projection_class, pkw = self._process_projection_requirements(**kwargs)

ax = projection_class(self, *args, **pkw)

key = (projection_class, pkw)

return self._add_axes_internal(ax, key)

def _add_axes_internal(self, ax, key):

"""Private helper for `add_axes` and `add_subplot`."""

self._axstack.add(ax)

if ax not in self._localaxes:

self._localaxes.append(ax)

self.sca(ax)

ax._remove_method = self.delaxes

# this is to support plt.subplot's re-selection logic

ax._projection_init = key

self.stale = True

ax.stale_callback = _stale_figure_callback

return ax

def subplots(self, nrows=1, ncols=1, *, sharex=False, sharey=False,

squeeze=True, width_ratios=None, height_ratios=None,

subplot_kw=None, gridspec_kw=None):

"""

gridspec_kw = dict(gridspec_kw or {})

if height_ratios is not None:

if 'height_ratios' in gridspec_kw:

raise ValueError("'height_ratios' must not be defined both as "

"parameter and as key in 'gridspec_kw'")

gridspec_kw['height_ratios'] = height_ratios

if width_ratios is not None:

if 'width_ratios' in gridspec_kw:

raise ValueError("'width_ratios' must not be defined both as "

"parameter and as key in 'gridspec_kw'")

gridspec_kw['width_ratios'] = width_ratios

gs = self.add_gridspec(nrows, ncols, figure=self, **gridspec_kw)

axs = gs.subplots(sharex=sharex, sharey=sharey, squeeze=squeeze,

subplot_kw=subplot_kw)

return axs

def delaxes(self, ax):

"""

self._remove_axes(ax, owners=[self._axstack, self._localaxes])

def _remove_axes(self, ax, owners):

"""

for owner in owners:

owner.remove(ax)

self._axobservers.process("_axes_change_event", self)

self.stale = True

self._root_figure.canvas.release_mouse(ax)

for name in ax._axis_names: # Break link between any shared Axes

grouper = ax._shared_axes[name]

siblings = [other for other in grouper.get_siblings(ax) if other is not ax]

if not siblings: # Axes was not shared along this axis; we're done.

continue

grouper.remove(ax)

# Formatters and locators may previously have been associated with the now

# removed axis. Update them to point to an axis still there (we can pick

# any of them, and use the first sibling).

remaining_axis = siblings[0]._axis_map[name]

remaining_axis.get_major_formatter().set_axis(remaining_axis)

remaining_axis.get_major_locator().set_axis(remaining_axis)

remaining_axis.get_minor_formatter().set_axis(remaining_axis)

remaining_axis.get_minor_locator().set_axis(remaining_axis)

ax._twinned_axes.remove(ax) # Break link between any twinned Axes.

def clear(self, keep_observers=False):

"""

self.suppressComposite = None

# first clear the Axes in any subfigures

for subfig in self.subfigs:

subfig.clear(keep_observers=keep_observers)

self.subfigs = []

for ax in tuple(self.axes): # Iterate over the copy.

ax.clear()

self.delaxes(ax) # Remove ax from self._axstack.

self.artists = []

self.lines = []

self.patches = []

self.texts = []

self.images = []

self.legends = []

if not keep_observers:

self._axobservers = cbook.CallbackRegistry()