# Note: The first part of this file can be modified in place, but the latter

# part is autogenerated by the boilerplate.py script.

"""

`matplotlib.pyplot` is a state-based interface to matplotlib. It provides

a MATLAB-like way of plotting.

pyplot is mainly intended for interactive plots and simple cases of

programmatic plot generation::

import numpy as np

import matplotlib.pyplot as plt

x = np.arange(0, 5, 0.1)

y = np.sin(x)

plt.plot(x, y)

The object-oriented API is recommended for more complex plots.

"""

import functools

import importlib

import inspect

import logging

from numbers import Number

import re

import sys

import time

try:

import threading

except ImportError:

import dummy_threading as threading

from cycler import cycler

import matplotlib

import matplotlib.colorbar

import matplotlib.image

from matplotlib import _api

from matplotlib import rcsetup, style

from matplotlib import _pylab_helpers, interactive

from matplotlib import cbook

from matplotlib import docstring

from matplotlib.backend_bases import FigureCanvasBase, MouseButton

from matplotlib.figure import Figure, figaspect

from matplotlib.gridspec import GridSpec, SubplotSpec

from matplotlib import rcParams, rcParamsDefault, get_backend, rcParamsOrig

from matplotlib.rcsetup import interactive_bk as _interactive_bk

from matplotlib.artist import Artist

from matplotlib.axes import Axes, Subplot

from matplotlib.projections import PolarAxes

from matplotlib import mlab # for detrend_none, window_hanning

from matplotlib.scale import get_scale_names

from matplotlib import cm

from matplotlib.cm import get_cmap, register_cmap

import numpy as np

# We may not need the following imports here:

from matplotlib.colors import Normalize

from matplotlib.lines import Line2D

from matplotlib.text import Text, Annotation

from matplotlib.patches import Polygon, Rectangle, Circle, Arrow

from matplotlib.widgets import SubplotTool, Button, Slider, Widget

from .ticker import (

TickHelper, Formatter, FixedFormatter, NullFormatter, FuncFormatter,

FormatStrFormatter, ScalarFormatter, LogFormatter, LogFormatterExponent,

LogFormatterMathtext, Locator, IndexLocator, FixedLocator, NullLocator,

LinearLocator, LogLocator, AutoLocator, MultipleLocator, MaxNLocator)

_log = logging.getLogger(__name__)

_code_objs = {

_api.rename_parameter:

_api.rename_parameter("", "old", "new", lambda new: None).__code__,

_api.make_keyword_only:

_api.make_keyword_only("", "p", lambda p: None).__code__,

}

def _copy_docstring_and_deprecators(method, func=None):

if func is None:

return functools.partial(_copy_docstring_and_deprecators, method)

decorators = [docstring.copy(method)]

# Check whether the definition of *method* includes @_api.rename_parameter

# or @_api.make_keyword_only decorators; if so, propagate them to the

# pyplot wrapper as well.

while getattr(method, "__wrapped__", None) is not None:

for decorator_maker, code in _code_objs.items():

if method.__code__ is code:

kwargs = {

k: v.cell_contents

for k, v in zip(code.co_freevars, method.__closure__)}

assert kwargs["func"] is method.__wrapped__

kwargs.pop("func")

decorators.append(decorator_maker(**kwargs))

method = method.__wrapped__

for decorator in decorators[::-1]:

func = decorator(func)

return func

## Global ##

_IP_REGISTERED = None

_INSTALL_FIG_OBSERVER = False

def install_repl_displayhook():

"""

Install a repl display hook so that any stale figure are automatically

redrawn when control is returned to the repl.

This works both with IPython and with vanilla python shells.

"""

global _IP_REGISTERED

global _INSTALL_FIG_OBSERVER

class _NotIPython(Exception):

pass

# see if we have IPython hooks around, if use them

try:

if 'IPython' in sys.modules:

from IPython import get_ipython

ip = get_ipython()

if ip is None:

raise _NotIPython()

if _IP_REGISTERED:

return

def post_execute():

if matplotlib.is_interactive():

draw_all()

# IPython >= 2

try:

ip.events.register('post_execute', post_execute)

except AttributeError:

# IPython 1.x

ip.register_post_execute(post_execute)

_IP_REGISTERED = post_execute

_INSTALL_FIG_OBSERVER = False

# trigger IPython's eventloop integration, if available

from IPython.core.pylabtools import backend2gui

ipython_gui_name = backend2gui.get(get_backend())

if ipython_gui_name:

ip.enable_gui(ipython_gui_name)

else:

_INSTALL_FIG_OBSERVER = True

# import failed or ipython is not running

except (ImportError, _NotIPython):

_INSTALL_FIG_OBSERVER = True

def uninstall_repl_displayhook():

"""

Uninstall the matplotlib display hook.

.. warning::

Need IPython >= 2 for this to work. For IPython < 2 will raise a

``NotImplementedError``

.. warning::

If you are using vanilla python and have installed another

display hook this will reset ``sys.displayhook`` to what ever

function was there when matplotlib installed it's displayhook,

possibly discarding your changes.

"""

global _IP_REGISTERED

global _INSTALL_FIG_OBSERVER

if _IP_REGISTERED:

from IPython import get_ipython

ip = get_ipython()

try:

ip.events.unregister('post_execute', _IP_REGISTERED)

except AttributeError as err:

raise NotImplementedError("Can not unregister events "

"in IPython < 2.0") from err

_IP_REGISTERED = None

if _INSTALL_FIG_OBSERVER:

_INSTALL_FIG_OBSERVER = False

draw_all = _pylab_helpers.Gcf.draw_all

@functools.wraps(matplotlib.set_loglevel)

def set_loglevel(*args, **kwargs): # Ensure this appears in the pyplot docs.

return matplotlib.set_loglevel(*args, **kwargs)

@_copy_docstring_and_deprecators(Artist.findobj)

def findobj(o=None, match=None, include_self=True):

if o is None:

o = gcf()

return o.findobj(match, include_self=include_self)

def _get_required_interactive_framework(backend_mod):

return getattr(

backend_mod.FigureCanvas, "required_interactive_framework", None)

def switch_backend(newbackend):

"""

Close all open figures and set the Matplotlib backend.

The argument is case-insensitive. Switching to an interactive backend is

possible only if no event loop for another interactive backend has started.

Switching to and from non-interactive backends is always possible.

Parameters

----------

newbackend : str

The name of the backend to use.

"""

global _backend_mod

# make sure the init is pulled up so we can assign to it later

import matplotlib.backends

close("all")

if newbackend is rcsetup._auto_backend_sentinel:

current_framework = cbook._get_running_interactive_framework()

mapping = {'qt5': 'qt5agg',

'qt4': 'qt4agg',

'gtk3': 'gtk3agg',

'wx': 'wxagg',

'tk': 'tkagg',

'macosx': 'macosx',

'headless': 'agg'}

best_guess = mapping.get(current_framework, None)

if best_guess is not None:

candidates = [best_guess]

else:

candidates = []

candidates += ["macosx", "qt5agg", "gtk3agg", "tkagg", "wxagg"]

# Don't try to fallback on the cairo-based backends as they each have

# an additional dependency (pycairo) over the agg-based backend, and

# are of worse quality.

for candidate in candidates:

try:

switch_backend(candidate)

except ImportError:

continue

else:

rcParamsOrig['backend'] = candidate

return

else:

# Switching to Agg should always succeed; if it doesn't, let the

# exception propagate out.

switch_backend("agg")

rcParamsOrig["backend"] = "agg"

return

# Backends are implemented as modules, but "inherit" default method

# implementations from backend_bases._Backend. This is achieved by

# creating a "class" that inherits from backend_bases._Backend and whose

# body is filled with the module's globals.

backend_name = cbook._backend_module_name(newbackend)

class backend_mod(matplotlib.backend_bases._Backend):

locals().update(vars(importlib.import_module(backend_name)))

required_framework = _get_required_interactive_framework(backend_mod)

if required_framework is not None:

current_framework = cbook._get_running_interactive_framework()

if (current_framework and required_framework

and current_framework != required_framework):

raise ImportError(

"Cannot load backend {!r} which requires the {!r} interactive "

"framework, as {!r} is currently running".format(

newbackend, required_framework, current_framework))

_log.debug("Loaded backend %s version %s.",

newbackend, backend_mod.backend_version)

rcParams['backend'] = rcParamsDefault['backend'] = newbackend

_backend_mod = backend_mod

for func_name in ["new_figure_manager", "draw_if_interactive", "show"]:

globals()[func_name].__signature__ = inspect.signature(

getattr(backend_mod, func_name))

# Need to keep a global reference to the backend for compatibility reasons.

# See https://github.com/matplotlib/matplotlib/issues/6092

matplotlib.backends.backend = newbackend

def _warn_if_gui_out_of_main_thread():

if (_get_required_interactive_framework(_backend_mod)

and threading.current_thread() is not threading.main_thread()):

_api.warn_external(

"Starting a Matplotlib GUI outside of the main thread will likely "

"fail.")

# This function's signature is rewritten upon backend-load by switch_backend.

def new_figure_manager(*args, **kwargs):

"""Create a new figure manager instance."""

_warn_if_gui_out_of_main_thread()

return _backend_mod.new_figure_manager(*args, **kwargs)

# This function's signature is rewritten upon backend-load by switch_backend.

def draw_if_interactive(*args, **kwargs):

"""

Redraw the current figure if in interactive mode.

.. warning::

End users will typically not have to call this function because the

the interactive mode takes care of this.

"""

return _backend_mod.draw_if_interactive(*args, **kwargs)

# This function's signature is rewritten upon backend-load by switch_backend.

def show(*args, **kwargs):

"""

Display all open figures.

Parameters

----------

block : bool, optional

Whether to wait for all figures to be closed before returning.

If `True` block and run the GUI main loop until all figure windows

are closed.

If `False` ensure that all figure windows are displayed and return

immediately. In this case, you are responsible for ensuring

that the event loop is running to have responsive figures.

Defaults to True in non-interactive mode and to False in interactive

mode (see `.pyplot.isinteractive`).

See Also

--------

ion : Enable interactive mode, which shows / updates the figure after

every plotting command, so that calling ``show()`` is not necessary.

ioff : Disable interactive mode.

savefig : Save the figure to an image file instead of showing it on screen.

Notes

-----

**Saving figures to file and showing a window at the same time**

If you want an image file as well as a user interface window, use

`.pyplot.savefig` before `.pyplot.show`. At the end of (a blocking)

``show()`` the figure is closed and thus unregistered from pyplot. Calling

`.pyplot.savefig` afterwards would save a new and thus empty figure. This

limitation of command order does not apply if the show is non-blocking or

if you keep a reference to the figure and use `.Figure.savefig`.

**Auto-show in jupyter notebooks**

The jupyter backends (activated via ``%matplotlib inline``,

``%matplotlib notebook``, or ``%matplotlib widget``), call ``show()`` at

the end of every cell by default. Thus, you usually don't have to call it

explicitly there.

"""

_warn_if_gui_out_of_main_thread()

return _backend_mod.show(*args, **kwargs)

def isinteractive():

"""

Return whether plots are updated after every plotting command.

The interactive mode is mainly useful if you build plots from the command

line and want to see the effect of each command while you are building the

figure.

In interactive mode:

- newly created figures will be shown immediately;

- figures will automatically redraw on change;

- `.pyplot.show` will not block by default.

In non-interactive mode:

- newly created figures and changes to figures will not be reflected until

explicitly asked to be;

- `.pyplot.show` will block by default.

See Also

--------

ion : Enable interactive mode.

ioff : Disable interactive mode.

show : Show all figures (and maybe block).

pause : Show all figures, and block for a time.

"""

return matplotlib.is_interactive()

class _IoffContext:

"""

Context manager for `.ioff`.

The state is changed in ``__init__()`` instead of ``__enter__()``. The

latter is a no-op. This allows using `.ioff` both as a function and

as a context.

"""

def __init__(self):

self.wasinteractive = isinteractive()

matplotlib.interactive(False)

uninstall_repl_displayhook()

def __enter__(self):

pass

def __exit__(self, exc_type, exc_value, traceback):

if self.wasinteractive:

matplotlib.interactive(True)

install_repl_displayhook()

else:

matplotlib.interactive(False)

uninstall_repl_displayhook()

class _IonContext:

"""

Context manager for `.ion`.

The state is changed in ``__init__()`` instead of ``__enter__()``. The

latter is a no-op. This allows using `.ion` both as a function and

as a context.

"""

def __init__(self):

self.wasinteractive = isinteractive()

matplotlib.interactive(True)

install_repl_displayhook()

def __enter__(self):

pass

def __exit__(self, exc_type, exc_value, traceback):

if not self.wasinteractive:

matplotlib.interactive(False)

uninstall_repl_displayhook()

else:

matplotlib.interactive(True)

install_repl_displayhook()

def ioff():

"""

Disable interactive mode.

See `.pyplot.isinteractive` for more details.

See Also

--------

ion : Enable interactive mode.

isinteractive : Whether interactive mode is enabled.

show : Show all figures (and maybe block).

pause : Show all figures, and block for a time.

Notes

-----

For a temporary change, this can be used as a context manager::

# if interactive mode is on

# then figures will be shown on creation

plt.ion()

# This figure will be shown immediately

fig = plt.figure()

with plt.ioff():

# interactive mode will be off

# figures will not automatically be shown

fig2 = plt.figure()

# ...

To enable usage as a context manager, this function returns an

``_IoffContext`` object. The return value is not intended to be stored

or accessed by the user.

"""

return _IoffContext()

def ion():

"""

Enable interactive mode.

See `.pyplot.isinteractive` for more details.

See Also

--------

ioff : Disable interactive mode.

isinteractive : Whether interactive mode is enabled.

show : Show all figures (and maybe block).

pause : Show all figures, and block for a time.

Notes

-----

For a temporary change, this can be used as a context manager::

# if interactive mode is off

# then figures will not be shown on creation

plt.ioff()

# This figure will not be shown immediately

fig = plt.figure()

with plt.ion():

# interactive mode will be on

# figures will automatically be shown

fig2 = plt.figure()

# ...

To enable usage as a context manager, this function returns an

``_IonContext`` object. The return value is not intended to be stored

or accessed by the user.

"""

return _IonContext()

def pause(interval):

"""

Run the GUI event loop for *interval* seconds.

If there is an active figure, it will be updated and displayed before the

pause, and the GUI event loop (if any) will run during the pause.

This can be used for crude animation. For more complex animation use

:mod:`matplotlib.animation`.

If there is no active figure, sleep for *interval* seconds instead.

See Also

--------

matplotlib.animation : Proper animations

show : Show all figures and optional block until all figures are closed.

"""

manager = _pylab_helpers.Gcf.get_active()

if manager is not None:

canvas = manager.canvas

if canvas.figure.stale:

canvas.draw_idle()

show(block=False)

canvas.start_event_loop(interval)

else:

time.sleep(interval)

@_copy_docstring_and_deprecators(matplotlib.rc)

def rc(group, **kwargs):

matplotlib.rc(group, **kwargs)

@_copy_docstring_and_deprecators(matplotlib.rc_context)

def rc_context(rc=None, fname=None):

return matplotlib.rc_context(rc, fname)

@_copy_docstring_and_deprecators(matplotlib.rcdefaults)

def rcdefaults():

matplotlib.rcdefaults()

if matplotlib.is_interactive():

draw_all()

# getp/get/setp are explicitly reexported so that they show up in pyplot docs.

@_copy_docstring_and_deprecators(matplotlib.artist.getp)

def getp(obj, *args, **kwargs):

return matplotlib.artist.getp(obj, *args, **kwargs)

@_copy_docstring_and_deprecators(matplotlib.artist.get)

def get(obj, *args, **kwargs):

return matplotlib.artist.get(obj, *args, **kwargs)

@_copy_docstring_and_deprecators(matplotlib.artist.setp)

def setp(obj, *args, **kwargs):

return matplotlib.artist.setp(obj, *args, **kwargs)

def xkcd(scale=1, length=100, randomness=2):

"""

Turn on `xkcd <https://xkcd.com/>`_ sketch-style drawing mode. This will

only have effect on things drawn after this function is called.

For best results, the "Humor Sans" font should be installed: it is

not included with Matplotlib.

Parameters

----------

scale : float, optional

The amplitude of the wiggle perpendicular to the source line.

length : float, optional

The length of the wiggle along the line.

randomness : float, optional

The scale factor by which the length is shrunken or expanded.

Notes

-----

This function works by a number of rcParams, so it will probably

override others you have set before.

If you want the effects of this function to be temporary, it can

be used as a context manager, for example::

with plt.xkcd():

# This figure will be in XKCD-style

fig1 = plt.figure()

# ...

# This figure will be in regular style

fig2 = plt.figure()

"""

return _xkcd(scale, length, randomness)

class _xkcd:

# This cannot be implemented in terms of rc_context() because this needs to

# work as a non-contextmanager too.

def __init__(self, scale, length, randomness):

self._orig = rcParams.copy()

if rcParams['text.usetex']:

raise RuntimeError(

"xkcd mode is not compatible with text.usetex = True")

from matplotlib import patheffects

rcParams.update({

'font.family': ['xkcd', 'xkcd Script', 'Humor Sans', 'Comic Neue',

'Comic Sans MS'],

'font.size': 14.0,

'path.sketch': (scale, length, randomness),

'path.effects': [

patheffects.withStroke(linewidth=4, foreground="w")],

'axes.linewidth': 1.5,

'lines.linewidth': 2.0,

'figure.facecolor': 'white',

'grid.linewidth': 0.0,

'axes.grid': False,

'axes.unicode_minus': False,

'axes.edgecolor': 'black',

'xtick.major.size': 8,

'xtick.major.width': 3,

'ytick.major.size': 8,

'ytick.major.width': 3,

})

def __enter__(self):

return self

def __exit__(self, *args):

dict.update(rcParams, self._orig)

## Figures ##

def figure(num=None, # autoincrement if None, else integer from 1-N

figsize=None, # defaults to rc figure.figsize

dpi=None, # defaults to rc figure.dpi

facecolor=None, # defaults to rc figure.facecolor

edgecolor=None, # defaults to rc figure.edgecolor

frameon=True,

FigureClass=Figure,

clear=False,

**kwargs

):

"""

Create a new figure, or activate an existing figure.

Parameters

----------

num : int or str or `.Figure`, optional

A unique identifier for the figure.

If a figure with that identifier already exists, this figure is made

active and returned. An integer refers to the ``Figure.number``

attribute, a string refers to the figure label.

If there is no figure with the identifier or *num* is not given, a new

figure is created, made active and returned. If *num* is an int, it

will be used for the ``Figure.number`` attribute, otherwise, an

auto-generated integer value is used (starting at 1 and incremented

for each new figure). If *num* is a string, the figure label and the

window title is set to this value.

figsize : (float, float), default: :rc:`figure.figsize`

Width, height in inches.

dpi : float, default: :rc:`figure.dpi`

The resolution of the figure in dots-per-inch.

facecolor : color, default: :rc:`figure.facecolor`

The background color.

edgecolor : color, default: :rc:`figure.edgecolor`

The border color.

frameon : bool, default: True

If False, suppress drawing the figure frame.

FigureClass : subclass of `~matplotlib.figure.Figure`

Optionally use a custom `.Figure` instance.

clear : bool, default: False

If True and the figure already exists, then it is cleared.

tight_layout : bool or dict, default: :rc:`figure.autolayout`

If ``False`` use *subplotpars*. If ``True`` adjust subplot

parameters using `.tight_layout` with default padding.

When providing a dict containing the keys ``pad``, ``w_pad``,

``h_pad``, and ``rect``, the default `.tight_layout` paddings

will be overridden.

constrained_layout : bool, default: :rc:`figure.constrained_layout.use`

If ``True`` use constrained layout to adjust positioning of plot

elements. Like ``tight_layout``, but designed to be more

flexible. See

:doc:`/tutorials/intermediate/constrainedlayout_guide`

for examples. (Note: does not work with `add_subplot` or

`~.pyplot.subplot2grid`.)

**kwargs : optional

See `~.matplotlib.figure.Figure` for other possible arguments.

Returns

-------

`~matplotlib.figure.Figure`

The `.Figure` instance returned will also be passed to

new_figure_manager in the backends, which allows to hook custom

`.Figure` classes into the pyplot interface. Additional kwargs will be

passed to the `.Figure` init function.

Notes

-----

If you are creating many figures, make sure you explicitly call

`.pyplot.close` on the figures you are not using, because this will

enable pyplot to properly clean up the memory.

`~matplotlib.rcParams` defines the default values, which can be modified

in the matplotlibrc file.

"""

if isinstance(num, Figure):

if num.canvas.manager is None:

raise ValueError("The passed figure is not managed by pyplot")

_pylab_helpers.Gcf.set_active(num.canvas.manager)

return num

allnums = get_fignums()

next_num = max(allnums) + 1 if allnums else 1

fig_label = ''

if num is None:

num = next_num

elif isinstance(num, str):

fig_label = num

all_labels = get_figlabels()

if fig_label not in all_labels:

if fig_label == 'all':

_api.warn_external("close('all') closes all existing figures.")

num = next_num

else:

inum = all_labels.index(fig_label)

num = allnums[inum]

else:

num = int(num) # crude validation of num argument

manager = _pylab_helpers.Gcf.get_fig_manager(num)

if manager is None:

max_open_warning = rcParams['figure.max_open_warning']

if len(allnums) == max_open_warning >= 1:

_api.warn_external(

f"More than {max_open_warning} figures have been opened. "

f"Figures created through the pyplot interface "

f"(`matplotlib.pyplot.figure`) are retained until explicitly "

f"closed and may consume too much memory. (To control this "

f"warning, see the rcParam `figure.max_open_warning`).",

RuntimeWarning)

manager = new_figure_manager(

num, figsize=figsize, dpi=dpi,

facecolor=facecolor, edgecolor=edgecolor, frameon=frameon,

FigureClass=FigureClass, **kwargs)

fig = manager.canvas.figure

if fig_label:

fig.set_label(fig_label)

_pylab_helpers.Gcf._set_new_active_manager(manager)

# make sure backends (inline) that we don't ship that expect this

# to be called in plotting commands to make the figure call show

# still work. There is probably a better way to do this in the

# FigureManager base class.

draw_if_interactive()

if _INSTALL_FIG_OBSERVER:

fig.stale_callback = _auto_draw_if_interactive

if clear:

manager.canvas.figure.clear()

return manager.canvas.figure

def _auto_draw_if_interactive(fig, val):

"""

An internal helper function for making sure that auto-redrawing

works as intended in the plain python repl.

Parameters

----------

fig : Figure

A figure object which is assumed to be associated with a canvas

"""

if (val and matplotlib.is_interactive()

and not fig.canvas.is_saving()

and not fig.canvas._is_idle_drawing):

# Some artists can mark themselves as stale in the middle of drawing

# (e.g. axes position & tick labels being computed at draw time), but

# this shouldn't trigger a redraw because the current redraw will

# already take them into account.

with fig.canvas._idle_draw_cntx():

fig.canvas.draw_idle()

def gcf():

"""

Get the current figure.

If no current figure exists, a new one is created using

`~.pyplot.figure()`.

"""

manager = _pylab_helpers.Gcf.get_active()

if manager is not None:

return manager.canvas.figure

else:

return figure()

def fignum_exists(num):

"""Return whether the figure with the given id exists."""

return _pylab_helpers.Gcf.has_fignum(num) or num in get_figlabels()

def get_fignums():

"""Return a list of existing figure numbers."""

return sorted(_pylab_helpers.Gcf.figs)

def get_figlabels():

"""Return a list of existing figure labels."""

managers = _pylab_helpers.Gcf.get_all_fig_managers()

managers.sort(key=lambda m: m.num)

return [m.canvas.figure.get_label() for m in managers]

def get_current_fig_manager():

"""

Return the figure manager of the current figure.

The figure manager is a container for the actual backend-depended window

that displays the figure on screen.

If no current figure exists, a new one is created, and its figure

manager is returned.

Returns

-------

`.FigureManagerBase` or backend-dependent subclass thereof

"""

return gcf().canvas.manager

@_copy_docstring_and_deprecators(FigureCanvasBase.mpl_connect)

def connect(s, func):

return gcf().canvas.mpl_connect(s, func)

@_copy_docstring_and_deprecators(FigureCanvasBase.mpl_disconnect)

def disconnect(cid):

return gcf().canvas.mpl_disconnect(cid)

def close(fig=None):

"""

Close a figure window.

Parameters

----------

fig : None or int or str or `.Figure`

The figure to close. There are a number of ways to specify this:

- *None*: the current figure

- `.Figure`: the given `.Figure` instance

- ``int``: a figure number

- ``str``: a figure name

- 'all': all figures

"""

if fig is None:

manager = _pylab_helpers.Gcf.get_active()

if manager is None:

return

else:

_pylab_helpers.Gcf.destroy(manager)

elif fig == 'all':

_pylab_helpers.Gcf.destroy_all()

elif isinstance(fig, int):

_pylab_helpers.Gcf.destroy(fig)

elif hasattr(fig, 'int'):

# if we are dealing with a type UUID, we

# can use its integer representation

_pylab_helpers.Gcf.destroy(fig.int)

elif isinstance(fig, str):

all_labels = get_figlabels()

if fig in all_labels:

num = get_fignums()[all_labels.index(fig)]

_pylab_helpers.Gcf.destroy(num)

elif isinstance(fig, Figure):

_pylab_helpers.Gcf.destroy_fig(fig)

else:

raise TypeError("close() argument must be a Figure, an int, a string, "

"or None, not %s" % type(fig))

def clf():

"""Clear the current figure."""

gcf().clf()

def draw():

"""

Redraw the current figure.

This is used to update a figure that has been altered, but not

automatically re-drawn. If interactive mode is on (via `.ion()`), this

should be only rarely needed, but there may be ways to modify the state of

a figure without marking it as "stale". Please report these cases as bugs.

This is equivalent to calling ``fig.canvas.draw_idle()``, where ``fig`` is

the current figure.

"""

gcf().canvas.draw_idle()

@_copy_docstring_and_deprecators(Figure.savefig)

def savefig(*args, **kwargs):

fig = gcf()

res = fig.savefig(*args, **kwargs)

fig.canvas.draw_idle() # need this if 'transparent=True' to reset colors

return res

## Putting things in figures ##

def figlegend(*args, **kwargs):

return gcf().legend(*args, **kwargs)

if Figure.legend.__doc__:

figlegend.__doc__ = Figure.legend.__doc__.replace("legend(", "figlegend(")

## Axes ##

@docstring.dedent_interpd

def axes(arg=None, **kwargs):

"""

Add an axes to the current figure and make it the current axes.

Call signatures::

plt.axes()

plt.axes(rect, projection=None, polar=False, **kwargs)

plt.axes(ax)

Parameters

----------

arg : None or 4-tuple

The exact behavior of this function depends on the type:

- *None*: A new full window axes is added using

``subplot(**kwargs)``.

- 4-tuple of floats *rect* = ``[left, bottom, width, height]``.