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

_loc_doc_base.format(parent='axes/figure',

default=":rc:`legend.loc` for Axes, 'upper right' for Figure",

best=_loc_doc_best, outside=_outside_doc) +

"""

# 'best' is only implemented for Axes legends

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

zorder = 5

def __str__(self):

return "Legend"

@_docstring.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

reverse=False, # reverse 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

ncols=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

alignment="center", # control the alignment within the legend box

ncol=1, # synonym for ncols (backward compatibility)

draggable=False # whether the legend can be dragged with the mouse

):

"""

# local import only to avoid circularity

from matplotlib.axes import Axes

from matplotlib.figure import FigureBase

super().__init__()

if prop is None:

self.prop = FontProperties(size=mpl._val_or_rc(fontsize, "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.legend_handles = []

self._legend_title_box = None

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

#: instance.

self._custom_handler_map = handler_map

self.numpoints = mpl._val_or_rc(numpoints, 'legend.numpoints')

self.markerscale = mpl._val_or_rc(markerscale, 'legend.markerscale')

self.scatterpoints = mpl._val_or_rc(scatterpoints, 'legend.scatterpoints')

self.borderpad = mpl._val_or_rc(borderpad, 'legend.borderpad')

self.labelspacing = mpl._val_or_rc(labelspacing, 'legend.labelspacing')

self.handlelength = mpl._val_or_rc(handlelength, 'legend.handlelength')

self.handleheight = mpl._val_or_rc(handleheight, 'legend.handleheight')

self.handletextpad = mpl._val_or_rc(handletextpad, 'legend.handletextpad')

self.borderaxespad = mpl._val_or_rc(borderaxespad, 'legend.borderaxespad')

self.columnspacing = mpl._val_or_rc(columnspacing, 'legend.columnspacing')

self.shadow = mpl._val_or_rc(shadow, 'legend.shadow')

if reverse:

labels = [*reversed(labels)]

handles = [*reversed(handles)]

handles = list(handles)

if len(handles) < 2:

ncols = 1

self._ncols = ncols if ncols != 1 else 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.get_figure(root=False))

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._mode = mode

self.set_bbox_to_anchor(bbox_to_anchor, bbox_transform)

# Figure out if self.shadow is valid

# If shadow was None, rcParams loads False

# So it shouldn't be None here

self._shadow_props = {'ox': 2, 'oy': -2} # default location offsets

if isinstance(self.shadow, dict):

self._shadow_props.update(self.shadow)

self.shadow = True

elif self.shadow in (0, 1, True, False):

self.shadow = bool(self.shadow)

else:

raise ValueError(

'Legend shadow must be a dict or bool, not '

f'{self.shadow!r} of type {type(self.shadow)}.'

)

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

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

facecolor = mpl._val_or_rc(facecolor, "legend.facecolor")

if facecolor == 'inherit':

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

edgecolor = mpl._val_or_rc(edgecolor, "legend.edgecolor")

if edgecolor == 'inherit':

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

fancybox = mpl._val_or_rc(fancybox, "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=mpl._val_or_rc(frameon, "legend.frameon")

)

self._set_artist_props(self.legendPatch)

_api.check_in_list(["center", "left", "right"], alignment=alignment)

self._alignment = alignment

# init with null renderer

self._init_legend_box(handles, labels, markerfirst)

# Set legend location

self.set_loc(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

self.set_draggable(state=draggable)

# 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'],

}

labelcolor = mpl._val_or_rc(labelcolor, 'legend.labelcolor')

if labelcolor is None:

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.legend_handles, self.texts):

try:

if handle.get_array() is not None:

continue

except AttributeError:

pass

for getter_name in getter_names:

try:

color = getattr(handle, getter_name)()

if isinstance(color, np.ndarray):

if (

color.shape[0] == 1

or np.isclose(color, color[0]).all()

):

text.set_color(color[0])

else:

pass

else:

text.set_color(color)

break

except AttributeError:

pass

elif cbook._str_equal(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(f"Invalid labelcolor: {labelcolor!r}")

def _set_artist_props(self, a):

"""

a.set_figure(self.get_figure(root=False))

if self.isaxes:

a.axes = self.axes

a.set_transform(self.get_transform())

@_docstring.interpd

def set_loc(self, loc=None):

"""

loc0 = loc

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'

type_err_message = ("loc must be string, coordinate tuple, or"

f" an integer 0-10, not {loc!r}")

# handle outside legends:

self._outside_loc = None

if isinstance(loc, str):

if loc.split()[0] == 'outside':

# strip outside:

loc = loc.split('outside ')[1]

# strip "center" at the beginning

self._outside_loc = loc.replace('center ', '')

# strip first

self._outside_loc = self._outside_loc.split()[0]

locs = loc.split()

if len(locs) > 1 and locs[0] in ('right', 'left'):

# locs doesn't accept "left upper", etc, so swap

if locs[0] != 'center':

locs = locs[::-1]

loc = locs[0] + ' ' + locs[1]

# check that loc is in acceptable strings

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

elif np.iterable(loc):

# coerce iterable into tuple

loc = tuple(loc)

# validate the tuple represents Real coordinates

if len(loc) != 2 or not all(isinstance(e, numbers.Real) for e in loc):

raise ValueError(type_err_message)

elif isinstance(loc, int):

# validate the integer represents a string numeric value

if loc < 0 or loc > 10:

raise ValueError(type_err_message)

else:

# all other cases are invalid values of loc

raise ValueError(type_err_message)

if self.isaxes and self._outside_loc:

raise ValueError(

f"'outside' option for loc='{loc0}' keyword argument only "

"works for figure legends")

if not self.isaxes and loc == 0:

raise ValueError(

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

"figure legend")

tmp = self._loc_used_default

self._set_loc(loc)

self._loc_used_default = tmp # ignore changes done by _set_loc

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 set_ncols(self, ncols):

"""Set the number of columns."""

self._ncols = ncols

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

self.legendPatch.set_mutation_scale(fontsize)

# self.shadow is validated in __init__

# So by here it is a bool and self._shadow_props contains any configs

if self.shadow:

Shadow(self.legendPatch, **self._shadow_props).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 a HPacker packed with:

# - handlebox: a DrawingArea which contains the legend handle.

# - labelbox: a TextArea which contains the legend text.

text_list = [] # the list of text instances

handle_list = [] # the list of handle instances

handles_and_labels = []

# 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) # heuristic.

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, label 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 handles for "

f"{type(orig_handle).__name__} "

"instances.\nA proxy artist may be used "

"instead.\nSee: https://matplotlib.org/"

"stable/users/explain/axes/legend_guide.html"

"#controlling-the-legend-entries")

# No handle for this artist, so we just defer to None.

handle_list.append(None)

else:

textbox = TextArea(label, multilinebaseline=True,

textprops=dict(

verticalalignment='baseline',

horizontalalignment='left',

fontproperties=self.prop))

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

columnbox = []

# array_split splits n handles_and_labels into ncols columns, with the

# first n%ncols columns having an extra entry. filter(len, ...)

# handles the case where n < ncols: the last ncols-n columns are empty

# and get filtered out.

for handles_and_labels_column in filter(

len, np.array_split(handles_and_labels, self._ncols)):

# 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_column]

# 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=self._alignment,

children=[self._legend_title_box,

self._legend_handle_box])

self._legend_box.set_figure(self.get_figure(root=False))

self._legend_box.axes = self.axes

self.texts = text_list

self.legend_handles = handle_list

def _auto_legend_data(self, renderer):

"""

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

lines.append(

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

elif isinstance(artist, PolyCollection):

lines.extend(artist.get_transform().transform_path(path)

for path in artist.get_paths())

elif isinstance(artist, Collection):

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

if len(hoffsets):

offsets.extend(transOffset.transform(hoffsets))

elif isinstance(artist, Text):

bboxes.append(artist.get_window_extent(renderer))

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.legend_handles 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.legend_handles

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_alignment(self, alignment):

"""