"""

def __init__(self):

super().__init__()

self._ind = 0

def as_list(self):

"""

ia_list = [a for k, a in self._elements]

ia_list.sort()

return [a for i, a in ia_list]

def get(self, key):

"""

item = dict(self._elements).get(key)

if item is None:

return None

cbook.warn_deprecated(

"2.1",

message="Adding an axes using the same arguments as a previous "

"axes currently reuses the earlier instance. In a future "

"version, a new instance will always be created and returned. "

"Meanwhile, this warning can be suppressed, and the future "

"behavior ensured, by passing a unique label to each axes "

"instance.")

return item[1]

def _entry_from_axes(self, e):

ind, k = {a: (ind, k) for k, (ind, a) in self._elements}[e]

return (k, (ind, e))

def remove(self, a):

"""Remove the axes from the stack."""

super().remove(self._entry_from_axes(a))

def bubble(self, a):

"""

return super().bubble(self._entry_from_axes(a))

def add(self, key, a):

"""

# All the error checking may be unnecessary; but this method

# is called so seldom that the overhead is negligible.

cbook._check_isinstance(Axes, a=a)

try:

hash(key)

except TypeError:

key = object()

a_existing = self.get(key)

if a_existing is not None:

super().remove((key, a_existing))

cbook._warn_external(

"key {!r} already existed; Axes is being replaced".format(key))

# I don't think the above should ever happen.

if a in self:

return None

self._ind += 1

return super().push((key, (self._ind, a)))

def current_key_axes(self):

"""

if not len(self._elements):

return self._default, self._default

else:

key, (index, axes) = self._elements[self._pos]

return key, axes

def __call__(self):

return self.current_key_axes()[1]

def __contains__(self, a):

"""

def __init__(self, left=None, bottom=None, right=None, top=None,

wspace=None, hspace=None):

"""

self.validate = True

for key in ["left", "bottom", "right", "top", "wspace", "hspace"]:

setattr(self, key, mpl.rcParams[f"figure.subplot.{key}"])

self.update(left, bottom, right, top, wspace, hspace)

def update(self, left=None, bottom=None, right=None, top=None,

wspace=None, hspace=None):

"""

if self.validate:

if ((left if left is not None else self.left)

>= (right if right is not None else self.right)):

raise ValueError('left cannot be >= right')

if ((bottom if bottom is not None else self.bottom)

>= (top if top is not None else self.top)):

raise ValueError('bottom cannot be >= top')

if left is not None:

self.left = left

if right is not None:

self.right = right

if bottom is not None:

self.bottom = bottom

if top is not None:

self.top = top

if wspace is not None:

self.wspace = wspace

if hspace is not None:

"""

def __str__(self):

return "Figure(%gx%g)" % tuple(self.bbox.size)

def __repr__(self):

return "<{clsname} size {h:g}x{w:g} with {naxes} Axes>".format(

clsname=self.__class__.__name__,

h=self.bbox.size[0], w=self.bbox.size[1],

naxes=len(self.axes),

)

def __init__(self,

figsize=None,

dpi=None,

facecolor=None,

edgecolor=None,

linewidth=0.0,

frameon=None,

subplotpars=None, # rc figure.subplot.*

tight_layout=None, # rc figure.autolayout

constrained_layout=None, # rc figure.constrained_layout.use

):

"""

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.callbacks = cbook.CallbackRegistry()

if figsize is None:

figsize = mpl.rcParams['figure.figsize']

if dpi is None:

dpi = mpl.rcParams['figure.dpi']

if facecolor is None:

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

if edgecolor is None:

edgecolor = mpl.rcParams['figure.edgecolor']

if frameon is None:

frameon = mpl.rcParams['figure.frameon']

if not np.isfinite(figsize).all() or (np.array(figsize) <= 0).any():

raise ValueError('figure size must be positive finite not '

f'{figsize}')

self.bbox_inches = Bbox.from_bounds(0, 0, *figsize)

self.dpi_scale_trans = Affine2D().scale(dpi)

# do not use property as it will trigger

self._dpi = dpi

self.bbox = TransformedBbox(self.bbox_inches, self.dpi_scale_trans)

self.transFigure = BboxTransformTo(self.bbox)

self.patch = Rectangle(

xy=(0, 0), width=1, height=1, visible=frameon,

facecolor=facecolor, edgecolor=edgecolor, linewidth=linewidth,

# Don't let the figure patch influence bbox calculation.

in_layout=False)

self._set_artist_props(self.patch)

self.patch.set_antialiased(False)

FigureCanvasBase(self) # Set self.canvas.

self._suptitle = None

if subplotpars is None:

subplotpars = SubplotParams()

self.subplotpars = subplotpars

# constrained_layout:

self._layoutbox = None

# set in set_constrained_layout_pads()

self.set_constrained_layout(constrained_layout)

self.set_tight_layout(tight_layout)

self._axstack = _AxesStack() # track all figure axes and current axes

self.clf()

self._cachedRenderer = None

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

# see self.align_xlabels and self.align_ylabels and

# axis._get_tick_boxes_siblings

self._align_xlabel_grp = cbook.Grouper()

self._align_ylabel_grp = cbook.Grouper()

# list of child gridspecs for this figure

self._gridspecs = []

# TODO: I'd like to dynamically add the _repr_html_ method

# to the figure in the right context, but then IPython doesn't

# use it, for some reason.

def _repr_html_(self):

# We can't use "isinstance" here, because then we'd end up importing

# webagg unconditionally.

if 'WebAgg' in type(self.canvas).__name__:

from matplotlib.backends import backend_webagg

return backend_webagg.ipython_inline_display(self)

def show(self, warn=True):

"""

if self.canvas.manager is None:

raise AttributeError(

"Figure.show works only for figures managed by pyplot, "

"normally created by pyplot.figure()")

try:

self.canvas.manager.show()

except NonGuiException as exc:

cbook._warn_external(str(exc))

def get_axes(self):

"""

return self._axstack.as_list()

axes = property(get_axes, doc="""

""")

def _get_dpi(self):

return self._dpi

def _set_dpi(self, dpi, forward=True):

"""

if dpi == self._dpi:

# We don't want to cause undue events in backends.

return

self._dpi = dpi

self.dpi_scale_trans.clear().scale(dpi)

w, h = self.get_size_inches()

self.set_size_inches(w, h, forward=forward)

self.callbacks.process('dpi_changed', self)

dpi = property(_get_dpi, _set_dpi, doc="The resolution in dots per inch.")

def get_tight_layout(self):

"""Return whether `.tight_layout` is called when drawing."""

return self._tight

def set_tight_layout(self, tight):

"""

if tight is None:

tight = mpl.rcParams['figure.autolayout']

self._tight = bool(tight)

self._tight_parameters = tight if isinstance(tight, dict) else {}

self.stale = True

def get_constrained_layout(self):

"""

return self._constrained

def set_constrained_layout(self, constrained):

"""

self._constrained_layout_pads = dict()

self._constrained_layout_pads['w_pad'] = None

self._constrained_layout_pads['h_pad'] = None

self._constrained_layout_pads['wspace'] = None

self._constrained_layout_pads['hspace'] = None

if constrained is None:

constrained = mpl.rcParams['figure.constrained_layout.use']

self._constrained = bool(constrained)

if isinstance(constrained, dict):

self.set_constrained_layout_pads(**constrained)

else:

self.set_constrained_layout_pads()

self.stale = True

def set_constrained_layout_pads(self, **kwargs):

"""

todo = ['w_pad', 'h_pad', 'wspace', 'hspace']

for td in todo:

if td in kwargs and kwargs[td] is not None:

self._constrained_layout_pads[td] = kwargs[td]

else:

self._constrained_layout_pads[td] = (

mpl.rcParams['figure.constrained_layout.' + td])

def get_constrained_layout_pads(self, relative=False):

"""

w_pad = self._constrained_layout_pads['w_pad']

h_pad = self._constrained_layout_pads['h_pad']

wspace = self._constrained_layout_pads['wspace']

hspace = self._constrained_layout_pads['hspace']

if relative and (w_pad is not None or h_pad is not None):

renderer0 = layoutbox.get_renderer(self)

dpi = renderer0.dpi

w_pad = w_pad * dpi / renderer0.width

h_pad = h_pad * dpi / renderer0.height

return w_pad, h_pad, wspace, hspace

def autofmt_xdate(

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

"""

if which is None:

cbook.warn_deprecated(

"3.3", message="Support for passing which=None to mean "

"which='major' is deprecated since %(since)s and will be "

"removed %(removal)s.")

allsubplots = all(hasattr(ax, 'is_last_row') for ax in self.axes)

if len(self.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 self.get_axes():

if ax.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('')

if allsubplots:

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.axes,

*self.lines,

*self.patches,

*self.texts,

*self.images,

*self.legends]

def contains(self, mouseevent):

"""

inside, info = self._default_contains(mouseevent, figure=self)

if inside is not None:

return inside, info

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

return inside, {}

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

"""

return self.bbox

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

"""

manual_position = ('x' in kwargs or 'y' in kwargs)

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

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

if 'horizontalalignment' not in kwargs and 'ha' not in kwargs:

kwargs['horizontalalignment'] = 'center'

if 'verticalalignment' not in kwargs and 'va' not in kwargs:

kwargs['verticalalignment'] = 'top'

if 'fontproperties' not in kwargs:

if 'fontsize' not in kwargs and 'size' not in kwargs:

kwargs['size'] = mpl.rcParams['figure.titlesize']

if 'fontweight' not in kwargs and 'weight' not in kwargs:

kwargs['weight'] = mpl.rcParams['figure.titleweight']

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

if self._suptitle is not None:

self._suptitle.set_text(t)

self._suptitle.set_position((x, y))

self._suptitle.update_from(sup)

sup.remove()

else:

self._suptitle = sup

self._suptitle._layoutbox = None

if self._layoutbox is not None and not manual_position:

w_pad, h_pad, wspace, hspace = \

self.get_constrained_layout_pads(relative=True)

figlb = self._layoutbox

self._suptitle._layoutbox = layoutbox.LayoutBox(

parent=figlb, artist=self._suptitle,

name=figlb.name+'.suptitle')

# stack the suptitle on top of all the children.

# Some day this should be on top of all the children in the

# gridspec only.

for child in figlb.children:

if child is not self._suptitle._layoutbox:

layoutbox.vstack([self._suptitle._layoutbox,

child],

padding=h_pad*2., strength='required')

self.stale = True

return self._suptitle

def set_canvas(self, canvas):

"""

self.canvas = canvas

def figimage(self, X, xo=0, yo=0, alpha=None, norm=None, cmap=None,

vmin=None, vmax=None, origin=None, resize=False, **kwargs):

"""

if resize:

dpi = self.get_dpi()

figsize = [x / dpi for x in (X.shape[1], X.shape[0])]

self.set_size_inches(figsize, forward=True)

im = mimage.FigureImage(self, cmap, norm, xo, yo, origin, **kwargs)

im.stale_callback = _stale_figure_callback

im.set_array(X)

im.set_alpha(alpha)

if norm is None:

im.set_clim(vmin, vmax)

self.images.append(im)

im._remove_method = self.images.remove

self.stale = True

return im

def set_size_inches(self, w, h=None, forward=True):

"""

if h is None: # Got called with a single pair as argument.

w, h = w

size = np.array([w, h])

if not np.isfinite(size).all() or (size <= 0).any():

raise ValueError(f'figure size must be positive finite not {size}')

self.bbox_inches.p1 = size

if forward:

canvas = getattr(self, 'canvas')

if canvas is not None:

dpi_ratio = getattr(canvas, '_dpi_ratio', 1)

manager = getattr(canvas, 'manager', None)

if manager is not None:

manager.resize(*(size * self.dpi / dpi_ratio).astype(int))

self.stale = True

def get_size_inches(self):

"""

return np.array(self.bbox_inches.p1)

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_figwidth(self):

"""Return the figure width in inches."""

return self.bbox_inches.width

def get_figheight(self):

"""Return the figure height in inches."""

return self.bbox_inches.height

def get_dpi(self):

"""Return the resolution in dots per inch as a float."""

return self.dpi

def get_frameon(self):

"""

return self.patch.get_visible()

def set_edgecolor(self, color):

"""

self.patch.set_edgecolor(color)

def set_facecolor(self, color):

"""

self.patch.set_facecolor(color)

def set_dpi(self, val):

"""

self.dpi = val

self.stale = True

def set_figwidth(self, val, forward=True):

"""

self.set_size_inches(val, self.get_figheight(), forward=forward)

def set_figheight(self, val, forward=True):

"""