def __init__(self, legend, use_blit=False, update="loc"):

"""

self.legend = legend

_api.check_in_list(["loc", "bbox"], update=update)

self._update = update

super().__init__(legend, legend._legend_box, use_blit=use_blit)

def finalize_offset(self):

if self._update == "loc":

self._update_loc(self.get_loc_in_canvas())

elif self._update == "bbox":

self._bbox_to_anchor(self.get_loc_in_canvas())

def _update_loc(self, loc_in_canvas):

bbox = self.legend.get_bbox_to_anchor()

# if bbox has zero width or height, the transformation is

# ill-defined. Fall back to the default bbox_to_anchor.

if bbox.width == 0 or bbox.height == 0:

self.legend.set_bbox_to_anchor(None)

bbox = self.legend.get_bbox_to_anchor()

_bbox_transform = BboxTransformFrom(bbox)

self.legend._loc = tuple(_bbox_transform.transform(loc_in_canvas))

def _update_bbox_to_anchor(self, loc_in_canvas):

loc_in_bbox = self.legend.axes.transAxes.transform(loc_in_canvas)

"""

# 'best' is only implemented for axes legends

codes = {'best': 0, **AnchoredOffsetbox.codes}

zorder = 5

def __str__(self):

return "Legend"

@docstring.dedent_interpd

def __init__(

self, parent, handles, labels,

loc=None,

numpoints=None, # number of points in the legend line

markerscale=None, # relative size of legend markers vs. original

markerfirst=True, # left/right ordering of legend marker and label

scatterpoints=None, # number of scatter points

scatteryoffsets=None,

prop=None, # properties for the legend texts

fontsize=None, # keyword to set font size directly

labelcolor=None, # keyword to set the text color

# spacing & pad defined as a fraction of the font-size

borderpad=None, # whitespace inside the legend border

labelspacing=None, # vertical space between the legend entries

handlelength=None, # length of the legend handles

handleheight=None, # height of the legend handles

handletextpad=None, # pad between the legend handle and text

borderaxespad=None, # pad between the axes and legend border

columnspacing=None, # spacing between columns

ncol=1, # number of columns

mode=None, # horizontal distribution of columns: None or "expand"

fancybox=None, # True: fancy box, False: rounded box, None: rcParam

shadow=None,

title=None, # legend title

title_fontsize=None, # legend title font size

framealpha=None, # set frame alpha

edgecolor=None, # frame patch edgecolor

facecolor=None, # frame patch facecolor

bbox_to_anchor=None, # bbox to which the legend will be anchored

bbox_transform=None, # transform for the bbox

frameon=None, # draw frame

handler_map=None,

title_fontproperties=None, # properties for the legend title

):

"""

# local import only to avoid circularity

from matplotlib.axes import Axes

from matplotlib.figure import FigureBase

super().__init__()

if prop is None:

if fontsize is not None:

self.prop = FontProperties(size=fontsize)

else:

self.prop = FontProperties(

size=mpl.rcParams["legend.fontsize"])

else:

self.prop = FontProperties._from_any(prop)

if isinstance(prop, dict) and "size" not in prop:

self.prop.set_size(mpl.rcParams["legend.fontsize"])

self._fontsize = self.prop.get_size_in_points()

self.texts = []

self.legendHandles = []

self._legend_title_box = None

#: A dictionary with the extra handler mappings for this Legend

#: instance.

self._custom_handler_map = handler_map

def val_or_rc(val, rc_name):

return val if val is not None else mpl.rcParams[rc_name]

self.numpoints = val_or_rc(numpoints, 'legend.numpoints')

self.markerscale = val_or_rc(markerscale, 'legend.markerscale')

self.scatterpoints = val_or_rc(scatterpoints, 'legend.scatterpoints')

self.borderpad = val_or_rc(borderpad, 'legend.borderpad')

self.labelspacing = val_or_rc(labelspacing, 'legend.labelspacing')

self.handlelength = val_or_rc(handlelength, 'legend.handlelength')

self.handleheight = val_or_rc(handleheight, 'legend.handleheight')

self.handletextpad = val_or_rc(handletextpad, 'legend.handletextpad')

self.borderaxespad = val_or_rc(borderaxespad, 'legend.borderaxespad')

self.columnspacing = val_or_rc(columnspacing, 'legend.columnspacing')

self.shadow = val_or_rc(shadow, 'legend.shadow')

# trim handles and labels if illegal label...

_lab, _hand = [], []

for label, handle in zip(labels, handles):

if isinstance(label, str) and label.startswith('_'):

_api.warn_external('The handle {!r} has a label of {!r} '

'which cannot be automatically added to'

' the legend.'.format(handle, label))

else:

_lab.append(label)

_hand.append(handle)

labels, handles = _lab, _hand

handles = list(handles)

if len(handles) < 2:

ncol = 1

self._ncol = ncol

if self.numpoints <= 0:

raise ValueError("numpoints must be > 0; it was %d" % numpoints)

# introduce y-offset for handles of the scatter plot

if scatteryoffsets is None:

self._scatteryoffsets = np.array([3. / 8., 4. / 8., 2.5 / 8.])

else:

self._scatteryoffsets = np.asarray(scatteryoffsets)

reps = self.scatterpoints // len(self._scatteryoffsets) + 1

self._scatteryoffsets = np.tile(self._scatteryoffsets,

reps)[:self.scatterpoints]

# _legend_box is a VPacker instance that contains all

# legend items and will be initialized from _init_legend_box()

# method.

self._legend_box = None

if isinstance(parent, Axes):

self.isaxes = True

self.axes = parent

self.set_figure(parent.figure)

elif isinstance(parent, FigureBase):

self.isaxes = False

self.set_figure(parent)

else:

raise TypeError(

"Legend needs either Axes or FigureBase as parent"

)

self.parent = parent

self._loc_used_default = loc is None

if loc is None:

loc = mpl.rcParams["legend.loc"]

if not self.isaxes and loc in [0, 'best']:

loc = 'upper right'

if isinstance(loc, str):

loc = _api.check_getitem(self.codes, loc=loc)

if not self.isaxes and loc == 0:

raise ValueError(

"Automatic legend placement (loc='best') not implemented for "

"figure legend")

self._mode = mode

self.set_bbox_to_anchor(bbox_to_anchor, bbox_transform)

# We use FancyBboxPatch to draw a legend frame. The location

# and size of the box will be updated during the drawing time.

if facecolor is None:

facecolor = mpl.rcParams["legend.facecolor"]

if facecolor == 'inherit':

facecolor = mpl.rcParams["axes.facecolor"]

if edgecolor is None:

edgecolor = mpl.rcParams["legend.edgecolor"]

if edgecolor == 'inherit':

edgecolor = mpl.rcParams["axes.edgecolor"]

if fancybox is None:

fancybox = mpl.rcParams["legend.fancybox"]

self.legendPatch = FancyBboxPatch(

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

facecolor=facecolor, edgecolor=edgecolor,

# If shadow is used, default to alpha=1 (#8943).

alpha=(framealpha if framealpha is not None

else 1 if shadow

else mpl.rcParams["legend.framealpha"]),

# The width and height of the legendPatch will be set (in draw())

# to the length that includes the padding. Thus we set pad=0 here.

boxstyle=("round,pad=0,rounding_size=0.2" if fancybox

else "square,pad=0"),

mutation_scale=self._fontsize,

snap=True,

visible=(frameon if frameon is not None

else mpl.rcParams["legend.frameon"])

)

self._set_artist_props(self.legendPatch)

# init with null renderer

self._init_legend_box(handles, labels, markerfirst)

tmp = self._loc_used_default

self._set_loc(loc)

self._loc_used_default = tmp # ignore changes done by _set_loc

# figure out title font properties:

if title_fontsize is not None and title_fontproperties is not None:

raise ValueError(

"title_fontsize and title_fontproperties can't be specified "

"at the same time. Only use one of them. ")

title_prop_fp = FontProperties._from_any(title_fontproperties)

if isinstance(title_fontproperties, dict):

if "size" not in title_fontproperties:

title_fontsize = mpl.rcParams["legend.title_fontsize"]

title_prop_fp.set_size(title_fontsize)

elif title_fontsize is not None:

title_prop_fp.set_size(title_fontsize)

elif not isinstance(title_fontproperties, FontProperties):

title_fontsize = mpl.rcParams["legend.title_fontsize"]

title_prop_fp.set_size(title_fontsize)

self.set_title(title, prop=title_prop_fp)

self._draggable = None

# set the text color

color_getters = { # getter function depends on line or patch

'linecolor': ['get_color', 'get_facecolor'],

'markerfacecolor': ['get_markerfacecolor', 'get_facecolor'],

'mfc': ['get_markerfacecolor', 'get_facecolor'],

'markeredgecolor': ['get_markeredgecolor', 'get_edgecolor'],

'mec': ['get_markeredgecolor', 'get_edgecolor'],

}

if labelcolor is None:

if mpl.rcParams['legend.labelcolor'] is not None:

labelcolor = mpl.rcParams['legend.labelcolor']

else:

labelcolor = mpl.rcParams['text.color']

if isinstance(labelcolor, str) and labelcolor in color_getters:

getter_names = color_getters[labelcolor]

for handle, text in zip(self.legendHandles, self.texts):

for getter_name in getter_names:

try:

color = getattr(handle, getter_name)()

text.set_color(color)

break

except AttributeError:

pass

elif isinstance(labelcolor, str) and labelcolor == 'none':

for text in self.texts:

text.set_color(labelcolor)

elif np.iterable(labelcolor):

for text, color in zip(self.texts,

itertools.cycle(

colors.to_rgba_array(labelcolor))):

text.set_color(color)

else:

raise ValueError("Invalid argument for labelcolor : %s" %

str(labelcolor))

def _set_artist_props(self, a):

"""

a.set_figure(self.figure)

if self.isaxes:

# a.set_axes(self.axes)

a.axes = self.axes

a.set_transform(self.get_transform())

def _set_loc(self, loc):

# find_offset function will be provided to _legend_box and

# _legend_box will draw itself at the location of the return

# value of the find_offset.

self._loc_used_default = False

self._loc_real = loc

self.stale = True

self._legend_box.set_offset(self._findoffset)

def _get_loc(self):

return self._loc_real

_loc = property(_get_loc, _set_loc)

def _findoffset(self, width, height, xdescent, ydescent, renderer):

"""Helper function to locate the legend."""

if self._loc == 0: # "best".

x, y = self._find_best_position(width, height, renderer)

elif self._loc in Legend.codes.values(): # Fixed location.

bbox = Bbox.from_bounds(0, 0, width, height)

x, y = self._get_anchored_bbox(self._loc, bbox,

self.get_bbox_to_anchor(),

renderer)

else: # Axes or figure coordinates.

fx, fy = self._loc

bbox = self.get_bbox_to_anchor()

x, y = bbox.x0 + bbox.width * fx, bbox.y0 + bbox.height * fy

return x + xdescent, y + ydescent

@allow_rasterization

def draw(self, renderer):

# docstring inherited

if not self.get_visible():

return

renderer.open_group('legend', gid=self.get_gid())

fontsize = renderer.points_to_pixels(self._fontsize)

# if mode == fill, set the width of the legend_box to the

# width of the parent (minus pads)

if self._mode in ["expand"]:

pad = 2 * (self.borderaxespad + self.borderpad) * fontsize

self._legend_box.set_width(self.get_bbox_to_anchor().width - pad)

# update the location and size of the legend. This needs to

# be done in any case to clip the figure right.

bbox = self._legend_box.get_window_extent(renderer)

self.legendPatch.set_bounds(bbox.x0, bbox.y0, bbox.width, bbox.height)

self.legendPatch.set_mutation_scale(fontsize)

if self.shadow:

Shadow(self.legendPatch, 2, -2).draw(renderer)

self.legendPatch.draw(renderer)

self._legend_box.draw(renderer)

renderer.close_group('legend')

self.stale = False

# _default_handler_map defines the default mapping between plot

# elements and the legend handlers.

_default_handler_map = {

StemContainer: legend_handler.HandlerStem(),

ErrorbarContainer: legend_handler.HandlerErrorbar(),

Line2D: legend_handler.HandlerLine2D(),

Patch: legend_handler.HandlerPatch(),

StepPatch: legend_handler.HandlerStepPatch(),

LineCollection: legend_handler.HandlerLineCollection(),

RegularPolyCollection: legend_handler.HandlerRegularPolyCollection(),

CircleCollection: legend_handler.HandlerCircleCollection(),

BarContainer: legend_handler.HandlerPatch(

update_func=legend_handler.update_from_first_child),

tuple: legend_handler.HandlerTuple(),

PathCollection: legend_handler.HandlerPathCollection(),

PolyCollection: legend_handler.HandlerPolyCollection()

}

# (get|set|update)_default_handler_maps are public interfaces to

# modify the default handler map.

@classmethod

def get_default_handler_map(cls):

"""Return the global default handler map, shared by all legends."""

return cls._default_handler_map

@classmethod

def set_default_handler_map(cls, handler_map):

"""Set the global default handler map, shared by all legends."""

cls._default_handler_map = handler_map

@classmethod

def update_default_handler_map(cls, handler_map):

"""Update the global default handler map, shared by all legends."""

cls._default_handler_map.update(handler_map)

def get_legend_handler_map(self):

"""Return this legend instance's handler map."""

default_handler_map = self.get_default_handler_map()

return ({**default_handler_map, **self._custom_handler_map}

if self._custom_handler_map else default_handler_map)

@staticmethod

def get_legend_handler(legend_handler_map, orig_handle):

"""

try:

return legend_handler_map[orig_handle]

except (TypeError, KeyError): # TypeError if unhashable.

pass

for handle_type in type(orig_handle).mro():

try:

return legend_handler_map[handle_type]

except KeyError:

pass

return None

def _init_legend_box(self, handles, labels, markerfirst=True):

"""

fontsize = self._fontsize

# legend_box is a HPacker, horizontally packed with

# columns. Each column is a VPacker, vertically packed with

# legend items. Each legend item is HPacker packed with

# legend handleBox and labelBox. handleBox is an instance of

# offsetbox.DrawingArea which contains legend handle. labelBox

# is an instance of offsetbox.TextArea which contains legend

# text.

text_list = [] # the list of text instances

handle_list = [] # the list of handle instances

handles_and_labels = []

label_prop = dict(verticalalignment='baseline',

horizontalalignment='left',

fontproperties=self.prop,

)

# The approximate height and descent of text. These values are

# only used for plotting the legend handle.

descent = 0.35 * fontsize * (self.handleheight - 0.7)

# 0.35 and 0.7 are just heuristic numbers and may need to be improved.

height = fontsize * self.handleheight - descent

# each handle needs to be drawn inside a box of (x, y, w, h) =

# (0, -descent, width, height). And their coordinates should

# be given in the display coordinates.

# The transformation of each handle will be automatically set

# to self.get_transform(). If the artist does not use its

# default transform (e.g., Collections), you need to

# manually set their transform to the self.get_transform().

legend_handler_map = self.get_legend_handler_map()

for orig_handle, lab in zip(handles, labels):

handler = self.get_legend_handler(legend_handler_map, orig_handle)

if handler is None:

_api.warn_external(

"Legend does not support {!r} instances.\nA proxy artist "

"may be used instead.\nSee: "

"https://matplotlib.org/users/legend_guide.html"

"#creating-artists-specifically-for-adding-to-the-legend-"

"aka-proxy-artists".format(orig_handle))

# We don't have a handle for this artist, so we just defer

# to None.

handle_list.append(None)

else:

textbox = TextArea(lab, textprops=label_prop,

multilinebaseline=True)

handlebox = DrawingArea(width=self.handlelength * fontsize,

height=height,

xdescent=0., ydescent=descent)

text_list.append(textbox._text)

# Create the artist for the legend which represents the

# original artist/handle.

handle_list.append(handler.legend_artist(self, orig_handle,

fontsize, handlebox))

handles_and_labels.append((handlebox, textbox))

if handles_and_labels:

# We calculate number of rows in each column. The first

# (num_largecol) columns will have (nrows+1) rows, and remaining

# (num_smallcol) columns will have (nrows) rows.

ncol = min(self._ncol, len(handles_and_labels))

nrows, num_largecol = divmod(len(handles_and_labels), ncol)

num_smallcol = ncol - num_largecol

# starting index of each column and number of rows in it.

rows_per_col = [nrows + 1] * num_largecol + [nrows] * num_smallcol

start_idxs = np.concatenate([[0], np.cumsum(rows_per_col)[:-1]])

cols = zip(start_idxs, rows_per_col)

else:

cols = []

columnbox = []

for i0, di in cols:

# pack handleBox and labelBox into itemBox

itemBoxes = [HPacker(pad=0,

sep=self.handletextpad * fontsize,

children=[h, t] if markerfirst else [t, h],

align="baseline")

for h, t in handles_and_labels[i0:i0 + di]]

# pack columnBox

alignment = "baseline" if markerfirst else "right"

columnbox.append(VPacker(pad=0,

sep=self.labelspacing * fontsize,

align=alignment,

children=itemBoxes))

mode = "expand" if self._mode == "expand" else "fixed"

sep = self.columnspacing * fontsize

self._legend_handle_box = HPacker(pad=0,

sep=sep, align="baseline",

mode=mode,

children=columnbox)

self._legend_title_box = TextArea("")

self._legend_box = VPacker(pad=self.borderpad * fontsize,

sep=self.labelspacing * fontsize,

align="center",

children=[self._legend_title_box,

self._legend_handle_box])

self._legend_box.set_figure(self.figure)

self._legend_box.axes = self.axes

self.texts = text_list

self.legendHandles = handle_list

def _auto_legend_data(self):

"""

assert self.isaxes # always holds, as this is only called internally

bboxes = []

lines = []

offsets = []

for artist in self.parent._children:

if isinstance(artist, Line2D):

lines.append(

artist.get_transform().transform_path(artist.get_path()))

elif isinstance(artist, Rectangle):

bboxes.append(

artist.get_bbox().transformed(artist.get_data_transform()))

elif isinstance(artist, Patch):

bboxes.append(

artist.get_path().get_extents(artist.get_transform()))

elif isinstance(artist, Collection):

_, transOffset, hoffsets, _ = artist._prepare_points()

for offset in transOffset.transform(hoffsets):

offsets.append(offset)

return bboxes, lines, offsets

def get_children(self):

# docstring inherited

return [self._legend_box, self.get_frame()]

def get_frame(self):

"""Return the `~.patches.Rectangle` used to frame the legend."""

return self.legendPatch

def get_lines(self):

r"""Return the list of `~.lines.Line2D`\s in the legend."""

return [h for h in self.legendHandles if isinstance(h, Line2D)]

def get_patches(self):

r"""Return the list of `~.patches.Patch`\s in the legend."""

return silent_list('Patch',

[h for h in self.legendHandles

if isinstance(h, Patch)])

def get_texts(self):

r"""Return the list of `~.text.Text`\s in the legend."""

return silent_list('Text', self.texts)

def set_title(self, title, prop=None):

"""

self._legend_title_box._text.set_text(title)

if title:

self._legend_title_box._text.set_visible(True)

self._legend_title_box.set_visible(True)

else:

self._legend_title_box._text.set_visible(False)

self._legend_title_box.set_visible(False)

if prop is not None:

self._legend_title_box._text.set_fontproperties(prop)

self.stale = True

def get_title(self):

"""Return the `.Text` instance for the legend title."""

return self._legend_title_box._text

def get_window_extent(self, renderer=None):

# docstring inherited

if renderer is None:

renderer = self.figure._cachedRenderer

return self._legend_box.get_window_extent(renderer=renderer)

def get_tightbbox(self, renderer):

"""

return self._legend_box.get_window_extent(renderer)

def get_frame_on(self):

"""Get whether the legend box patch is drawn."""

return self.legendPatch.get_visible()

def set_frame_on(self, b):

"""

self.legendPatch.set_visible(b)

self.stale = True

draw_frame = set_frame_on # Backcompat alias.

def get_bbox_to_anchor(self):

"""Return the bbox that the legend will be anchored to."""

if self._bbox_to_anchor is None:

return self.parent.bbox

else:

return self._bbox_to_anchor

def set_bbox_to_anchor(self, bbox, transform=None):

"""

if bbox is None:

self._bbox_to_anchor = None

return

elif isinstance(bbox, BboxBase):

self._bbox_to_anchor = bbox

else:

try:

l = len(bbox)

except TypeError as err:

raise ValueError("Invalid argument for bbox : %s" %

str(bbox)) from err

if l == 2:

bbox = [bbox[0], bbox[1], 0, 0]

self._bbox_to_anchor = Bbox.from_bounds(*bbox)

if transform is None:

transform = BboxTransformTo(self.parent.bbox)

self._bbox_to_anchor = TransformedBbox(self._bbox_to_anchor,

transform)

self.stale = True

def _get_anchored_bbox(self, loc, bbox, parentbbox, renderer):

"""