"""

### Labelling, legend and texts

def get_title(self, loc="center"):

"""

titles = {'left': self._left_title,

'center': self.title,

'right': self._right_title}

title = _api.check_getitem(titles, loc=loc.lower())

return title.get_text()

def set_title(self, label, fontdict=None, loc=None, pad=None, *, y=None,

**kwargs):

"""

if loc is None:

loc = mpl.rcParams['axes.titlelocation']

if y is None:

y = mpl.rcParams['axes.titley']

if y is None:

y = 1.0

else:

self._autotitlepos = False

kwargs['y'] = y

titles = {'left': self._left_title,

'center': self.title,

'right': self._right_title}

title = _api.check_getitem(titles, loc=loc.lower())

default = {

'fontsize': mpl.rcParams['axes.titlesize'],

'fontweight': mpl.rcParams['axes.titleweight'],

'verticalalignment': 'baseline',

'horizontalalignment': loc.lower()}

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

if not cbook._str_lower_equal(titlecolor, 'auto'):

default["color"] = titlecolor

if pad is None:

pad = mpl.rcParams['axes.titlepad']

self._set_title_offset_trans(float(pad))

title.set_text(label)

title.update(default)

if fontdict is not None:

title.update(fontdict)

title._internal_update(kwargs)

return title

def get_legend_handles_labels(self, legend_handler_map=None):

"""

# pass through to legend.

handles, labels = mlegend._get_legend_handles_labels(

[self], legend_handler_map)

return handles, labels

@_docstring.dedent_interpd

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

"""

handles, labels, extra_args, kwargs = mlegend._parse_legend_args(

[self],

*args,

**kwargs)

if len(extra_args):

raise _api.nargs_error('legend', '0-2', len(args))

self.legend_ = mlegend.Legend(self, handles, labels, **kwargs)

self.legend_._remove_method = self._remove_legend

return self.legend_

def _remove_legend(self, legend):

self.legend_ = None

def inset_axes(self, bounds, *, transform=None, zorder=5, **kwargs):

"""

if transform is None:

transform = self.transAxes

kwargs.setdefault('label', 'inset_axes')

# This puts the rectangle into figure-relative coordinates.

inset_locator = _TransformedBoundsLocator(bounds, transform)

bounds = inset_locator(self, None).bounds

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

inset_ax = projection_class(self.figure, bounds, zorder=zorder, **pkw)

# this locator lets the axes move if in data coordinates.

# it gets called in `ax.apply_aspect() (of all places)

inset_ax.set_axes_locator(inset_locator)

self.add_child_axes(inset_ax)

return inset_ax

@_docstring.dedent_interpd

def indicate_inset(self, bounds, inset_ax=None, *, transform=None,

facecolor='none', edgecolor='0.5', alpha=0.5,

zorder=4.99, **kwargs):

"""

# to make the axes connectors work, we need to apply the aspect to

# the parent axes.

self.apply_aspect()

if transform is None:

transform = self.transData

kwargs.setdefault('label', '_indicate_inset')

x, y, width, height = bounds

rectangle_patch = mpatches.Rectangle(

(x, y), width, height,

facecolor=facecolor, edgecolor=edgecolor, alpha=alpha,

zorder=zorder, transform=transform, **kwargs)

self.add_patch(rectangle_patch)

connects = []

if inset_ax is not None:

# connect the inset_axes to the rectangle

for xy_inset_ax in [(0, 0), (0, 1), (1, 0), (1, 1)]:

# inset_ax positions are in axes coordinates

# The 0, 1 values define the four edges if the inset_ax

# lower_left, upper_left, lower_right upper_right.

ex, ey = xy_inset_ax

if self.xaxis.get_inverted():

ex = 1 - ex

if self.yaxis.get_inverted():

ey = 1 - ey

xy_data = x + ex * width, y + ey * height

p = mpatches.ConnectionPatch(

xyA=xy_inset_ax, coordsA=inset_ax.transAxes,

xyB=xy_data, coordsB=self.transData,

arrowstyle="-", zorder=zorder,

edgecolor=edgecolor, alpha=alpha)

connects.append(p)

self.add_patch(p)

# decide which two of the lines to keep visible....

pos = inset_ax.get_position()

bboxins = pos.transformed(self.figure.transSubfigure)

rectbbox = mtransforms.Bbox.from_bounds(

*bounds

).transformed(transform)

x0 = rectbbox.x0 < bboxins.x0

x1 = rectbbox.x1 < bboxins.x1

y0 = rectbbox.y0 < bboxins.y0

y1 = rectbbox.y1 < bboxins.y1

connects[0].set_visible(x0 ^ y0)

connects[1].set_visible(x0 == y1)

connects[2].set_visible(x1 == y0)

connects[3].set_visible(x1 ^ y1)

return rectangle_patch, tuple(connects) if connects else None

def indicate_inset_zoom(self, inset_ax, **kwargs):

"""

xlim = inset_ax.get_xlim()

ylim = inset_ax.get_ylim()

rect = (xlim[0], ylim[0], xlim[1] - xlim[0], ylim[1] - ylim[0])

return self.indicate_inset(rect, inset_ax, **kwargs)

@_docstring.dedent_interpd

def secondary_xaxis(self, location, *, functions=None, **kwargs):

"""

if location in ['top', 'bottom'] or isinstance(location, Real):

secondary_ax = SecondaryAxis(self, 'x', location, functions,

**kwargs)

self.add_child_axes(secondary_ax)

return secondary_ax

else:

raise ValueError('secondary_xaxis location must be either '

'a float or "top"/"bottom"')

@_docstring.dedent_interpd

def secondary_yaxis(self, location, *, functions=None, **kwargs):

"""

if location in ['left', 'right'] or isinstance(location, Real):

secondary_ax = SecondaryAxis(self, 'y', location,

functions, **kwargs)

self.add_child_axes(secondary_ax)

return secondary_ax

else:

raise ValueError('secondary_yaxis location must be either '

'a float or "left"/"right"')

@_docstring.dedent_interpd

def text(self, x, y, s, fontdict=None, **kwargs):

"""

effective_kwargs = {

'verticalalignment': 'baseline',

'horizontalalignment': 'left',

'transform': self.transData,

'clip_on': False,

**(fontdict if fontdict is not None else {}),

**kwargs,

}

t = mtext.Text(x, y, text=s, **effective_kwargs)

if t.get_clip_path() is None:

t.set_clip_path(self.patch)

self._add_text(t)

return t

@_docstring.dedent_interpd

def annotate(self, text, xy, xytext=None, xycoords='data', textcoords=None,

arrowprops=None, annotation_clip=None, **kwargs):

# Signature must match Annotation. This is verified in

# test_annotate_signature().

a = mtext.Annotation(text, xy, xytext=xytext, xycoords=xycoords,

textcoords=textcoords, arrowprops=arrowprops,

annotation_clip=annotation_clip, **kwargs)

a.set_transform(mtransforms.IdentityTransform())

if kwargs.get('clip_on', False) and a.get_clip_path() is None:

a.set_clip_path(self.patch)

self._add_text(a)

return a

annotate.__doc__ = mtext.Annotation.__init__.__doc__

#### Lines and spans

@_docstring.dedent_interpd

def axhline(self, y=0, xmin=0, xmax=1, **kwargs):

"""

self._check_no_units([xmin, xmax], ['xmin', 'xmax'])

if "transform" in kwargs:

raise ValueError("'transform' is not allowed as a keyword "

"argument; axhline generates its own transform.")

ymin, ymax = self.get_ybound()

# Strip away the units for comparison with non-unitized bounds.

yy, = self._process_unit_info([("y", y)], kwargs)

scaley = (yy < ymin) or (yy > ymax)

trans = self.get_yaxis_transform(which='grid')

l = mlines.Line2D([xmin, xmax], [y, y], transform=trans, **kwargs)

self.add_line(l)

if scaley:

self._request_autoscale_view("y")

return l

@_docstring.dedent_interpd

def axvline(self, x=0, ymin=0, ymax=1, **kwargs):

"""

self._check_no_units([ymin, ymax], ['ymin', 'ymax'])

if "transform" in kwargs:

raise ValueError("'transform' is not allowed as a keyword "

"argument; axvline generates its own transform.")

xmin, xmax = self.get_xbound()

# Strip away the units for comparison with non-unitized bounds.

xx, = self._process_unit_info([("x", x)], kwargs)

scalex = (xx < xmin) or (xx > xmax)

trans = self.get_xaxis_transform(which='grid')

l = mlines.Line2D([x, x], [ymin, ymax], transform=trans, **kwargs)

self.add_line(l)

if scalex:

self._request_autoscale_view("x")

return l

@staticmethod

def _check_no_units(vals, names):

# Helper method to check that vals are not unitized

for val, name in zip(vals, names):

if not munits._is_natively_supported(val):

raise ValueError(f"{name} must be a single scalar value, "

f"but got {val}")

@_docstring.dedent_interpd

def axline(self, xy1, xy2=None, *, slope=None, **kwargs):

"""

if slope is not None and (self.get_xscale() != 'linear' or

self.get_yscale() != 'linear'):

raise TypeError("'slope' cannot be used with non-linear scales")

datalim = [xy1] if xy2 is None else [xy1, xy2]

if "transform" in kwargs:

# if a transform is passed (i.e. line points not in data space),

# data limits should not be adjusted.

datalim = []

line = mlines._AxLine(xy1, xy2, slope, **kwargs)

# Like add_line, but correctly handling data limits.

self._set_artist_props(line)

if line.get_clip_path() is None:

line.set_clip_path(self.patch)

if not line.get_label():

line.set_label(f"_child{len(self._children)}")

self._children.append(line)

line._remove_method = self._children.remove

self.update_datalim(datalim)

self._request_autoscale_view()

return line

@_docstring.dedent_interpd

def axhspan(self, ymin, ymax, xmin=0, xmax=1, **kwargs):

"""

# Strip units away.

self._check_no_units([xmin, xmax], ['xmin', 'xmax'])

(ymin, ymax), = self._process_unit_info([("y", [ymin, ymax])], kwargs)

verts = (xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin)

p = mpatches.Polygon(verts, **kwargs)

p.set_transform(self.get_yaxis_transform(which="grid"))

self.add_patch(p)

self._request_autoscale_view("y")

return p

@_docstring.dedent_interpd

def axvspan(self, xmin, xmax, ymin=0, ymax=1, **kwargs):

"""