demo + utils venv

utils/venv/lib/python3.6/site-packages/matplotlib/backends/__init__.py

@@ -0,0 +1,107 @@
+import importlib
+import logging
+import os
+import sys
+import traceback
+
+import matplotlib
+from matplotlib import cbook
+from matplotlib.backend_bases import _Backend
+
+_log = logging.getLogger(__name__)
+
+
+# NOTE: plt.switch_backend() (called at import time) will add a "backend"
+# attribute here for backcompat.
+
+
+def _get_running_interactive_framework():
+    """
+    Return the interactive framework whose event loop is currently running, if
+    any, or "headless" if no event loop can be started, or None.
+
+    Returns
+    -------
+    Optional[str]
+        One of the following values: "qt5", "qt4", "gtk3", "wx", "tk",
+        "macosx", "headless", ``None``.
+    """
+    QtWidgets = (sys.modules.get("PyQt5.QtWidgets")
+                 or sys.modules.get("PySide2.QtWidgets"))
+    if QtWidgets and QtWidgets.QApplication.instance():
+        return "qt5"
+    QtGui = (sys.modules.get("PyQt4.QtGui")
+             or sys.modules.get("PySide.QtGui"))
+    if QtGui and QtGui.QApplication.instance():
+        return "qt4"
+    Gtk = (sys.modules.get("gi.repository.Gtk")
+           or sys.modules.get("pgi.repository.Gtk"))
+    if Gtk and Gtk.main_level():
+        return "gtk3"
+    wx = sys.modules.get("wx")
+    if wx and wx.GetApp():
+        return "wx"
+    tkinter = sys.modules.get("tkinter")
+    if tkinter:
+        for frame in sys._current_frames().values():
+            while frame:
+                if frame.f_code == tkinter.mainloop.__code__:
+                    return "tk"
+                frame = frame.f_back
+    if 'matplotlib.backends._macosx' in sys.modules:
+        if sys.modules["matplotlib.backends._macosx"].event_loop_is_running():
+            return "macosx"
+    if sys.platform.startswith("linux") and not os.environ.get("DISPLAY"):
+        return "headless"
+    return None
+
+
+@cbook.deprecated("3.0")
+def pylab_setup(name=None):
+    """
+    Return new_figure_manager, draw_if_interactive and show for pyplot.
+
+    This provides the backend-specific functions that are used by pyplot to
+    abstract away the difference between backends.
+
+    Parameters
+    ----------
+    name : str, optional
+        The name of the backend to use.  If `None`, falls back to
+        ``matplotlib.get_backend()`` (which return :rc:`backend`).
+
+    Returns
+    -------
+    backend_mod : module
+        The module which contains the backend of choice
+
+    new_figure_manager : function
+        Create a new figure manager (roughly maps to GUI window)
+
+    draw_if_interactive : function
+        Redraw the current figure if pyplot is interactive
+
+    show : function
+        Show (and possibly block) any unshown figures.
+    """
+    # Import the requested backend into a generic module object.
+    if name is None:
+        name = matplotlib.get_backend()
+    backend_name = (name[9:] if name.startswith("module://")
+                    else "matplotlib.backends.backend_{}".format(name.lower()))
+    backend_mod = importlib.import_module(backend_name)
+    # Create a local Backend class whose body corresponds to the contents of
+    # the backend module.  This allows the Backend class to fill in the missing
+    # methods through inheritance.
+    Backend = type("Backend", (_Backend,), vars(backend_mod))
+
+    # Need to keep a global reference to the backend for compatibility reasons.
+    # See https://github.com/matplotlib/matplotlib/issues/6092
+    global backend
+    backend = name
+
+    _log.debug('backend %s version %s', name, Backend.backend_version)
+    return (backend_mod,
+            Backend.new_figure_manager,
+            Backend.draw_if_interactive,
+            Backend.show)

utils/venv/lib/python3.6/site-packages/matplotlib/backends/_gtk3_compat.py

@@ -0,0 +1,47 @@
+"""
+GObject compatibility loader; supports ``gi`` and ``pgi``.
+
+The binding selection rules are as follows:
+- if ``gi`` has already been imported, use it; else
+- if ``pgi`` has already been imported, use it; else
+- if ``gi`` can be imported, use it; else
+- if ``pgi`` can be imported, use it; else
+- error out.
+
+Thus, to force usage of PGI when both bindings are installed, import it first.
+"""
+
+import importlib
+import sys
+
+if "gi" in sys.modules:
+    import gi
+elif "pgi" in sys.modules:
+    import pgi as gi
+else:
+    try:
+        import gi
+    except ImportError:
+        try:
+            import pgi as gi
+        except ImportError:
+            raise ImportError("The GTK3 backends require PyGObject or pgi")
+
+from .backend_cairo import cairo  # noqa
+# The following combinations are allowed:
+#   gi + pycairo
+#   gi + cairocffi
+#   pgi + cairocffi
+# (pgi doesn't work with pycairo)
+# We always try to import cairocffi first so if a check below fails it means
+# that cairocffi was unavailable to start with.
+if gi.__name__ == "pgi" and cairo.__name__ == "cairo":
+    raise ImportError("pgi and pycairo are not compatible")
+
+if gi.__name__ == "pgi" and gi.version_info < (0, 0, 11, 2):
+    raise ImportError("The GTK3 backends are incompatible with pgi<0.0.11.2")
+gi.require_version("Gtk", "3.0")
+globals().update(
+    {name:
+     importlib.import_module("{}.repository.{}".format(gi.__name__, name))
+     for name in ["GLib", "GObject", "Gtk", "Gdk"]})

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_agg.py

@@ -0,0 +1,595 @@
+"""
+An agg http://antigrain.com/ backend
+
+Features that are implemented
+
+ * capstyles and join styles
+ * dashes
+ * linewidth
+ * lines, rectangles, ellipses
+ * clipping to a rectangle
+ * output to RGBA and PNG, optionally JPEG and TIFF
+ * alpha blending
+ * DPI scaling properly - everything scales properly (dashes, linewidths, etc)
+ * draw polygon
+ * freetype2 w/ ft2font
+
+TODO:
+
+  * integrate screen dpi w/ ppi and text
+
+"""
+try:
+    import threading
+except ImportError:
+    import dummy_threading as threading
+import numpy as np
+from collections import OrderedDict
+from math import radians, cos, sin
+from matplotlib import cbook, rcParams, __version__
+from matplotlib.backend_bases import (
+    _Backend, FigureCanvasBase, FigureManagerBase, RendererBase)
+from matplotlib.font_manager import findfont, get_font
+from matplotlib.ft2font import (LOAD_FORCE_AUTOHINT, LOAD_NO_HINTING,
+                                LOAD_DEFAULT, LOAD_NO_AUTOHINT)
+from matplotlib.mathtext import MathTextParser
+from matplotlib.path import Path
+from matplotlib.transforms import Bbox, BboxBase
+from matplotlib import colors as mcolors
+
+from matplotlib.backends._backend_agg import RendererAgg as _RendererAgg
+from matplotlib import _png
+
+from matplotlib.backend_bases import _has_pil
+
+if _has_pil:
+    from PIL import Image
+
+backend_version = 'v2.2'
+
+def get_hinting_flag():
+    mapping = {
+        True: LOAD_FORCE_AUTOHINT,
+        False: LOAD_NO_HINTING,
+        'either': LOAD_DEFAULT,
+        'native': LOAD_NO_AUTOHINT,
+        'auto': LOAD_FORCE_AUTOHINT,
+        'none': LOAD_NO_HINTING
+        }
+    return mapping[rcParams['text.hinting']]
+
+
+class RendererAgg(RendererBase):
+    """
+    The renderer handles all the drawing primitives using a graphics
+    context instance that controls the colors/styles
+    """
+
+    # we want to cache the fonts at the class level so that when
+    # multiple figures are created we can reuse them.  This helps with
+    # a bug on windows where the creation of too many figures leads to
+    # too many open file handles.  However, storing them at the class
+    # level is not thread safe.  The solution here is to let the
+    # FigureCanvas acquire a lock on the fontd at the start of the
+    # draw, and release it when it is done.  This allows multiple
+    # renderers to share the cached fonts, but only one figure can
+    # draw at time and so the font cache is used by only one
+    # renderer at a time.
+
+    lock = threading.RLock()
+
+    def __init__(self, width, height, dpi):
+        RendererBase.__init__(self)
+
+        self.dpi = dpi
+        self.width = width
+        self.height = height
+        self._renderer = _RendererAgg(int(width), int(height), dpi)
+        self._filter_renderers = []
+
+        self._update_methods()
+        self.mathtext_parser = MathTextParser('Agg')
+
+        self.bbox = Bbox.from_bounds(0, 0, self.width, self.height)
+
+    def __getstate__(self):
+        # We only want to preserve the init keywords of the Renderer.
+        # Anything else can be re-created.
+        return {'width': self.width, 'height': self.height, 'dpi': self.dpi}
+
+    def __setstate__(self, state):
+        self.__init__(state['width'], state['height'], state['dpi'])
+
+    def _update_methods(self):
+        self.draw_gouraud_triangle = self._renderer.draw_gouraud_triangle
+        self.draw_gouraud_triangles = self._renderer.draw_gouraud_triangles
+        self.draw_image = self._renderer.draw_image
+        self.draw_markers = self._renderer.draw_markers
+        self.draw_path_collection = self._renderer.draw_path_collection
+        self.draw_quad_mesh = self._renderer.draw_quad_mesh
+        self.copy_from_bbox = self._renderer.copy_from_bbox
+        self.get_content_extents = self._renderer.get_content_extents
+
+    def tostring_rgba_minimized(self):
+        extents = self.get_content_extents()
+        bbox = [[extents[0], self.height - (extents[1] + extents[3])],
+                [extents[0] + extents[2], self.height - extents[1]]]
+        region = self.copy_from_bbox(bbox)
+        return np.array(region), extents
+
+    def draw_path(self, gc, path, transform, rgbFace=None):
+        """
+        Draw the path
+        """
+        nmax = rcParams['agg.path.chunksize'] # here at least for testing
+        npts = path.vertices.shape[0]
+
+        if (nmax > 100 and npts > nmax and path.should_simplify and
+                rgbFace is None and gc.get_hatch() is None):
+            nch = np.ceil(npts / nmax)
+            chsize = int(np.ceil(npts / nch))
+            i0 = np.arange(0, npts, chsize)
+            i1 = np.zeros_like(i0)
+            i1[:-1] = i0[1:] - 1
+            i1[-1] = npts
+            for ii0, ii1 in zip(i0, i1):
+                v = path.vertices[ii0:ii1, :]
+                c = path.codes
+                if c is not None:
+                    c = c[ii0:ii1]
+                    c[0] = Path.MOVETO  # move to end of last chunk
+                p = Path(v, c)
+                try:
+                    self._renderer.draw_path(gc, p, transform, rgbFace)
+                except OverflowError:
+                    raise OverflowError("Exceeded cell block limit (set "
+                                        "'agg.path.chunksize' rcparam)")
+        else:
+            try:
+                self._renderer.draw_path(gc, path, transform, rgbFace)
+            except OverflowError:
+                raise OverflowError("Exceeded cell block limit (set "
+                                    "'agg.path.chunksize' rcparam)")
+
+    def draw_mathtext(self, gc, x, y, s, prop, angle):
+        """
+        Draw the math text using matplotlib.mathtext
+        """
+        ox, oy, width, height, descent, font_image, used_characters = \
+            self.mathtext_parser.parse(s, self.dpi, prop)
+
+        xd = descent * sin(radians(angle))
+        yd = descent * cos(radians(angle))
+        x = np.round(x + ox + xd)
+        y = np.round(y - oy + yd)
+        self._renderer.draw_text_image(font_image, x, y + 1, angle, gc)
+
+    def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
+        """
+        Render the text
+        """
+        if ismath:
+            return self.draw_mathtext(gc, x, y, s, prop, angle)
+
+        flags = get_hinting_flag()
+        font = self._get_agg_font(prop)
+
+        if font is None:
+            return None
+        if len(s) == 1 and ord(s) > 127:
+            font.load_char(ord(s), flags=flags)
+        else:
+            # We pass '0' for angle here, since it will be rotated (in raster
+            # space) in the following call to draw_text_image).
+            font.set_text(s, 0, flags=flags)
+        font.draw_glyphs_to_bitmap(antialiased=rcParams['text.antialiased'])
+        d = font.get_descent() / 64.0
+        # The descent needs to be adjusted for the angle.
+        xo, yo = font.get_bitmap_offset()
+        xo /= 64.0
+        yo /= 64.0
+        xd = -d * sin(radians(angle))
+        yd = d * cos(radians(angle))
+
+        self._renderer.draw_text_image(
+            font, np.round(x - xd + xo), np.round(y + yd + yo) + 1, angle, gc)
+
+    def get_text_width_height_descent(self, s, prop, ismath):
+        """
+        Get the width, height, and descent (offset from the bottom
+        to the baseline), in display coords, of the string *s* with
+        :class:`~matplotlib.font_manager.FontProperties` *prop*
+        """
+        if ismath in ["TeX", "TeX!"]:
+            # todo: handle props
+            size = prop.get_size_in_points()
+            texmanager = self.get_texmanager()
+            fontsize = prop.get_size_in_points()
+            w, h, d = texmanager.get_text_width_height_descent(
+                s, fontsize, renderer=self)
+            return w, h, d
+
+        if ismath:
+            ox, oy, width, height, descent, fonts, used_characters = \
+                self.mathtext_parser.parse(s, self.dpi, prop)
+            return width, height, descent
+
+        flags = get_hinting_flag()
+        font = self._get_agg_font(prop)
+        font.set_text(s, 0.0, flags=flags)
+        w, h = font.get_width_height()  # width and height of unrotated string
+        d = font.get_descent()
+        w /= 64.0  # convert from subpixels
+        h /= 64.0
+        d /= 64.0
+        return w, h, d
+
+    def draw_tex(self, gc, x, y, s, prop, angle, ismath='TeX!', mtext=None):
+        # todo, handle props, angle, origins
+        size = prop.get_size_in_points()
+
+        texmanager = self.get_texmanager()
+
+        Z = texmanager.get_grey(s, size, self.dpi)
+        Z = np.array(Z * 255.0, np.uint8)
+
+        w, h, d = self.get_text_width_height_descent(s, prop, ismath)
+        xd = d * sin(radians(angle))
+        yd = d * cos(radians(angle))
+        x = np.round(x + xd)
+        y = np.round(y + yd)
+
+        self._renderer.draw_text_image(Z, x, y, angle, gc)
+
+    def get_canvas_width_height(self):
+        'return the canvas width and height in display coords'
+        return self.width, self.height
+
+    def _get_agg_font(self, prop):
+        """
+        Get the font for text instance t, caching for efficiency
+        """
+        fname = findfont(prop)
+        font = get_font(fname)
+
+        font.clear()
+        size = prop.get_size_in_points()
+        font.set_size(size, self.dpi)
+
+        return font
+
+    def points_to_pixels(self, points):
+        """
+        convert point measures to pixes using dpi and the pixels per
+        inch of the display
+        """
+        return points * self.dpi / 72
+
+    def tostring_rgb(self):
+        return self._renderer.tostring_rgb()
+
+    def tostring_argb(self):
+        return self._renderer.tostring_argb()
+
+    def buffer_rgba(self):
+        return self._renderer.buffer_rgba()
+
+    def clear(self):
+        self._renderer.clear()
+
+    def option_image_nocomposite(self):
+        # It is generally faster to composite each image directly to
+        # the Figure, and there's no file size benefit to compositing
+        # with the Agg backend
+        return True
+
+    def option_scale_image(self):
+        """
+        agg backend doesn't support arbitrary scaling of image.
+        """
+        return False
+
+    def restore_region(self, region, bbox=None, xy=None):
+        """
+        Restore the saved region. If bbox (instance of BboxBase, or
+        its extents) is given, only the region specified by the bbox
+        will be restored. *xy* (a tuple of two floasts) optionally
+        specifies the new position (the LLC of the original region,
+        not the LLC of the bbox) where the region will be restored.
+
+        >>> region = renderer.copy_from_bbox()
+        >>> x1, y1, x2, y2 = region.get_extents()
+        >>> renderer.restore_region(region, bbox=(x1+dx, y1, x2, y2),
+        ...                         xy=(x1-dx, y1))
+
+        """
+        if bbox is not None or xy is not None:
+            if bbox is None:
+                x1, y1, x2, y2 = region.get_extents()
+            elif isinstance(bbox, BboxBase):
+                x1, y1, x2, y2 = bbox.extents
+            else:
+                x1, y1, x2, y2 = bbox
+
+            if xy is None:
+                ox, oy = x1, y1
+            else:
+                ox, oy = xy
+
+            # The incoming data is float, but the _renderer type-checking wants
+            # to see integers.
+            self._renderer.restore_region(region, int(x1), int(y1),
+                                          int(x2), int(y2), int(ox), int(oy))
+
+        else:
+            self._renderer.restore_region(region)
+
+    def start_filter(self):
+        """
+        Start filtering. It simply create a new canvas (the old one is saved).
+        """
+        self._filter_renderers.append(self._renderer)
+        self._renderer = _RendererAgg(int(self.width), int(self.height),
+                                      self.dpi)
+        self._update_methods()
+
+    def stop_filter(self, post_processing):
+        """
+        Save the plot in the current canvas as a image and apply
+        the *post_processing* function.
+
+           def post_processing(image, dpi):
+             # ny, nx, depth = image.shape
+             # image (numpy array) has RGBA channels and has a depth of 4.
+             ...
+             # create a new_image (numpy array of 4 channels, size can be
+             # different). The resulting image may have offsets from
+             # lower-left corner of the original image
+             return new_image, offset_x, offset_y
+
+        The saved renderer is restored and the returned image from
+        post_processing is plotted (using draw_image) on it.
+        """
+
+        width, height = int(self.width), int(self.height)
+
+        buffer, (l, b, w, h) = self.tostring_rgba_minimized()
+
+        self._renderer = self._filter_renderers.pop()
+        self._update_methods()
+
+        if w > 0 and h > 0:
+            img = np.fromstring(buffer, np.uint8)
+            img, ox, oy = post_processing(img.reshape((h, w, 4)) / 255.,
+                                          self.dpi)
+            gc = self.new_gc()
+            if img.dtype.kind == 'f':
+                img = np.asarray(img * 255., np.uint8)
+            img = img[::-1]
+            self._renderer.draw_image(gc, l + ox, height - b - h + oy, img)
+
+
+class FigureCanvasAgg(FigureCanvasBase):
+    """
+    The canvas the figure renders into.  Calls the draw and print fig
+    methods, creates the renderers, etc...
+
+    Attributes
+    ----------
+    figure : `matplotlib.figure.Figure`
+        A high-level Figure instance
+
+    """
+
+    def copy_from_bbox(self, bbox):
+        renderer = self.get_renderer()
+        return renderer.copy_from_bbox(bbox)
+
+    def restore_region(self, region, bbox=None, xy=None):
+        renderer = self.get_renderer()
+        return renderer.restore_region(region, bbox, xy)
+
+    def draw(self):
+        """
+        Draw the figure using the renderer.
+        """
+        self.renderer = self.get_renderer(cleared=True)
+        # acquire a lock on the shared font cache
+        RendererAgg.lock.acquire()
+
+        toolbar = self.toolbar
+        try:
+            self.figure.draw(self.renderer)
+            # A GUI class may be need to update a window using this draw, so
+            # don't forget to call the superclass.
+            super().draw()
+        finally:
+            RendererAgg.lock.release()
+
+    def get_renderer(self, cleared=False):
+        l, b, w, h = self.figure.bbox.bounds
+        key = w, h, self.figure.dpi
+        try: self._lastKey, self.renderer
+        except AttributeError: need_new_renderer = True
+        else:  need_new_renderer = (self._lastKey != key)
+
+        if need_new_renderer:
+            self.renderer = RendererAgg(w, h, self.figure.dpi)
+            self._lastKey = key
+        elif cleared:
+            self.renderer.clear()
+        return self.renderer
+
+    def tostring_rgb(self):
+        '''Get the image as an RGB byte string.
+
+        `draw` must be called at least once before this function will work and
+        to update the renderer for any subsequent changes to the Figure.
+
+        Returns
+        -------
+        bytes
+        '''
+        return self.renderer.tostring_rgb()
+
+    def tostring_argb(self):
+        '''Get the image as an ARGB byte string
+
+        `draw` must be called at least once before this function will work and
+        to update the renderer for any subsequent changes to the Figure.
+
+        Returns
+        -------
+        bytes
+
+        '''
+        return self.renderer.tostring_argb()
+
+    def buffer_rgba(self):
+        '''Get the image as an RGBA byte string.
+
+        `draw` must be called at least once before this function will work and
+        to update the renderer for any subsequent changes to the Figure.
+
+        Returns
+        -------
+        bytes
+        '''
+        return self.renderer.buffer_rgba()
+
+    def print_raw(self, filename_or_obj, *args, **kwargs):
+        FigureCanvasAgg.draw(self)
+        renderer = self.get_renderer()
+        with cbook._setattr_cm(renderer, dpi=self.figure.dpi), \
+                cbook.open_file_cm(filename_or_obj, "wb") as fh:
+            fh.write(renderer._renderer.buffer_rgba())
+    print_rgba = print_raw
+
+    def print_png(self, filename_or_obj, *args, **kwargs):
+        """
+        Write the figure to a PNG file.
+
+        Parameters
+        ----------
+        filename_or_obj : str or PathLike or file-like object
+            The file to write to.
+
+        metadata : dict, optional
+            Metadata in the PNG file as key-value pairs of bytes or latin-1
+            encodable strings.
+            According to the PNG specification, keys must be shorter than 79
+            chars.
+
+            The `PNG specification`_ defines some common keywords that may be
+            used as appropriate:
+
+            - Title: Short (one line) title or caption for image.
+            - Author: Name of image's creator.
+            - Description: Description of image (possibly long).
+            - Copyright: Copyright notice.
+            - Creation Time: Time of original image creation
+              (usually RFC 1123 format).
+            - Software: Software used to create the image.
+            - Disclaimer: Legal disclaimer.
+            - Warning: Warning of nature of content.
+            - Source: Device used to create the image.
+            - Comment: Miscellaneous comment;
+              conversion from other image format.
+
+            Other keywords may be invented for other purposes.
+
+            If 'Software' is not given, an autogenerated value for matplotlib
+            will be used.
+
+            For more details see the `PNG specification`_.
+
+            .. _PNG specification: \
+                https://www.w3.org/TR/2003/REC-PNG-20031110/#11keywords
+
+        """
+        FigureCanvasAgg.draw(self)
+        renderer = self.get_renderer()
+
+        version_str = (
+            'matplotlib version ' + __version__ + ', http://matplotlib.org/')
+        metadata = OrderedDict({'Software': version_str})
+        user_metadata = kwargs.pop("metadata", None)
+        if user_metadata is not None:
+            metadata.update(user_metadata)
+
+        with cbook._setattr_cm(renderer, dpi=self.figure.dpi), \
+                cbook.open_file_cm(filename_or_obj, "wb") as fh:
+            _png.write_png(renderer._renderer, fh,
+                            self.figure.dpi, metadata=metadata)
+
+    def print_to_buffer(self):
+        FigureCanvasAgg.draw(self)
+        renderer = self.get_renderer()
+        with cbook._setattr_cm(renderer, dpi=self.figure.dpi):
+            return (renderer._renderer.buffer_rgba(),
+                    (int(renderer.width), int(renderer.height)))
+
+    if _has_pil:
+        # add JPEG support
+        def print_jpg(self, filename_or_obj, *args, dryrun=False, **kwargs):
+            """
+            Write the figure to a JPEG file.
+
+            Parameters
+            ----------
+            filename_or_obj : str or PathLike or file-like object
+                The file to write to.
+
+            Other Parameters
+            ----------------
+            quality : int
+                The image quality, on a scale from 1 (worst) to 100 (best).
+                The default is :rc:`savefig.jpeg_quality`.  Values above
+                95 should be avoided; 100 completely disables the JPEG
+                quantization stage.
+
+            optimize : bool
+                If present, indicates that the encoder should
+                make an extra pass over the image in order to select
+                optimal encoder settings.
+
+            progressive : bool
+                If present, indicates that this image
+                should be stored as a progressive JPEG file.
+            """
+            buf, size = self.print_to_buffer()
+            if dryrun:
+                return
+            # The image is "pasted" onto a white background image to safely
+            # handle any transparency
+            image = Image.frombuffer('RGBA', size, buf, 'raw', 'RGBA', 0, 1)
+            rgba = mcolors.to_rgba(rcParams['savefig.facecolor'])
+            color = tuple([int(x * 255) for x in rgba[:3]])
+            background = Image.new('RGB', size, color)
+            background.paste(image, image)
+            options = {k: kwargs[k]
+                       for k in ['quality', 'optimize', 'progressive', 'dpi']
+                       if k in kwargs}
+            options.setdefault('quality', rcParams['savefig.jpeg_quality'])
+            if 'dpi' in options:
+                # Set the same dpi in both x and y directions
+                options['dpi'] = (options['dpi'], options['dpi'])
+
+            return background.save(filename_or_obj, format='jpeg', **options)
+        print_jpeg = print_jpg
+
+        # add TIFF support
+        def print_tif(self, filename_or_obj, *args, dryrun=False, **kwargs):
+            buf, size = self.print_to_buffer()
+            if dryrun:
+                return
+            image = Image.frombuffer('RGBA', size, buf, 'raw', 'RGBA', 0, 1)
+            dpi = (self.figure.dpi, self.figure.dpi)
+            return image.save(filename_or_obj, format='tiff', dpi=dpi)
+        print_tiff = print_tif
+
+
+@_Backend.export
+class _BackendAgg(_Backend):
+    FigureCanvas = FigureCanvasAgg
+    FigureManager = FigureManagerBase

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_cairo.py

@@ -0,0 +1,633 @@
+"""
+A Cairo backend for matplotlib
+==============================
+:Author: Steve Chaplin and others
+
+This backend depends on cairocffi or pycairo.
+"""
+
+import copy
+import gzip
+import sys
+import warnings
+
+import numpy as np
+
+# cairocffi is more widely compatible than pycairo (in particular pgi only
+# works with cairocffi) so try it first.
+try:
+    import cairocffi as cairo
+except ImportError:
+    try:
+        import cairo
+    except ImportError:
+        raise ImportError("cairo backend requires that cairocffi or pycairo "
+                          "is installed")
+    else:
+        if cairo.version_info < (1, 11, 0):
+            # Introduced create_for_data for Py3.
+            raise ImportError(
+                "cairo {} is installed; cairo>=1.11.0 is required"
+                .format(cairo.version))
+
+backend_version = cairo.version
+
+from .. import cbook
+from matplotlib.backend_bases import (
+    _Backend, FigureCanvasBase, FigureManagerBase, GraphicsContextBase,
+    RendererBase)
+from matplotlib.font_manager import ttfFontProperty
+from matplotlib.mathtext import MathTextParser
+from matplotlib.path import Path
+from matplotlib.transforms import Affine2D
+
+
+if cairo.__name__ == "cairocffi":
+    # Convert a pycairo context to a cairocffi one.
+    def _to_context(ctx):
+        if not isinstance(ctx, cairo.Context):
+            ctx = cairo.Context._from_pointer(
+                cairo.ffi.cast(
+                    'cairo_t **',
+                    id(ctx) + object.__basicsize__)[0],
+                incref=True)
+        return ctx
+else:
+    # Pass-through a pycairo context.
+    def _to_context(ctx):
+        return ctx
+
+
+@cbook.deprecated("3.0")
+class ArrayWrapper:
+    """Thin wrapper around numpy ndarray to expose the interface
+       expected by cairocffi. Basically replicates the
+       array.array interface.
+    """
+    def __init__(self, myarray):
+        self.__array = myarray
+        self.__data = myarray.ctypes.data
+        self.__size = len(myarray.flatten())
+        self.itemsize = myarray.itemsize
+
+    def buffer_info(self):
+        return (self.__data, self.__size)
+
+
+# Mapping from Matplotlib Path codes to cairo path codes.
+_MPL_TO_CAIRO_PATH_TYPE = np.zeros(80, dtype=int)  # CLOSEPOLY = 79.
+_MPL_TO_CAIRO_PATH_TYPE[Path.MOVETO] = cairo.PATH_MOVE_TO
+_MPL_TO_CAIRO_PATH_TYPE[Path.LINETO] = cairo.PATH_LINE_TO
+_MPL_TO_CAIRO_PATH_TYPE[Path.CURVE4] = cairo.PATH_CURVE_TO
+_MPL_TO_CAIRO_PATH_TYPE[Path.CLOSEPOLY] = cairo.PATH_CLOSE_PATH
+# Sizes in cairo_path_data_t of each cairo path element.
+_CAIRO_PATH_TYPE_SIZES = np.zeros(4, dtype=int)
+_CAIRO_PATH_TYPE_SIZES[cairo.PATH_MOVE_TO] = 2
+_CAIRO_PATH_TYPE_SIZES[cairo.PATH_LINE_TO] = 2
+_CAIRO_PATH_TYPE_SIZES[cairo.PATH_CURVE_TO] = 4
+_CAIRO_PATH_TYPE_SIZES[cairo.PATH_CLOSE_PATH] = 1
+
+
+def _append_paths_slow(ctx, paths, transforms, clip=None):
+    for path, transform in zip(paths, transforms):
+        for points, code in path.iter_segments(
+                transform, remove_nans=True, clip=clip):
+            if code == Path.MOVETO:
+                ctx.move_to(*points)
+            elif code == Path.CLOSEPOLY:
+                ctx.close_path()
+            elif code == Path.LINETO:
+                ctx.line_to(*points)
+            elif code == Path.CURVE3:
+                cur = ctx.get_current_point()
+                ctx.curve_to(
+                    *np.concatenate([cur / 3 + points[:2] * 2 / 3,
+                                     points[:2] * 2 / 3 + points[-2:] / 3]))
+            elif code == Path.CURVE4:
+                ctx.curve_to(*points)
+
+
+def _append_paths_fast(ctx, paths, transforms, clip=None):
+    # We directly convert to the internal representation used by cairo, for
+    # which ABI compatibility is guaranteed.  The layout for each item is
+    # --CODE(4)--  -LENGTH(4)-  ---------PAD(8)---------
+    # ----------X(8)----------  ----------Y(8)----------
+    # with the size in bytes in parentheses, and (X, Y) repeated as many times
+    # as there are points for the current code.
+    ffi = cairo.ffi
+
+    # Convert curves to segment, so that 1. we don't have to handle
+    # variable-sized CURVE-n codes, and 2. we don't have to implement degree
+    # elevation for quadratic Beziers.
+    cleaneds = [path.cleaned(transform, remove_nans=True, clip=clip)
+                for path, transform in zip(paths, transforms)]
+    vertices = np.concatenate([cleaned.vertices for cleaned in cleaneds])
+    codes = np.concatenate([cleaned.codes for cleaned in cleaneds])
+
+    # Remove unused vertices and convert to cairo codes.  Note that unlike
+    # cairo_close_path, we do not explicitly insert an extraneous MOVE_TO after
+    # CLOSE_PATH, so our resulting buffer may be smaller.
+    vertices = vertices[(codes != Path.STOP) & (codes != Path.CLOSEPOLY)]
+    codes = codes[codes != Path.STOP]
+    codes = _MPL_TO_CAIRO_PATH_TYPE[codes]
+
+    # Where are the headers of each cairo portions?
+    cairo_type_sizes = _CAIRO_PATH_TYPE_SIZES[codes]
+    cairo_type_positions = np.insert(np.cumsum(cairo_type_sizes), 0, 0)
+    cairo_num_data = cairo_type_positions[-1]
+    cairo_type_positions = cairo_type_positions[:-1]
+
+    # Fill the buffer.
+    buf = np.empty(cairo_num_data * 16, np.uint8)
+    as_int = np.frombuffer(buf.data, np.int32)
+    as_int[::4][cairo_type_positions] = codes
+    as_int[1::4][cairo_type_positions] = cairo_type_sizes
+    as_float = np.frombuffer(buf.data, np.float64)
+    mask = np.ones_like(as_float, bool)
+    mask[::2][cairo_type_positions] = mask[1::2][cairo_type_positions] = False
+    as_float[mask] = vertices.ravel()
+
+    # Construct the cairo_path_t, and pass it to the context.
+    ptr = ffi.new("cairo_path_t *")
+    ptr.status = cairo.STATUS_SUCCESS
+    ptr.data = ffi.cast("cairo_path_data_t *", ffi.from_buffer(buf))
+    ptr.num_data = cairo_num_data
+    cairo.cairo.cairo_append_path(ctx._pointer, ptr)
+
+
+_append_paths = (_append_paths_fast if cairo.__name__ == "cairocffi"
+                 else _append_paths_slow)
+
+
+def _append_path(ctx, path, transform, clip=None):
+    return _append_paths(ctx, [path], [transform], clip)
+
+
+class RendererCairo(RendererBase):
+    fontweights = {
+        100          : cairo.FONT_WEIGHT_NORMAL,
+        200          : cairo.FONT_WEIGHT_NORMAL,
+        300          : cairo.FONT_WEIGHT_NORMAL,
+        400          : cairo.FONT_WEIGHT_NORMAL,
+        500          : cairo.FONT_WEIGHT_NORMAL,
+        600          : cairo.FONT_WEIGHT_BOLD,
+        700          : cairo.FONT_WEIGHT_BOLD,
+        800          : cairo.FONT_WEIGHT_BOLD,
+        900          : cairo.FONT_WEIGHT_BOLD,
+        'ultralight' : cairo.FONT_WEIGHT_NORMAL,
+        'light'      : cairo.FONT_WEIGHT_NORMAL,
+        'normal'     : cairo.FONT_WEIGHT_NORMAL,
+        'medium'     : cairo.FONT_WEIGHT_NORMAL,
+        'regular'    : cairo.FONT_WEIGHT_NORMAL,
+        'semibold'   : cairo.FONT_WEIGHT_BOLD,
+        'bold'       : cairo.FONT_WEIGHT_BOLD,
+        'heavy'      : cairo.FONT_WEIGHT_BOLD,
+        'ultrabold'  : cairo.FONT_WEIGHT_BOLD,
+        'black'      : cairo.FONT_WEIGHT_BOLD,
+                   }
+    fontangles = {
+        'italic'  : cairo.FONT_SLANT_ITALIC,
+        'normal'  : cairo.FONT_SLANT_NORMAL,
+        'oblique' : cairo.FONT_SLANT_OBLIQUE,
+        }
+
+
+    def __init__(self, dpi):
+        self.dpi = dpi
+        self.gc = GraphicsContextCairo(renderer=self)
+        self.text_ctx = cairo.Context(
+           cairo.ImageSurface(cairo.FORMAT_ARGB32, 1, 1))
+        self.mathtext_parser = MathTextParser('Cairo')
+        RendererBase.__init__(self)
+
+    def set_ctx_from_surface(self, surface):
+        self.gc.ctx = cairo.Context(surface)
+        # Although it may appear natural to automatically call
+        # `self.set_width_height(surface.get_width(), surface.get_height())`
+        # here (instead of having the caller do so separately), this would fail
+        # for PDF/PS/SVG surfaces, which have no way to report their extents.
+
+    def set_width_height(self, width, height):
+        self.width  = width
+        self.height = height
+
+    def _fill_and_stroke(self, ctx, fill_c, alpha, alpha_overrides):
+        if fill_c is not None:
+            ctx.save()
+            if len(fill_c) == 3 or alpha_overrides:
+                ctx.set_source_rgba(fill_c[0], fill_c[1], fill_c[2], alpha)
+            else:
+                ctx.set_source_rgba(fill_c[0], fill_c[1], fill_c[2], fill_c[3])
+            ctx.fill_preserve()
+            ctx.restore()
+        ctx.stroke()
+
+    @staticmethod
+    @cbook.deprecated("3.0")
+    def convert_path(ctx, path, transform, clip=None):
+        _append_path(ctx, path, transform, clip)
+
+    def draw_path(self, gc, path, transform, rgbFace=None):
+        ctx = gc.ctx
+        # Clip the path to the actual rendering extents if it isn't filled.
+        clip = (ctx.clip_extents()
+                if rgbFace is None and gc.get_hatch() is None
+                else None)
+        transform = (transform
+                     + Affine2D().scale(1, -1).translate(0, self.height))
+        ctx.new_path()
+        _append_path(ctx, path, transform, clip)
+        self._fill_and_stroke(
+            ctx, rgbFace, gc.get_alpha(), gc.get_forced_alpha())
+
+    def draw_markers(self, gc, marker_path, marker_trans, path, transform,
+                     rgbFace=None):
+        ctx = gc.ctx
+
+        ctx.new_path()
+        # Create the path for the marker; it needs to be flipped here already!
+        _append_path(ctx, marker_path, marker_trans + Affine2D().scale(1, -1))
+        marker_path = ctx.copy_path_flat()
+
+        # Figure out whether the path has a fill
+        x1, y1, x2, y2 = ctx.fill_extents()
+        if x1 == 0 and y1 == 0 and x2 == 0 and y2 == 0:
+            filled = False
+            # No fill, just unset this (so we don't try to fill it later on)
+            rgbFace = None
+        else:
+            filled = True
+
+        transform = (transform
+                     + Affine2D().scale(1, -1).translate(0, self.height))
+
+        ctx.new_path()
+        for i, (vertices, codes) in enumerate(
+                path.iter_segments(transform, simplify=False)):
+            if len(vertices):
+                x, y = vertices[-2:]
+                ctx.save()
+
+                # Translate and apply path
+                ctx.translate(x, y)
+                ctx.append_path(marker_path)
+
+                ctx.restore()
+
+                # Slower code path if there is a fill; we need to draw
+                # the fill and stroke for each marker at the same time.
+                # Also flush out the drawing every once in a while to
+                # prevent the paths from getting way too long.
+                if filled or i % 1000 == 0:
+                    self._fill_and_stroke(
+                        ctx, rgbFace, gc.get_alpha(), gc.get_forced_alpha())
+
+        # Fast path, if there is no fill, draw everything in one step
+        if not filled:
+            self._fill_and_stroke(
+                ctx, rgbFace, gc.get_alpha(), gc.get_forced_alpha())
+
+    def draw_path_collection(
+            self, gc, master_transform, paths, all_transforms, offsets,
+            offsetTrans, facecolors, edgecolors, linewidths, linestyles,
+            antialiaseds, urls, offset_position):
+
+        path_ids = []
+        for path, transform in self._iter_collection_raw_paths(
+                master_transform, paths, all_transforms):
+            path_ids.append((path, Affine2D(transform)))
+
+        reuse_key = None
+        grouped_draw = []
+
+        def _draw_paths():
+            if not grouped_draw:
+                return
+            gc_vars, rgb_fc = reuse_key
+            gc = copy.copy(gc0)
+            # We actually need to call the setters to reset the internal state.
+            vars(gc).update(gc_vars)
+            for k, v in gc_vars.items():
+                if k == "_linestyle":  # Deprecated, no effect.
+                    continue
+                try:
+                    getattr(gc, "set" + k)(v)
+                except (AttributeError, TypeError) as e:
+                    pass
+            gc.ctx.new_path()
+            paths, transforms = zip(*grouped_draw)
+            grouped_draw.clear()
+            _append_paths(gc.ctx, paths, transforms)
+            self._fill_and_stroke(
+                gc.ctx, rgb_fc, gc.get_alpha(), gc.get_forced_alpha())
+
+        for xo, yo, path_id, gc0, rgb_fc in self._iter_collection(
+                gc, master_transform, all_transforms, path_ids, offsets,
+                offsetTrans, facecolors, edgecolors, linewidths, linestyles,
+                antialiaseds, urls, offset_position):
+            path, transform = path_id
+            transform = (Affine2D(transform.get_matrix())
+                         .translate(xo, yo - self.height).scale(1, -1))
+            # rgb_fc could be a ndarray, for which equality is elementwise.
+            new_key = vars(gc0), tuple(rgb_fc) if rgb_fc is not None else None
+            if new_key == reuse_key:
+                grouped_draw.append((path, transform))
+            else:
+                _draw_paths()
+                grouped_draw.append((path, transform))
+                reuse_key = new_key
+        _draw_paths()
+
+    def draw_image(self, gc, x, y, im):
+        im = cbook._unmultiplied_rgba8888_to_premultiplied_argb32(im[::-1])
+        surface = cairo.ImageSurface.create_for_data(
+            im.ravel().data, cairo.FORMAT_ARGB32,
+            im.shape[1], im.shape[0], im.shape[1] * 4)
+        ctx = gc.ctx
+        y = self.height - y - im.shape[0]
+
+        ctx.save()
+        ctx.set_source_surface(surface, float(x), float(y))
+        ctx.paint()
+        ctx.restore()
+
+    def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
+        # Note: x,y are device/display coords, not user-coords, unlike other
+        # draw_* methods
+        if ismath:
+            self._draw_mathtext(gc, x, y, s, prop, angle)
+
+        else:
+            ctx = gc.ctx
+            ctx.new_path()
+            ctx.move_to(x, y)
+            ctx.select_font_face(prop.get_name(),
+                                 self.fontangles[prop.get_style()],
+                                 self.fontweights[prop.get_weight()])
+
+            size = prop.get_size_in_points() * self.dpi / 72.0
+
+            ctx.save()
+            if angle:
+                ctx.rotate(np.deg2rad(-angle))
+            ctx.set_font_size(size)
+
+            ctx.show_text(s)
+            ctx.restore()
+
+    def _draw_mathtext(self, gc, x, y, s, prop, angle):
+        ctx = gc.ctx
+        width, height, descent, glyphs, rects = self.mathtext_parser.parse(
+            s, self.dpi, prop)
+
+        ctx.save()
+        ctx.translate(x, y)
+        if angle:
+            ctx.rotate(np.deg2rad(-angle))
+
+        for font, fontsize, s, ox, oy in glyphs:
+            ctx.new_path()
+            ctx.move_to(ox, oy)
+
+            fontProp = ttfFontProperty(font)
+            ctx.select_font_face(fontProp.name,
+                                 self.fontangles[fontProp.style],
+                                 self.fontweights[fontProp.weight])
+
+            size = fontsize * self.dpi / 72.0
+            ctx.set_font_size(size)
+            ctx.show_text(s)
+
+        for ox, oy, w, h in rects:
+            ctx.new_path()
+            ctx.rectangle(ox, oy, w, h)
+            ctx.set_source_rgb(0, 0, 0)
+            ctx.fill_preserve()
+
+        ctx.restore()
+
+    def get_canvas_width_height(self):
+        return self.width, self.height
+
+    def get_text_width_height_descent(self, s, prop, ismath):
+        if ismath:
+            width, height, descent, fonts, used_characters = \
+                self.mathtext_parser.parse(s, self.dpi, prop)
+            return width, height, descent
+
+        ctx = self.text_ctx
+        ctx.save()
+        ctx.select_font_face(prop.get_name(),
+                             self.fontangles[prop.get_style()],
+                             self.fontweights[prop.get_weight()])
+
+        # Cairo (says it) uses 1/96 inch user space units, ref: cairo_gstate.c
+        # but if /96.0 is used the font is too small
+        size = prop.get_size_in_points() * self.dpi / 72
+
+        # problem - scale remembers last setting and font can become
+        # enormous causing program to crash
+        # save/restore prevents the problem
+        ctx.set_font_size(size)
+
+        y_bearing, w, h = ctx.text_extents(s)[1:4]
+        ctx.restore()
+
+        return w, h, h + y_bearing
+
+    def new_gc(self):
+        self.gc.ctx.save()
+        self.gc._alpha = 1
+        self.gc._forced_alpha = False # if True, _alpha overrides A from RGBA
+        return self.gc
+
+    def points_to_pixels(self, points):
+        return points / 72 * self.dpi
+
+
+class GraphicsContextCairo(GraphicsContextBase):
+    _joind = {
+        'bevel' : cairo.LINE_JOIN_BEVEL,
+        'miter' : cairo.LINE_JOIN_MITER,
+        'round' : cairo.LINE_JOIN_ROUND,
+        }
+
+    _capd = {
+        'butt'       : cairo.LINE_CAP_BUTT,
+        'projecting' : cairo.LINE_CAP_SQUARE,
+        'round'      : cairo.LINE_CAP_ROUND,
+        }
+
+    def __init__(self, renderer):
+        GraphicsContextBase.__init__(self)
+        self.renderer = renderer
+
+    def restore(self):
+        self.ctx.restore()
+
+    def set_alpha(self, alpha):
+        GraphicsContextBase.set_alpha(self, alpha)
+        _alpha = self.get_alpha()
+        rgb = self._rgb
+        if self.get_forced_alpha():
+            self.ctx.set_source_rgba(rgb[0], rgb[1], rgb[2], _alpha)
+        else:
+            self.ctx.set_source_rgba(rgb[0], rgb[1], rgb[2], rgb[3])
+
+    # def set_antialiased(self, b):
+        # cairo has many antialiasing modes, we need to pick one for True and
+        # one for False.
+
+    def set_capstyle(self, cs):
+        if cs in ('butt', 'round', 'projecting'):
+            self._capstyle = cs
+            self.ctx.set_line_cap(self._capd[cs])
+        else:
+            raise ValueError('Unrecognized cap style.  Found %s' % cs)
+
+    def set_clip_rectangle(self, rectangle):
+        if not rectangle:
+            return
+        x, y, w, h = np.round(rectangle.bounds)
+        ctx = self.ctx
+        ctx.new_path()
+        ctx.rectangle(x, self.renderer.height - h - y, w, h)
+        ctx.clip()
+
+    def set_clip_path(self, path):
+        if not path:
+            return
+        tpath, affine = path.get_transformed_path_and_affine()
+        ctx = self.ctx
+        ctx.new_path()
+        affine = (affine
+                  + Affine2D().scale(1, -1).translate(0, self.renderer.height))
+        _append_path(ctx, tpath, affine)
+        ctx.clip()
+
+    def set_dashes(self, offset, dashes):
+        self._dashes = offset, dashes
+        if dashes is None:
+            self.ctx.set_dash([], 0)  # switch dashes off
+        else:
+            self.ctx.set_dash(
+                list(self.renderer.points_to_pixels(np.asarray(dashes))),
+                offset)
+
+    def set_foreground(self, fg, isRGBA=None):
+        GraphicsContextBase.set_foreground(self, fg, isRGBA)
+        if len(self._rgb) == 3:
+            self.ctx.set_source_rgb(*self._rgb)
+        else:
+            self.ctx.set_source_rgba(*self._rgb)
+
+    def get_rgb(self):
+        return self.ctx.get_source().get_rgba()[:3]
+
+    def set_joinstyle(self, js):
+        if js in ('miter', 'round', 'bevel'):
+            self._joinstyle = js
+            self.ctx.set_line_join(self._joind[js])
+        else:
+            raise ValueError('Unrecognized join style.  Found %s' % js)
+
+    def set_linewidth(self, w):
+        self._linewidth = float(w)
+        self.ctx.set_line_width(self.renderer.points_to_pixels(w))
+
+
+class FigureCanvasCairo(FigureCanvasBase):
+    supports_blit = False
+
+    def print_png(self, fobj, *args, **kwargs):
+        self._get_printed_image_surface().write_to_png(fobj)
+
+    def print_rgba(self, fobj, *args, **kwargs):
+        width, height = self.get_width_height()
+        buf = self._get_printed_image_surface().get_data()
+        fobj.write(cbook._premultiplied_argb32_to_unmultiplied_rgba8888(
+            np.asarray(buf).reshape((width, height, 4))))
+
+    print_raw = print_rgba
+
+    def _get_printed_image_surface(self):
+        width, height = self.get_width_height()
+        renderer = RendererCairo(self.figure.dpi)
+        renderer.set_width_height(width, height)
+        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
+        renderer.set_ctx_from_surface(surface)
+        self.figure.draw(renderer)
+        return surface
+
+    def print_pdf(self, fobj, *args, **kwargs):
+        return self._save(fobj, 'pdf', *args, **kwargs)
+
+    def print_ps(self, fobj, *args, **kwargs):
+        return self._save(fobj, 'ps', *args, **kwargs)
+
+    def print_svg(self, fobj, *args, **kwargs):
+        return self._save(fobj, 'svg', *args, **kwargs)
+
+    def print_svgz(self, fobj, *args, **kwargs):
+        return self._save(fobj, 'svgz', *args, **kwargs)
+
+    def _save(self, fo, fmt, **kwargs):
+        # save PDF/PS/SVG
+        orientation = kwargs.get('orientation', 'portrait')
+
+        dpi = 72
+        self.figure.dpi = dpi
+        w_in, h_in = self.figure.get_size_inches()
+        width_in_points, height_in_points = w_in * dpi, h_in * dpi
+
+        if orientation == 'landscape':
+            width_in_points, height_in_points = (
+                height_in_points, width_in_points)
+
+        if fmt == 'ps':
+            if not hasattr(cairo, 'PSSurface'):
+                raise RuntimeError('cairo has not been compiled with PS '
+                                   'support enabled')
+            surface = cairo.PSSurface(fo, width_in_points, height_in_points)
+        elif fmt == 'pdf':
+            if not hasattr(cairo, 'PDFSurface'):
+                raise RuntimeError('cairo has not been compiled with PDF '
+                                   'support enabled')
+            surface = cairo.PDFSurface(fo, width_in_points, height_in_points)
+        elif fmt in ('svg', 'svgz'):
+            if not hasattr(cairo, 'SVGSurface'):
+                raise RuntimeError('cairo has not been compiled with SVG '
+                                   'support enabled')
+            if fmt == 'svgz':
+                if isinstance(fo, str):
+                    fo = gzip.GzipFile(fo, 'wb')
+                else:
+                    fo = gzip.GzipFile(None, 'wb', fileobj=fo)
+            surface = cairo.SVGSurface(fo, width_in_points, height_in_points)
+        else:
+            warnings.warn("unknown format: %s" % fmt, stacklevel=2)
+            return
+
+        # surface.set_dpi() can be used
+        renderer = RendererCairo(self.figure.dpi)
+        renderer.set_width_height(width_in_points, height_in_points)
+        renderer.set_ctx_from_surface(surface)
+        ctx = renderer.gc.ctx
+
+        if orientation == 'landscape':
+            ctx.rotate(np.pi / 2)
+            ctx.translate(0, -height_in_points)
+            # Perhaps add an '%%Orientation: Landscape' comment?
+
+        self.figure.draw(renderer)
+
+        ctx.show_page()
+        surface.finish()
+        if fmt == 'svgz':
+            fo.close()
+
+
+@_Backend.export
+class _BackendCairo(_Backend):
+    FigureCanvas = FigureCanvasCairo
+    FigureManager = FigureManagerBase

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_gtk3.py

@@ -0,0 +1,990 @@
+import logging
+import os
+import sys
+
+import matplotlib
+from matplotlib import backend_tools, cbook, rcParams
+from matplotlib._pylab_helpers import Gcf
+from matplotlib.backend_bases import (
+    _Backend, FigureCanvasBase, FigureManagerBase, NavigationToolbar2,
+    StatusbarBase, TimerBase, ToolContainerBase, cursors)
+from matplotlib.backend_managers import ToolManager
+from matplotlib.figure import Figure
+from matplotlib.widgets import SubplotTool
+from ._gtk3_compat import GLib, GObject, Gtk, Gdk
+
+
+_log = logging.getLogger(__name__)
+
+backend_version = "%s.%s.%s" % (
+    Gtk.get_major_version(), Gtk.get_micro_version(), Gtk.get_minor_version())
+
+# the true dots per inch on the screen; should be display dependent
+# see http://groups.google.com/groups?q=screen+dpi+x11&hl=en&lr=&ie=UTF-8&oe=UTF-8&safe=off&selm=7077.26e81ad5%40swift.cs.tcd.ie&rnum=5 for some info about screen dpi
+PIXELS_PER_INCH = 96
+
+try:
+    cursord = {
+        cursors.MOVE          : Gdk.Cursor.new(Gdk.CursorType.FLEUR),
+        cursors.HAND          : Gdk.Cursor.new(Gdk.CursorType.HAND2),
+        cursors.POINTER       : Gdk.Cursor.new(Gdk.CursorType.LEFT_PTR),
+        cursors.SELECT_REGION : Gdk.Cursor.new(Gdk.CursorType.TCROSS),
+        cursors.WAIT          : Gdk.Cursor.new(Gdk.CursorType.WATCH),
+    }
+except TypeError as exc:
+    # Happens when running headless.  Convert to ImportError to cooperate with
+    # backend switching.
+    raise ImportError(exc)
+
+
+class TimerGTK3(TimerBase):
+    '''
+    Subclass of :class:`backend_bases.TimerBase` using GTK3 for timer events.
+
+    Attributes
+    ----------
+    interval : int
+        The time between timer events in milliseconds. Default is 1000 ms.
+    single_shot : bool
+        Boolean flag indicating whether this timer should operate as single
+        shot (run once and then stop). Defaults to False.
+    callbacks : list
+        Stores list of (func, args) tuples that will be called upon timer
+        events. This list can be manipulated directly, or the functions
+        `add_callback` and `remove_callback` can be used.
+
+    '''
+    def _timer_start(self):
+        # Need to stop it, otherwise we potentially leak a timer id that will
+        # never be stopped.
+        self._timer_stop()
+        self._timer = GLib.timeout_add(self._interval, self._on_timer)
+
+    def _timer_stop(self):
+        if self._timer is not None:
+            GLib.source_remove(self._timer)
+            self._timer = None
+
+    def _timer_set_interval(self):
+        # Only stop and restart it if the timer has already been started
+        if self._timer is not None:
+            self._timer_stop()
+            self._timer_start()
+
+    def _on_timer(self):
+        TimerBase._on_timer(self)
+
+        # Gtk timeout_add() requires that the callback returns True if it
+        # is to be called again.
+        if self.callbacks and not self._single:
+            return True
+        else:
+            self._timer = None
+            return False
+
+
+class FigureCanvasGTK3(Gtk.DrawingArea, FigureCanvasBase):
+    keyvald = {65507: 'control',
+               65505: 'shift',
+               65513: 'alt',
+               65508: 'control',
+               65506: 'shift',
+               65514: 'alt',
+               65361: 'left',
+               65362: 'up',
+               65363: 'right',
+               65364: 'down',
+               65307: 'escape',
+               65470: 'f1',
+               65471: 'f2',
+               65472: 'f3',
+               65473: 'f4',
+               65474: 'f5',
+               65475: 'f6',
+               65476: 'f7',
+               65477: 'f8',
+               65478: 'f9',
+               65479: 'f10',
+               65480: 'f11',
+               65481: 'f12',
+               65300: 'scroll_lock',
+               65299: 'break',
+               65288: 'backspace',
+               65293: 'enter',
+               65379: 'insert',
+               65535: 'delete',
+               65360: 'home',
+               65367: 'end',
+               65365: 'pageup',
+               65366: 'pagedown',
+               65438: '0',
+               65436: '1',
+               65433: '2',
+               65435: '3',
+               65430: '4',
+               65437: '5',
+               65432: '6',
+               65429: '7',
+               65431: '8',
+               65434: '9',
+               65451: '+',
+               65453: '-',
+               65450: '*',
+               65455: '/',
+               65439: 'dec',
+               65421: 'enter',
+               }
+
+    # Setting this as a static constant prevents
+    # this resulting expression from leaking
+    event_mask = (Gdk.EventMask.BUTTON_PRESS_MASK   |
+                  Gdk.EventMask.BUTTON_RELEASE_MASK |
+                  Gdk.EventMask.EXPOSURE_MASK       |
+                  Gdk.EventMask.KEY_PRESS_MASK      |
+                  Gdk.EventMask.KEY_RELEASE_MASK    |
+                  Gdk.EventMask.ENTER_NOTIFY_MASK   |
+                  Gdk.EventMask.LEAVE_NOTIFY_MASK   |
+                  Gdk.EventMask.POINTER_MOTION_MASK |
+                  Gdk.EventMask.POINTER_MOTION_HINT_MASK|
+                  Gdk.EventMask.SCROLL_MASK)
+
+    def __init__(self, figure):
+        FigureCanvasBase.__init__(self, figure)
+        GObject.GObject.__init__(self)
+
+        self._idle_draw_id  = 0
+        self._lastCursor    = None
+
+        self.connect('scroll_event',         self.scroll_event)
+        self.connect('button_press_event',   self.button_press_event)
+        self.connect('button_release_event', self.button_release_event)
+        self.connect('configure_event',      self.configure_event)
+        self.connect('draw',                 self.on_draw_event)
+        self.connect('key_press_event',      self.key_press_event)
+        self.connect('key_release_event',    self.key_release_event)
+        self.connect('motion_notify_event',  self.motion_notify_event)
+        self.connect('leave_notify_event',   self.leave_notify_event)
+        self.connect('enter_notify_event',   self.enter_notify_event)
+        self.connect('size_allocate',        self.size_allocate)
+
+        self.set_events(self.__class__.event_mask)
+
+        self.set_double_buffered(True)
+        self.set_can_focus(True)
+        self._renderer_init()
+        default_context = GLib.main_context_get_thread_default() or GLib.main_context_default()
+
+    def destroy(self):
+        #Gtk.DrawingArea.destroy(self)
+        self.close_event()
+        if self._idle_draw_id != 0:
+            GLib.source_remove(self._idle_draw_id)
+
+    def scroll_event(self, widget, event):
+        x = event.x
+        # flipy so y=0 is bottom of canvas
+        y = self.get_allocation().height - event.y
+        if event.direction==Gdk.ScrollDirection.UP:
+            step = 1
+        else:
+            step = -1
+        FigureCanvasBase.scroll_event(self, x, y, step, guiEvent=event)
+        return False  # finish event propagation?
+
+    def button_press_event(self, widget, event):
+        x = event.x
+        # flipy so y=0 is bottom of canvas
+        y = self.get_allocation().height - event.y
+        FigureCanvasBase.button_press_event(self, x, y, event.button, guiEvent=event)
+        return False  # finish event propagation?
+
+    def button_release_event(self, widget, event):
+        x = event.x
+        # flipy so y=0 is bottom of canvas
+        y = self.get_allocation().height - event.y
+        FigureCanvasBase.button_release_event(self, x, y, event.button, guiEvent=event)
+        return False  # finish event propagation?
+
+    def key_press_event(self, widget, event):
+        key = self._get_key(event)
+        FigureCanvasBase.key_press_event(self, key, guiEvent=event)
+        return True  # stop event propagation
+
+    def key_release_event(self, widget, event):
+        key = self._get_key(event)
+        FigureCanvasBase.key_release_event(self, key, guiEvent=event)
+        return True  # stop event propagation
+
+    def motion_notify_event(self, widget, event):
+        if event.is_hint:
+            t, x, y, state = event.window.get_pointer()
+        else:
+            x, y, state = event.x, event.y, event.get_state()
+
+        # flipy so y=0 is bottom of canvas
+        y = self.get_allocation().height - y
+        FigureCanvasBase.motion_notify_event(self, x, y, guiEvent=event)
+        return False  # finish event propagation?
+
+    def leave_notify_event(self, widget, event):
+        FigureCanvasBase.leave_notify_event(self, event)
+
+    def enter_notify_event(self, widget, event):
+        x = event.x
+        # flipy so y=0 is bottom of canvas
+        y = self.get_allocation().height - event.y
+        FigureCanvasBase.enter_notify_event(self, guiEvent=event, xy=(x, y))
+
+    def size_allocate(self, widget, allocation):
+        dpival = self.figure.dpi
+        winch = allocation.width / dpival
+        hinch = allocation.height / dpival
+        self.figure.set_size_inches(winch, hinch, forward=False)
+        FigureCanvasBase.resize_event(self)
+        self.draw_idle()
+
+    def _get_key(self, event):
+        if event.keyval in self.keyvald:
+            key = self.keyvald[event.keyval]
+        elif event.keyval < 256:
+            key = chr(event.keyval)
+        else:
+            key = None
+
+        modifiers = [
+                     (Gdk.ModifierType.MOD4_MASK, 'super'),
+                     (Gdk.ModifierType.MOD1_MASK, 'alt'),
+                     (Gdk.ModifierType.CONTROL_MASK, 'ctrl'),
+                    ]
+        for key_mask, prefix in modifiers:
+            if event.state & key_mask:
+                key = '{0}+{1}'.format(prefix, key)
+
+        return key
+
+    def configure_event(self, widget, event):
+        if widget.get_property("window") is None:
+            return
+        w, h = event.width, event.height
+        if w < 3 or h < 3:
+            return # empty fig
+        # resize the figure (in inches)
+        dpi = self.figure.dpi
+        self.figure.set_size_inches(w / dpi, h / dpi, forward=False)
+        return False  # finish event propagation?
+
+    def on_draw_event(self, widget, ctx):
+        # to be overwritten by GTK3Agg or GTK3Cairo
+        pass
+
+    def draw(self):
+        if self.get_visible() and self.get_mapped():
+            self.queue_draw()
+            # do a synchronous draw (its less efficient than an async draw,
+            # but is required if/when animation is used)
+            self.get_property("window").process_updates(False)
+
+    def draw_idle(self):
+        if self._idle_draw_id != 0:
+            return
+        def idle_draw(*args):
+            try:
+                self.draw()
+            finally:
+                self._idle_draw_id = 0
+            return False
+        self._idle_draw_id = GLib.idle_add(idle_draw)
+
+    def new_timer(self, *args, **kwargs):
+        """
+        Creates a new backend-specific subclass of :class:`backend_bases.Timer`.
+        This is useful for getting periodic events through the backend's native
+        event loop. Implemented only for backends with GUIs.
+
+        Other Parameters
+        ----------------
+        interval : scalar
+            Timer interval in milliseconds
+        callbacks : list
+            Sequence of (func, args, kwargs) where ``func(*args, **kwargs)``
+            will be executed by the timer every *interval*.
+        """
+        return TimerGTK3(*args, **kwargs)
+
+    def flush_events(self):
+        Gdk.threads_enter()
+        while Gtk.events_pending():
+            Gtk.main_iteration()
+        Gdk.flush()
+        Gdk.threads_leave()
+
+
+class FigureManagerGTK3(FigureManagerBase):
+    """
+    Attributes
+    ----------
+    canvas : `FigureCanvas`
+        The FigureCanvas instance
+    num : int or str
+        The Figure number
+    toolbar : Gtk.Toolbar
+        The Gtk.Toolbar
+    vbox : Gtk.VBox
+        The Gtk.VBox containing the canvas and toolbar
+    window : Gtk.Window
+        The Gtk.Window
+
+    """
+    def __init__(self, canvas, num):
+        FigureManagerBase.__init__(self, canvas, num)
+
+        self.window = Gtk.Window()
+        self.window.set_wmclass("matplotlib", "Matplotlib")
+        self.set_window_title("Figure %d" % num)
+        try:
+            self.window.set_icon_from_file(window_icon)
+        except Exception:
+            # Some versions of gtk throw a glib.GError but not all, so I am not
+            # sure how to catch it.  I am unhappy doing a blanket catch here,
+            # but am not sure what a better way is - JDH
+            _log.info('Could not load matplotlib icon: %s', sys.exc_info()[1])
+
+        self.vbox = Gtk.Box()
+        self.vbox.set_property("orientation", Gtk.Orientation.VERTICAL)
+        self.window.add(self.vbox)
+        self.vbox.show()
+
+        self.canvas.show()
+
+        self.vbox.pack_start(self.canvas, True, True, 0)
+        # calculate size for window
+        w = int(self.canvas.figure.bbox.width)
+        h = int(self.canvas.figure.bbox.height)
+
+        self.toolmanager = self._get_toolmanager()
+        self.toolbar = self._get_toolbar()
+        self.statusbar = None
+
+        def add_widget(child, expand, fill, padding):
+            child.show()
+            self.vbox.pack_end(child, False, False, 0)
+            size_request = child.size_request()
+            return size_request.height
+
+        if self.toolmanager:
+            backend_tools.add_tools_to_manager(self.toolmanager)
+            if self.toolbar:
+                backend_tools.add_tools_to_container(self.toolbar)
+                self.statusbar = StatusbarGTK3(self.toolmanager)
+                h += add_widget(self.statusbar, False, False, 0)
+                h += add_widget(Gtk.HSeparator(), False, False, 0)
+
+        if self.toolbar is not None:
+            self.toolbar.show()
+            h += add_widget(self.toolbar, False, False, 0)
+
+        self.window.set_default_size(w, h)
+
+        def destroy(*args):
+            Gcf.destroy(num)
+        self.window.connect("destroy", destroy)
+        self.window.connect("delete_event", destroy)
+        if matplotlib.is_interactive():
+            self.window.show()
+            self.canvas.draw_idle()
+
+        self.canvas.grab_focus()
+
+    def destroy(self, *args):
+        self.vbox.destroy()
+        self.window.destroy()
+        self.canvas.destroy()
+        if self.toolbar:
+            self.toolbar.destroy()
+
+        if (Gcf.get_num_fig_managers() == 0 and
+                not matplotlib.is_interactive() and
+                Gtk.main_level() >= 1):
+            Gtk.main_quit()
+
+    def show(self):
+        # show the figure window
+        self.window.show()
+        self.window.present()
+
+    def full_screen_toggle(self):
+        self._full_screen_flag = not self._full_screen_flag
+        if self._full_screen_flag:
+            self.window.fullscreen()
+        else:
+            self.window.unfullscreen()
+    _full_screen_flag = False
+
+    def _get_toolbar(self):
+        # must be inited after the window, drawingArea and figure
+        # attrs are set
+        if rcParams['toolbar'] == 'toolbar2':
+            toolbar = NavigationToolbar2GTK3(self.canvas, self.window)
+        elif rcParams['toolbar'] == 'toolmanager':
+            toolbar = ToolbarGTK3(self.toolmanager)
+        else:
+            toolbar = None
+        return toolbar
+
+    def _get_toolmanager(self):
+        # must be initialised after toolbar has been set
+        if rcParams['toolbar'] == 'toolmanager':
+            toolmanager = ToolManager(self.canvas.figure)
+        else:
+            toolmanager = None
+        return toolmanager
+
+    def get_window_title(self):
+        return self.window.get_title()
+
+    def set_window_title(self, title):
+        self.window.set_title(title)
+
+    def resize(self, width, height):
+        'set the canvas size in pixels'
+        #_, _, cw, ch = self.canvas.allocation
+        #_, _, ww, wh = self.window.allocation
+        #self.window.resize (width-cw+ww, height-ch+wh)
+        self.window.resize(width, height)
+
+
+class NavigationToolbar2GTK3(NavigationToolbar2, Gtk.Toolbar):
+    def __init__(self, canvas, window):
+        self.win = window
+        GObject.GObject.__init__(self)
+        NavigationToolbar2.__init__(self, canvas)
+        self.ctx = None
+
+    def set_message(self, s):
+        self.message.set_label(s)
+
+    def set_cursor(self, cursor):
+        self.canvas.get_property("window").set_cursor(cursord[cursor])
+        Gtk.main_iteration()
+
+    def draw_rubberband(self, event, x0, y0, x1, y1):
+        'adapted from http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/189744'
+        self.ctx = self.canvas.get_property("window").cairo_create()
+
+        # todo: instead of redrawing the entire figure, copy the part of
+        # the figure that was covered by the previous rubberband rectangle
+        self.canvas.draw()
+
+        height = self.canvas.figure.bbox.height
+        y1 = height - y1
+        y0 = height - y0
+        w = abs(x1 - x0)
+        h = abs(y1 - y0)
+        rect = [int(val) for val in (min(x0, x1), min(y0, y1), w, h)]
+
+        self.ctx.new_path()
+        self.ctx.set_line_width(0.5)
+        self.ctx.rectangle(rect[0], rect[1], rect[2], rect[3])
+        self.ctx.set_source_rgb(0, 0, 0)
+        self.ctx.stroke()
+
+    def _init_toolbar(self):
+        self.set_style(Gtk.ToolbarStyle.ICONS)
+        basedir = os.path.join(rcParams['datapath'], 'images')
+
+        for text, tooltip_text, image_file, callback in self.toolitems:
+            if text is None:
+                self.insert(Gtk.SeparatorToolItem(), -1)
+                continue
+            fname = os.path.join(basedir, image_file + '.png')
+            image = Gtk.Image()
+            image.set_from_file(fname)
+            tbutton = Gtk.ToolButton()
+            tbutton.set_label(text)
+            tbutton.set_icon_widget(image)
+            self.insert(tbutton, -1)
+            tbutton.connect('clicked', getattr(self, callback))
+            tbutton.set_tooltip_text(tooltip_text)
+
+        toolitem = Gtk.SeparatorToolItem()
+        self.insert(toolitem, -1)
+        toolitem.set_draw(False)
+        toolitem.set_expand(True)
+
+        toolitem = Gtk.ToolItem()
+        self.insert(toolitem, -1)
+        self.message = Gtk.Label()
+        toolitem.add(self.message)
+
+        self.show_all()
+
+    def get_filechooser(self):
+        fc = FileChooserDialog(
+            title='Save the figure',
+            parent=self.win,
+            path=os.path.expanduser(rcParams['savefig.directory']),
+            filetypes=self.canvas.get_supported_filetypes(),
+            default_filetype=self.canvas.get_default_filetype())
+        fc.set_current_name(self.canvas.get_default_filename())
+        return fc
+
+    def save_figure(self, *args):
+        chooser = self.get_filechooser()
+        fname, format = chooser.get_filename_from_user()
+        chooser.destroy()
+        if fname:
+            startpath = os.path.expanduser(rcParams['savefig.directory'])
+            # Save dir for next time, unless empty str (i.e., use cwd).
+            if startpath != "":
+                rcParams['savefig.directory'] = os.path.dirname(fname)
+            try:
+                self.canvas.figure.savefig(fname, format=format)
+            except Exception as e:
+                error_msg_gtk(str(e), parent=self)
+
+    def configure_subplots(self, button):
+        toolfig = Figure(figsize=(6, 3))
+        canvas = self._get_canvas(toolfig)
+        toolfig.subplots_adjust(top=0.9)
+        tool =  SubplotTool(self.canvas.figure, toolfig)
+
+        w = int(toolfig.bbox.width)
+        h = int(toolfig.bbox.height)
+
+        window = Gtk.Window()
+        try:
+            window.set_icon_from_file(window_icon)
+        except Exception:
+            # we presumably already logged a message on the
+            # failure of the main plot, don't keep reporting
+            pass
+        window.set_title("Subplot Configuration Tool")
+        window.set_default_size(w, h)
+        vbox = Gtk.Box()
+        vbox.set_property("orientation", Gtk.Orientation.VERTICAL)
+        window.add(vbox)
+        vbox.show()
+
+        canvas.show()
+        vbox.pack_start(canvas, True, True, 0)
+        window.show()
+
+    def _get_canvas(self, fig):
+        return self.canvas.__class__(fig)
+
+
+class FileChooserDialog(Gtk.FileChooserDialog):
+    """GTK+ file selector which remembers the last file/directory
+    selected and presents the user with a menu of supported image formats
+    """
+    def __init__(self,
+                 title   = 'Save file',
+                 parent  = None,
+                 action  = Gtk.FileChooserAction.SAVE,
+                 buttons = (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
+                            Gtk.STOCK_SAVE,   Gtk.ResponseType.OK),
+                 path    = None,
+                 filetypes = [],
+                 default_filetype = None
+                ):
+        super().__init__(title, parent, action, buttons)
+        self.set_default_response(Gtk.ResponseType.OK)
+        self.set_do_overwrite_confirmation(True)
+
+        if not path:
+            path = os.getcwd()
+
+        # create an extra widget to list supported image formats
+        self.set_current_folder(path)
+        self.set_current_name('image.' + default_filetype)
+
+        hbox = Gtk.Box(spacing=10)
+        hbox.pack_start(Gtk.Label(label="File Format:"), False, False, 0)
+
+        liststore = Gtk.ListStore(GObject.TYPE_STRING)
+        cbox = Gtk.ComboBox()
+        cbox.set_model(liststore)
+        cell = Gtk.CellRendererText()
+        cbox.pack_start(cell, True)
+        cbox.add_attribute(cell, 'text', 0)
+        hbox.pack_start(cbox, False, False, 0)
+
+        self.filetypes = filetypes
+        sorted_filetypes = sorted(filetypes.items())
+        default = 0
+        for i, (ext, name) in enumerate(sorted_filetypes):
+            liststore.append(["%s (*.%s)" % (name, ext)])
+            if ext == default_filetype:
+                default = i
+        cbox.set_active(default)
+        self.ext = default_filetype
+
+        def cb_cbox_changed(cbox, data=None):
+            """File extension changed"""
+            head, filename = os.path.split(self.get_filename())
+            root, ext = os.path.splitext(filename)
+            ext = ext[1:]
+            new_ext = sorted_filetypes[cbox.get_active()][0]
+            self.ext = new_ext
+
+            if ext in self.filetypes:
+                filename = root + '.' + new_ext
+            elif ext == '':
+                filename = filename.rstrip('.') + '.' + new_ext
+
+            self.set_current_name(filename)
+        cbox.connect("changed", cb_cbox_changed)
+
+        hbox.show_all()
+        self.set_extra_widget(hbox)
+
+    @cbook.deprecated("3.0", alternative="sorted(self.filetypes.items())")
+    def sorted_filetypes(self):
+        return sorted(self.filetypes.items())
+
+    def get_filename_from_user(self):
+        if self.run() == int(Gtk.ResponseType.OK):
+            return self.get_filename(), self.ext
+        else:
+            return None, self.ext
+
+
+class RubberbandGTK3(backend_tools.RubberbandBase):
+    def __init__(self, *args, **kwargs):
+        backend_tools.RubberbandBase.__init__(self, *args, **kwargs)
+        self.ctx = None
+
+    def draw_rubberband(self, x0, y0, x1, y1):
+        # 'adapted from http://aspn.activestate.com/ASPN/Cookbook/Python/
+        # Recipe/189744'
+        self.ctx = self.figure.canvas.get_property("window").cairo_create()
+
+        # todo: instead of redrawing the entire figure, copy the part of
+        # the figure that was covered by the previous rubberband rectangle
+        self.figure.canvas.draw()
+
+        height = self.figure.bbox.height
+        y1 = height - y1
+        y0 = height - y0
+        w = abs(x1 - x0)
+        h = abs(y1 - y0)
+        rect = [int(val) for val in (min(x0, x1), min(y0, y1), w, h)]
+
+        self.ctx.new_path()
+        self.ctx.set_line_width(0.5)
+        self.ctx.rectangle(rect[0], rect[1], rect[2], rect[3])
+        self.ctx.set_source_rgb(0, 0, 0)
+        self.ctx.stroke()
+
+
+class ToolbarGTK3(ToolContainerBase, Gtk.Box):
+    _icon_extension = '.png'
+
+    def __init__(self, toolmanager):
+        ToolContainerBase.__init__(self, toolmanager)
+        Gtk.Box.__init__(self)
+        self.set_property("orientation", Gtk.Orientation.VERTICAL)
+
+        self._toolarea = Gtk.Box()
+        self._toolarea.set_property('orientation', Gtk.Orientation.HORIZONTAL)
+        self.pack_start(self._toolarea, False, False, 0)
+        self._toolarea.show_all()
+        self._groups = {}
+        self._toolitems = {}
+
+    def add_toolitem(self, name, group, position, image_file, description,
+                     toggle):
+        if toggle:
+            tbutton = Gtk.ToggleToolButton()
+        else:
+            tbutton = Gtk.ToolButton()
+        tbutton.set_label(name)
+
+        if image_file is not None:
+            image = Gtk.Image()
+            image.set_from_file(image_file)
+            tbutton.set_icon_widget(image)
+
+        if position is None:
+            position = -1
+
+        self._add_button(tbutton, group, position)
+        signal = tbutton.connect('clicked', self._call_tool, name)
+        tbutton.set_tooltip_text(description)
+        tbutton.show_all()
+        self._toolitems.setdefault(name, [])
+        self._toolitems[name].append((tbutton, signal))
+
+    def _add_button(self, button, group, position):
+        if group not in self._groups:
+            if self._groups:
+                self._add_separator()
+            toolbar = Gtk.Toolbar()
+            toolbar.set_style(Gtk.ToolbarStyle.ICONS)
+            self._toolarea.pack_start(toolbar, False, False, 0)
+            toolbar.show_all()
+            self._groups[group] = toolbar
+        self._groups[group].insert(button, position)
+
+    def _call_tool(self, btn, name):
+        self.trigger_tool(name)
+
+    def toggle_toolitem(self, name, toggled):
+        if name not in self._toolitems:
+            return
+        for toolitem, signal in self._toolitems[name]:
+            toolitem.handler_block(signal)
+            toolitem.set_active(toggled)
+            toolitem.handler_unblock(signal)
+
+    def remove_toolitem(self, name):
+        if name not in self._toolitems:
+            self.toolmanager.message_event('%s Not in toolbar' % name, self)
+            return
+
+        for group in self._groups:
+            for toolitem, _signal in self._toolitems[name]:
+                if toolitem in self._groups[group]:
+                    self._groups[group].remove(toolitem)
+        del self._toolitems[name]
+
+    def _add_separator(self):
+        sep = Gtk.Separator()
+        sep.set_property("orientation", Gtk.Orientation.VERTICAL)
+        self._toolarea.pack_start(sep, False, True, 0)
+        sep.show_all()
+
+
+class StatusbarGTK3(StatusbarBase, Gtk.Statusbar):
+    def __init__(self, *args, **kwargs):
+        StatusbarBase.__init__(self, *args, **kwargs)
+        Gtk.Statusbar.__init__(self)
+        self._context = self.get_context_id('message')
+
+    def set_message(self, s):
+        self.pop(self._context)
+        self.push(self._context, s)
+
+
+class SaveFigureGTK3(backend_tools.SaveFigureBase):
+
+    def get_filechooser(self):
+        fc = FileChooserDialog(
+            title='Save the figure',
+            parent=self.figure.canvas.manager.window,
+            path=os.path.expanduser(rcParams['savefig.directory']),
+            filetypes=self.figure.canvas.get_supported_filetypes(),
+            default_filetype=self.figure.canvas.get_default_filetype())
+        fc.set_current_name(self.figure.canvas.get_default_filename())
+        return fc
+
+    def trigger(self, *args, **kwargs):
+        chooser = self.get_filechooser()
+        fname, format_ = chooser.get_filename_from_user()
+        chooser.destroy()
+        if fname:
+            startpath = os.path.expanduser(rcParams['savefig.directory'])
+            if startpath == '':
+                # explicitly missing key or empty str signals to use cwd
+                rcParams['savefig.directory'] = startpath
+            else:
+                # save dir for next time
+                rcParams['savefig.directory'] = os.path.dirname(fname)
+            try:
+                self.figure.canvas.print_figure(fname, format=format_)
+            except Exception as e:
+                error_msg_gtk(str(e), parent=self)
+
+
+class SetCursorGTK3(backend_tools.SetCursorBase):
+    def set_cursor(self, cursor):
+        self.figure.canvas.get_property("window").set_cursor(cursord[cursor])
+
+
+class ConfigureSubplotsGTK3(backend_tools.ConfigureSubplotsBase, Gtk.Window):
+    def __init__(self, *args, **kwargs):
+        backend_tools.ConfigureSubplotsBase.__init__(self, *args, **kwargs)
+        self.window = None
+
+    def init_window(self):
+        if self.window:
+            return
+        self.window = Gtk.Window(title="Subplot Configuration Tool")
+
+        try:
+            self.window.window.set_icon_from_file(window_icon)
+        except Exception:
+            # we presumably already logged a message on the
+            # failure of the main plot, don't keep reporting
+            pass
+
+        self.vbox = Gtk.Box()
+        self.vbox.set_property("orientation", Gtk.Orientation.VERTICAL)
+        self.window.add(self.vbox)
+        self.vbox.show()
+        self.window.connect('destroy', self.destroy)
+
+        toolfig = Figure(figsize=(6, 3))
+        canvas = self.figure.canvas.__class__(toolfig)
+
+        toolfig.subplots_adjust(top=0.9)
+        SubplotTool(self.figure, toolfig)
+
+        w = int(toolfig.bbox.width)
+        h = int(toolfig.bbox.height)
+
+        self.window.set_default_size(w, h)
+
+        canvas.show()
+        self.vbox.pack_start(canvas, True, True, 0)
+        self.window.show()
+
+    def destroy(self, *args):
+        self.window.destroy()
+        self.window = None
+
+    def _get_canvas(self, fig):
+        return self.canvas.__class__(fig)
+
+    def trigger(self, sender, event, data=None):
+        self.init_window()
+        self.window.present()
+
+
+class HelpGTK3(backend_tools.ToolHelpBase):
+    def _normalize_shortcut(self, key):
+        """
+        Convert Matplotlib key presses to GTK+ accelerator identifiers.
+
+        Related to `FigureCanvasGTK3._get_key`.
+        """
+        special = {
+            'backspace': 'BackSpace',
+            'pagedown': 'Page_Down',
+            'pageup': 'Page_Up',
+            'scroll_lock': 'Scroll_Lock',
+        }
+
+        parts = key.split('+')
+        mods = ['<' + mod + '>' for mod in parts[:-1]]
+        key = parts[-1]
+
+        if key in special:
+            key = special[key]
+        elif len(key) > 1:
+            key = key.capitalize()
+        elif key.isupper():
+            mods += ['<shift>']
+
+        return ''.join(mods) + key
+
+    def _show_shortcuts_window(self):
+        section = Gtk.ShortcutsSection()
+
+        for name, tool in sorted(self.toolmanager.tools.items()):
+            if not tool.description:
+                continue
+
+            # Putting everything in a separate group allows GTK to
+            # automatically split them into separate columns/pages, which is
+            # useful because we have lots of shortcuts, some with many keys
+            # that are very wide.
+            group = Gtk.ShortcutsGroup()
+            section.add(group)
+            # A hack to remove the title since we have no group naming.
+            group.forall(lambda widget, data: widget.set_visible(False), None)
+
+            shortcut = Gtk.ShortcutsShortcut(
+                accelerator=' '.join(
+                    self._normalize_shortcut(key)
+                    for key in self.toolmanager.get_tool_keymap(name)
+                    # Will never be sent:
+                    if 'cmd+' not in key),
+                title=tool.name,
+                subtitle=tool.description)
+            group.add(shortcut)
+
+        window = Gtk.ShortcutsWindow(
+            title='Help',
+            modal=True,
+            transient_for=self._figure.canvas.get_toplevel())
+        section.show()  # Must be done explicitly before add!
+        window.add(section)
+
+        window.show_all()
+
+    def _show_shortcuts_dialog(self):
+        dialog = Gtk.MessageDialog(
+            self._figure.canvas.get_toplevel(),
+            0, Gtk.MessageType.INFO, Gtk.ButtonsType.OK, self._get_help_text(),
+            title="Help")
+        dialog.run()
+        dialog.destroy()
+
+    def trigger(self, *args):
+        if Gtk.check_version(3, 20, 0) is None:
+            self._show_shortcuts_window()
+        else:
+            self._show_shortcuts_dialog()
+
+
+class ToolCopyToClipboardGTK3(backend_tools.ToolCopyToClipboardBase):
+    def trigger(self, *args, **kwargs):
+        clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
+        window = self.canvas.get_window()
+        x, y, width, height = window.get_geometry()
+        pb = Gdk.pixbuf_get_from_window(window, x, y, width, height)
+        clipboard.set_image(pb)
+
+
+# Define the file to use as the GTk icon
+if sys.platform == 'win32':
+    icon_filename = 'matplotlib.png'
+else:
+    icon_filename = 'matplotlib.svg'
+window_icon = os.path.join(
+    matplotlib.rcParams['datapath'], 'images', icon_filename)
+
+
+def error_msg_gtk(msg, parent=None):
+    if parent is not None: # find the toplevel Gtk.Window
+        parent = parent.get_toplevel()
+        if not parent.is_toplevel():
+            parent = None
+
+    if not isinstance(msg, str):
+        msg = ','.join(map(str, msg))
+
+    dialog = Gtk.MessageDialog(
+        parent         = parent,
+        type           = Gtk.MessageType.ERROR,
+        buttons        = Gtk.ButtonsType.OK,
+        message_format = msg)
+    dialog.run()
+    dialog.destroy()
+
+
+backend_tools.ToolSaveFigure = SaveFigureGTK3
+backend_tools.ToolConfigureSubplots = ConfigureSubplotsGTK3
+backend_tools.ToolSetCursor = SetCursorGTK3
+backend_tools.ToolRubberband = RubberbandGTK3
+backend_tools.ToolHelp = HelpGTK3
+backend_tools.ToolCopyToClipboard = ToolCopyToClipboardGTK3
+
+Toolbar = ToolbarGTK3
+
+
+@_Backend.export
+class _BackendGTK3(_Backend):
+    required_interactive_framework = "gtk3"
+    FigureCanvas = FigureCanvasGTK3
+    FigureManager = FigureManagerGTK3
+
+    @staticmethod
+    def trigger_manager_draw(manager):
+        manager.canvas.draw_idle()
+
+    @staticmethod
+    def mainloop():
+        if Gtk.main_level() == 0:
+            Gtk.main()

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_gtk3agg.py

@@ -0,0 +1,90 @@
+import sys
+
+import numpy as np
+
+from .. import cbook
+from . import backend_agg, backend_cairo, backend_gtk3
+from ._gtk3_compat import gi
+from .backend_cairo import cairo
+from .backend_gtk3 import Gtk, _BackendGTK3
+from matplotlib import transforms
+
+
+class FigureCanvasGTK3Agg(backend_gtk3.FigureCanvasGTK3,
+                          backend_agg.FigureCanvasAgg):
+    def __init__(self, figure):
+        backend_gtk3.FigureCanvasGTK3.__init__(self, figure)
+        self._bbox_queue = []
+
+    def _renderer_init(self):
+        pass
+
+    def _render_figure(self, width, height):
+        backend_agg.FigureCanvasAgg.draw(self)
+
+    def on_draw_event(self, widget, ctx):
+        """GtkDrawable draw event, like expose_event in GTK 2.X.
+        """
+        allocation = self.get_allocation()
+        w, h = allocation.width, allocation.height
+
+        if not len(self._bbox_queue):
+            self._render_figure(w, h)
+            Gtk.render_background(
+                self.get_style_context(), ctx,
+                allocation.x, allocation.y,
+                allocation.width, allocation.height)
+            bbox_queue = [transforms.Bbox([[0, 0], [w, h]])]
+        else:
+            bbox_queue = self._bbox_queue
+
+        ctx = backend_cairo._to_context(ctx)
+
+        for bbox in bbox_queue:
+            x = int(bbox.x0)
+            y = h - int(bbox.y1)
+            width = int(bbox.x1) - int(bbox.x0)
+            height = int(bbox.y1) - int(bbox.y0)
+
+            buf = cbook._unmultiplied_rgba8888_to_premultiplied_argb32(
+                np.asarray(self.copy_from_bbox(bbox)))
+            image = cairo.ImageSurface.create_for_data(
+                buf.ravel().data, cairo.FORMAT_ARGB32, width, height)
+            ctx.set_source_surface(image, x, y)
+            ctx.paint()
+
+        if len(self._bbox_queue):
+            self._bbox_queue = []
+
+        return False
+
+    def blit(self, bbox=None):
+        # If bbox is None, blit the entire canvas to gtk. Otherwise
+        # blit only the area defined by the bbox.
+        if bbox is None:
+            bbox = self.figure.bbox
+
+        allocation = self.get_allocation()
+        w, h = allocation.width, allocation.height
+        x = int(bbox.x0)
+        y = h - int(bbox.y1)
+        width = int(bbox.x1) - int(bbox.x0)
+        height = int(bbox.y1) - int(bbox.y0)
+
+        self._bbox_queue.append(bbox)
+        self.queue_draw_area(x, y, width, height)
+
+    def print_png(self, filename, *args, **kwargs):
+        # Do this so we can save the resolution of figure in the PNG file
+        agg = self.switch_backends(backend_agg.FigureCanvasAgg)
+        return agg.print_png(filename, *args, **kwargs)
+
+
+class FigureManagerGTK3Agg(backend_gtk3.FigureManagerGTK3):
+    pass
+
+
+@_BackendGTK3.export
+class _BackendGTK3Cairo(_BackendGTK3):
+    FigureCanvas = FigureCanvasGTK3Agg
+    FigureManager = FigureManagerGTK3Agg

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_gtk3cairo.py

@@ -0,0 +1,46 @@
+from . import backend_cairo, backend_gtk3
+from ._gtk3_compat import gi
+from .backend_gtk3 import Gtk, _BackendGTK3
+from matplotlib.backend_bases import cursors
+
+
+class RendererGTK3Cairo(backend_cairo.RendererCairo):
+    def set_context(self, ctx):
+        self.gc.ctx = backend_cairo._to_context(ctx)
+
+
+class FigureCanvasGTK3Cairo(backend_gtk3.FigureCanvasGTK3,
+                            backend_cairo.FigureCanvasCairo):
+
+    def _renderer_init(self):
+        """Use cairo renderer."""
+        self._renderer = RendererGTK3Cairo(self.figure.dpi)
+
+    def _render_figure(self, width, height):
+        self._renderer.set_width_height(width, height)
+        self.figure.draw(self._renderer)
+
+    def on_draw_event(self, widget, ctx):
+        """GtkDrawable draw event."""
+        toolbar = self.toolbar
+        # if toolbar:
+        #     toolbar.set_cursor(cursors.WAIT)
+        self._renderer.set_context(ctx)
+        allocation = self.get_allocation()
+        Gtk.render_background(
+            self.get_style_context(), ctx,
+            allocation.x, allocation.y, allocation.width, allocation.height)
+        self._render_figure(allocation.width, allocation.height)
+        # if toolbar:
+        #     toolbar.set_cursor(toolbar._lastCursor)
+        return False  # finish event propagation?
+
+
+class FigureManagerGTK3Cairo(backend_gtk3.FigureManagerGTK3):
+    pass
+
+
+@_BackendGTK3.export
+class _BackendGTK3Cairo(_BackendGTK3):
+    FigureCanvas = FigureCanvasGTK3Cairo
+    FigureManager = FigureManagerGTK3Cairo

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_macosx.py

@@ -0,0 +1,203 @@
+import os
+
+from matplotlib._pylab_helpers import Gcf
+from matplotlib.backend_bases import (
+    _Backend, FigureCanvasBase, FigureManagerBase, NavigationToolbar2,
+    TimerBase)
+
+from matplotlib.figure import Figure
+from matplotlib import rcParams
+
+from matplotlib.widgets import SubplotTool
+
+import matplotlib
+from matplotlib.backends import _macosx
+
+from .backend_agg import FigureCanvasAgg
+
+
+########################################################################
+#
+# The following functions and classes are for pylab and implement
+# window/figure managers, etc...
+#
+########################################################################
+
+
+class TimerMac(_macosx.Timer, TimerBase):
+    '''
+    Subclass of :class:`backend_bases.TimerBase` that uses CoreFoundation
+    run loops for timer events.
+
+    Attributes
+    ----------
+    interval : int
+        The time between timer events in milliseconds. Default is 1000 ms.
+    single_shot : bool
+        Boolean flag indicating whether this timer should operate as single
+        shot (run once and then stop). Defaults to False.
+    callbacks : list
+        Stores list of (func, args) tuples that will be called upon timer
+        events. This list can be manipulated directly, or the functions
+        `add_callback` and `remove_callback` can be used.
+
+    '''
+    # completely implemented at the C-level (in _macosx.Timer)
+
+
+class FigureCanvasMac(_macosx.FigureCanvas, FigureCanvasAgg):
+    """
+    The canvas the figure renders into.  Calls the draw and print fig
+    methods, creates the renderers, etc...
+
+    Events such as button presses, mouse movements, and key presses
+    are handled in the C code and the base class methods
+    button_press_event, button_release_event, motion_notify_event,
+    key_press_event, and key_release_event are called from there.
+
+    Attributes
+    ----------
+    figure : `matplotlib.figure.Figure`
+        A high-level Figure instance
+
+    """
+
+    def __init__(self, figure):
+        FigureCanvasBase.__init__(self, figure)
+        width, height = self.get_width_height()
+        _macosx.FigureCanvas.__init__(self, width, height)
+        self._device_scale = 1.0
+
+    def _set_device_scale(self, value):
+        if self._device_scale != value:
+            self.figure.dpi = self.figure.dpi / self._device_scale * value
+            self._device_scale = value
+
+    def _draw(self):
+        renderer = self.get_renderer(cleared=self.figure.stale)
+
+        if self.figure.stale:
+            self.figure.draw(renderer)
+
+        return renderer
+
+    def draw(self):
+        self.invalidate()
+        self.flush_events()
+
+    def draw_idle(self, *args, **kwargs):
+        self.invalidate()
+
+    def blit(self, bbox=None):
+        self.invalidate()
+
+    def resize(self, width, height):
+        dpi = self.figure.dpi
+        width /= dpi
+        height /= dpi
+        self.figure.set_size_inches(width * self._device_scale,
+                                    height * self._device_scale,
+                                    forward=False)
+        FigureCanvasBase.resize_event(self)
+        self.draw_idle()
+
+    def new_timer(self, *args, **kwargs):
+        """
+        Creates a new backend-specific subclass of `backend_bases.Timer`.
+        This is useful for getting periodic events through the backend's native
+        event loop. Implemented only for backends with GUIs.
+
+        Other Parameters
+        ----------------
+        interval : scalar
+            Timer interval in milliseconds
+        callbacks : list
+            Sequence of (func, args, kwargs) where ``func(*args, **kwargs)``
+            will be executed by the timer every *interval*.
+        """
+        return TimerMac(*args, **kwargs)
+
+
+class FigureManagerMac(_macosx.FigureManager, FigureManagerBase):
+    """
+    Wrap everything up into a window for the pylab interface
+    """
+    def __init__(self, canvas, num):
+        FigureManagerBase.__init__(self, canvas, num)
+        title = "Figure %d" % num
+        _macosx.FigureManager.__init__(self, canvas, title)
+        if rcParams['toolbar'] == 'toolbar2':
+            self.toolbar = NavigationToolbar2Mac(canvas)
+        else:
+            self.toolbar = None
+        if self.toolbar is not None:
+            self.toolbar.update()
+
+        if matplotlib.is_interactive():
+            self.show()
+            self.canvas.draw_idle()
+
+    def close(self):
+        Gcf.destroy(self.num)
+
+
+class NavigationToolbar2Mac(_macosx.NavigationToolbar2, NavigationToolbar2):
+
+    def __init__(self, canvas):
+        NavigationToolbar2.__init__(self, canvas)
+
+    def _init_toolbar(self):
+        basedir = os.path.join(rcParams['datapath'], "images")
+        _macosx.NavigationToolbar2.__init__(self, basedir)
+
+    def draw_rubberband(self, event, x0, y0, x1, y1):
+        self.canvas.set_rubberband(int(x0), int(y0), int(x1), int(y1))
+
+    def release(self, event):
+        self.canvas.remove_rubberband()
+
+    def set_cursor(self, cursor):
+        _macosx.set_cursor(cursor)
+
+    def save_figure(self, *args):
+        filename = _macosx.choose_save_file('Save the figure',
+                                            self.canvas.get_default_filename())
+        if filename is None: # Cancel
+            return
+        self.canvas.figure.savefig(filename)
+
+    def prepare_configure_subplots(self):
+        toolfig = Figure(figsize=(6,3))
+        canvas = FigureCanvasMac(toolfig)
+        toolfig.subplots_adjust(top=0.9)
+        tool = SubplotTool(self.canvas.figure, toolfig)
+        return canvas
+
+    def set_message(self, message):
+        _macosx.NavigationToolbar2.set_message(self, message.encode('utf-8'))
+
+
+########################################################################
+#
+# Now just provide the standard names that backend.__init__ is expecting
+#
+########################################################################
+
+@_Backend.export
+class _BackendMac(_Backend):
+    required_interactive_framework = "macosx"
+    FigureCanvas = FigureCanvasMac
+    FigureManager = FigureManagerMac
+
+    @staticmethod
+    def trigger_manager_draw(manager):
+        # For performance reasons, we don't want to redraw the figure after
+        # each draw command. Instead, we mark the figure as invalid, so that it
+        # will be redrawn as soon as the event loop resumes via PyOS_InputHook.
+        # This function should be called after each draw event, even if
+        # matplotlib is not running interactively.
+        manager.canvas.invalidate()
+
+    @staticmethod
+    def mainloop():
+        _macosx.show()

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_mixed.py

@@ -0,0 +1,150 @@
+import numpy as np
+
+from matplotlib.backends.backend_agg import RendererAgg
+from matplotlib.tight_bbox import process_figure_for_rasterizing
+
+
+class MixedModeRenderer(object):
+    """
+    A helper class to implement a renderer that switches between
+    vector and raster drawing.  An example may be a PDF writer, where
+    most things are drawn with PDF vector commands, but some very
+    complex objects, such as quad meshes, are rasterised and then
+    output as images.
+    """
+    def __init__(self, figure, width, height, dpi, vector_renderer,
+                 raster_renderer_class=None,
+                 bbox_inches_restore=None):
+        """
+        Parameters
+        ----------
+        figure : `matplotlib.figure.Figure`
+            The figure instance.
+
+        width : scalar
+            The width of the canvas in logical units
+
+        height : scalar
+            The height of the canvas in logical units
+
+        dpi : scalar
+            The dpi of the canvas
+
+        vector_renderer : `matplotlib.backend_bases.RendererBase`
+            An instance of a subclass of
+            `~matplotlib.backend_bases.RendererBase` that will be used for the
+            vector drawing.
+
+        raster_renderer_class : `matplotlib.backend_bases.RendererBase`
+            The renderer class to use for the raster drawing.  If not provided,
+            this will use the Agg backend (which is currently the only viable
+            option anyway.)
+
+        """
+        if raster_renderer_class is None:
+            raster_renderer_class = RendererAgg
+
+        self._raster_renderer_class = raster_renderer_class
+        self._width = width
+        self._height = height
+        self.dpi = dpi
+
+        self._vector_renderer = vector_renderer
+
+        self._raster_renderer = None
+        self._rasterizing = 0
+
+        # A reference to the figure is needed as we need to change
+        # the figure dpi before and after the rasterization. Although
+        # this looks ugly, I couldn't find a better solution. -JJL
+        self.figure = figure
+        self._figdpi = figure.get_dpi()
+
+        self._bbox_inches_restore = bbox_inches_restore
+
+        self._set_current_renderer(vector_renderer)
+
+    _methods = """
+        close_group draw_image draw_markers draw_path
+        draw_path_collection draw_quad_mesh draw_tex draw_text
+        finalize flipy get_canvas_width_height get_image_magnification
+        get_texmanager get_text_width_height_descent new_gc open_group
+        option_image_nocomposite points_to_pixels strip_math
+        start_filter stop_filter draw_gouraud_triangle
+        draw_gouraud_triangles option_scale_image
+        _text2path _get_text_path_transform height width
+        """.split()
+
+    def _set_current_renderer(self, renderer):
+        self._renderer = renderer
+
+        for method in self._methods:
+            if hasattr(renderer, method):
+                setattr(self, method, getattr(renderer, method))
+        renderer.start_rasterizing = self.start_rasterizing
+        renderer.stop_rasterizing = self.stop_rasterizing
+
+    def start_rasterizing(self):
+        """
+        Enter "raster" mode.  All subsequent drawing commands (until
+        stop_rasterizing is called) will be drawn with the raster
+        backend.
+
+        If start_rasterizing is called multiple times before
+        stop_rasterizing is called, this method has no effect.
+        """
+
+        # change the dpi of the figure temporarily.
+        self.figure.set_dpi(self.dpi)
+
+        if self._bbox_inches_restore:  # when tight bbox is used
+            r = process_figure_for_rasterizing(self.figure,
+                                               self._bbox_inches_restore)
+            self._bbox_inches_restore = r
+
+        if self._rasterizing == 0:
+            self._raster_renderer = self._raster_renderer_class(
+                self._width*self.dpi, self._height*self.dpi, self.dpi)
+            self._set_current_renderer(self._raster_renderer)
+        self._rasterizing += 1
+
+    def stop_rasterizing(self):
+        """
+        Exit "raster" mode.  All of the drawing that was done since
+        the last start_rasterizing command will be copied to the
+        vector backend by calling draw_image.
+
+        If stop_rasterizing is called multiple times before
+        start_rasterizing is called, this method has no effect.
+        """
+        self._rasterizing -= 1
+        if self._rasterizing == 0:
+            self._set_current_renderer(self._vector_renderer)
+
+            height = self._height * self.dpi
+            buffer, bounds = self._raster_renderer.tostring_rgba_minimized()
+            l, b, w, h = bounds
+            if w > 0 and h > 0:
+                image = np.frombuffer(buffer, dtype=np.uint8)
+                image = image.reshape((h, w, 4))
+                image = image[::-1]
+                gc = self._renderer.new_gc()
+                # TODO: If the mixedmode resolution differs from the figure's
+                #       dpi, the image must be scaled (dpi->_figdpi). Not all
+                #       backends support this.
+                self._renderer.draw_image(
+                    gc,
+                    l * self._figdpi / self.dpi,
+                    (height-b-h) * self._figdpi / self.dpi,
+                    image)
+            self._raster_renderer = None
+            self._rasterizing = False
+
+            # restore the figure dpi.
+            self.figure.set_dpi(self._figdpi)
+
+        if self._bbox_inches_restore:  # when tight bbox is used
+            r = process_figure_for_rasterizing(self.figure,
+                                               self._bbox_inches_restore,
+                                               self._figdpi)
+            self._bbox_inches_restore = r

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_nbagg.py

@@ -0,0 +1,265 @@
+"""Interactive figures in the IPython notebook"""
+# Note: There is a notebook in
+# lib/matplotlib/backends/web_backend/nbagg_uat.ipynb to help verify
+# that changes made maintain expected behaviour.
+
+from base64 import b64encode
+import io
+import json
+import os
+import pathlib
+import uuid
+
+from IPython.display import display, Javascript, HTML
+try:
+    # Jupyter/IPython 4.x or later
+    from ipykernel.comm import Comm
+except ImportError:
+    # Jupyter/IPython 3.x or earlier
+    from IPython.kernel.comm import Comm
+
+from matplotlib import rcParams, is_interactive
+from matplotlib._pylab_helpers import Gcf
+from matplotlib.backend_bases import (
+    _Backend, FigureCanvasBase, NavigationToolbar2)
+from matplotlib.backends.backend_webagg_core import (
+    FigureCanvasWebAggCore, FigureManagerWebAgg, NavigationToolbar2WebAgg,
+    TimerTornado)
+
+
+def connection_info():
+    """
+    Return a string showing the figure and connection status for
+    the backend. This is intended as a diagnostic tool, and not for general
+    use.
+
+    """
+    result = []
+    for manager in Gcf.get_all_fig_managers():
+        fig = manager.canvas.figure
+        result.append('{0} - {0}'.format((fig.get_label() or
+                                          "Figure {0}".format(manager.num)),
+                                         manager.web_sockets))
+    if not is_interactive():
+        result.append('Figures pending show: {0}'.format(len(Gcf._activeQue)))
+    return '\n'.join(result)
+
+
+# Note: Version 3.2 and 4.x icons
+# http://fontawesome.io/3.2.1/icons/
+# http://fontawesome.io/
+# the `fa fa-xxx` part targets font-awesome 4, (IPython 3.x)
+# the icon-xxx targets font awesome 3.21 (IPython 2.x)
+_FONT_AWESOME_CLASSES = {
+    'home': 'fa fa-home icon-home',
+    'back': 'fa fa-arrow-left icon-arrow-left',
+    'forward': 'fa fa-arrow-right icon-arrow-right',
+    'zoom_to_rect': 'fa fa-square-o icon-check-empty',
+    'move': 'fa fa-arrows icon-move',
+    'download': 'fa fa-floppy-o icon-save',
+    None: None
+}
+
+
+class NavigationIPy(NavigationToolbar2WebAgg):
+
+    # Use the standard toolbar items + download button
+    toolitems = [(text, tooltip_text,
+                  _FONT_AWESOME_CLASSES[image_file], name_of_method)
+                 for text, tooltip_text, image_file, name_of_method
+                 in (NavigationToolbar2.toolitems +
+                     (('Download', 'Download plot', 'download', 'download'),))
+                 if image_file in _FONT_AWESOME_CLASSES]
+
+
+class FigureManagerNbAgg(FigureManagerWebAgg):
+    ToolbarCls = NavigationIPy
+
+    def __init__(self, canvas, num):
+        self._shown = False
+        FigureManagerWebAgg.__init__(self, canvas, num)
+
+    def display_js(self):
+        # XXX How to do this just once? It has to deal with multiple
+        # browser instances using the same kernel (require.js - but the
+        # file isn't static?).
+        display(Javascript(FigureManagerNbAgg.get_javascript()))
+
+    def show(self):
+        if not self._shown:
+            self.display_js()
+            self._create_comm()
+        else:
+            self.canvas.draw_idle()
+        self._shown = True
+
+    def reshow(self):
+        """
+        A special method to re-show the figure in the notebook.
+
+        """
+        self._shown = False
+        self.show()
+
+    @property
+    def connected(self):
+        return bool(self.web_sockets)
+
+    @classmethod
+    def get_javascript(cls, stream=None):
+        if stream is None:
+            output = io.StringIO()
+        else:
+            output = stream
+        super().get_javascript(stream=output)
+        output.write((pathlib.Path(__file__).parent
+                      / "web_backend/js/nbagg_mpl.js")
+                     .read_text(encoding="utf-8"))
+        if stream is None:
+            return output.getvalue()
+
+    def _create_comm(self):
+        comm = CommSocket(self)
+        self.add_web_socket(comm)
+        return comm
+
+    def destroy(self):
+        self._send_event('close')
+        # need to copy comms as callbacks will modify this list
+        for comm in list(self.web_sockets):
+            comm.on_close()
+        self.clearup_closed()
+
+    def clearup_closed(self):
+        """Clear up any closed Comms."""
+        self.web_sockets = {socket for socket in self.web_sockets
+                            if socket.is_open()}
+
+        if len(self.web_sockets) == 0:
+            self.canvas.close_event()
+
+    def remove_comm(self, comm_id):
+        self.web_sockets = {socket for socket in self.web_sockets
+                            if not socket.comm.comm_id == comm_id}
+
+
+class FigureCanvasNbAgg(FigureCanvasWebAggCore):
+    def new_timer(self, *args, **kwargs):
+        return TimerTornado(*args, **kwargs)
+
+
+class CommSocket(object):
+    """
+    Manages the Comm connection between IPython and the browser (client).
+
+    Comms are 2 way, with the CommSocket being able to publish a message
+    via the send_json method, and handle a message with on_message. On the
+    JS side figure.send_message and figure.ws.onmessage do the sending and
+    receiving respectively.
+
+    """
+    def __init__(self, manager):
+        self.supports_binary = None
+        self.manager = manager
+        self.uuid = str(uuid.uuid4())
+        # Publish an output area with a unique ID. The javascript can then
+        # hook into this area.
+        display(HTML("<div id=%r></div>" % self.uuid))
+        try:
+            self.comm = Comm('matplotlib', data={'id': self.uuid})
+        except AttributeError:
+            raise RuntimeError('Unable to create an IPython notebook Comm '
+                               'instance. Are you in the IPython notebook?')
+        self.comm.on_msg(self.on_message)
+
+        manager = self.manager
+        self._ext_close = False
+
+        def _on_close(close_message):
+            self._ext_close = True
+            manager.remove_comm(close_message['content']['comm_id'])
+            manager.clearup_closed()
+
+        self.comm.on_close(_on_close)
+
+    def is_open(self):
+        return not (self._ext_close or self.comm._closed)
+
+    def on_close(self):
+        # When the socket is closed, deregister the websocket with
+        # the FigureManager.
+        if self.is_open():
+            try:
+                self.comm.close()
+            except KeyError:
+                # apparently already cleaned it up?
+                pass
+
+    def send_json(self, content):
+        self.comm.send({'data': json.dumps(content)})
+
+    def send_binary(self, blob):
+        # The comm is ascii, so we always send the image in base64
+        # encoded data URL form.
+        data = b64encode(blob).decode('ascii')
+        data_uri = "data:image/png;base64,{0}".format(data)
+        self.comm.send({'data': data_uri})
+
+    def on_message(self, message):
+        # The 'supports_binary' message is relevant to the
+        # websocket itself.  The other messages get passed along
+        # to matplotlib as-is.
+
+        # Every message has a "type" and a "figure_id".
+        message = json.loads(message['content']['data'])
+        if message['type'] == 'closing':
+            self.on_close()
+            self.manager.clearup_closed()
+        elif message['type'] == 'supports_binary':
+            self.supports_binary = message['value']
+        else:
+            self.manager.handle_json(message)
+
+
+@_Backend.export
+class _BackendNbAgg(_Backend):
+    FigureCanvas = FigureCanvasNbAgg
+    FigureManager = FigureManagerNbAgg
+
+    @staticmethod
+    def new_figure_manager_given_figure(num, figure):
+        canvas = FigureCanvasNbAgg(figure)
+        manager = FigureManagerNbAgg(canvas, num)
+        if is_interactive():
+            manager.show()
+            figure.canvas.draw_idle()
+        canvas.mpl_connect('close_event', lambda event: Gcf.destroy(num))
+        return manager
+
+    @staticmethod
+    def trigger_manager_draw(manager):
+        manager.show()
+
+    @staticmethod
+    def show(*args, **kwargs):
+        ## TODO: something to do when keyword block==False ?
+        from matplotlib._pylab_helpers import Gcf
+
+        managers = Gcf.get_all_fig_managers()
+        if not managers:
+            return
+
+        interactive = is_interactive()
+
+        for manager in managers:
+            manager.show()
+
+            # plt.figure adds an event which puts the figure in focus
+            # in the activeQue. Disable this behaviour, as it results in
+            # figures being put as the active figure after they have been
+            # shown, even in non-interactive mode.
+            if hasattr(manager, '_cidgcf'):
+                manager.canvas.mpl_disconnect(manager._cidgcf)
+
+            if not interactive and manager in Gcf._activeQue:
+                Gcf._activeQue.remove(manager)

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_qt4.py

@@ -0,0 +1,10 @@
+from .backend_qt5 import (
+    backend_version, SPECIAL_KEYS, SUPER, ALT, CTRL, SHIFT, MODIFIER_KEYS,
+    cursord, _create_qApp, _BackendQT5, TimerQT, MainWindow, FigureManagerQT,
+    NavigationToolbar2QT, SubplotToolQt, error_msg_qt, exception_handler)
+from .backend_qt5 import FigureCanvasQT as FigureCanvasQT5
+
+
+@_BackendQT5.export
+class _BackendQT4(_BackendQT5):
+    required_interactive_framework = "qt4"

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_qt4agg.py

@@ -0,0 +1,11 @@
+"""
+Render to qt from agg
+"""
+
+from .backend_qt5agg import (
+    _BackendQT5Agg, FigureCanvasQTAgg, FigureManagerQT, NavigationToolbar2QT)
+
+
+@_BackendQT5Agg.export
+class _BackendQT4Agg(_BackendQT5Agg):
+    required_interactive_framework = "qt4"

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_qt4cairo.py

@@ -0,0 +1,6 @@
+from .backend_qt5cairo import _BackendQT5Cairo
+
+
+@_BackendQT5Cairo.export
+class _BackendQT4Cairo(_BackendQT5Cairo):
+    required_interactive_framework = "qt4"

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_qt5agg.py

@@ -0,0 +1,94 @@
+"""
+Render to qt from agg
+"""
+
+import ctypes
+
+from matplotlib.transforms import Bbox
+
+from .. import cbook
+from .backend_agg import FigureCanvasAgg
+from .backend_qt5 import (
+    QtCore, QtGui, QtWidgets, _BackendQT5, FigureCanvasQT, FigureManagerQT,
+    NavigationToolbar2QT, backend_version)
+from .qt_compat import QT_API
+
+
+class FigureCanvasQTAgg(FigureCanvasAgg, FigureCanvasQT):
+
+    def __init__(self, figure):
+        # Must pass 'figure' as kwarg to Qt base class.
+        super().__init__(figure=figure)
+
+    def paintEvent(self, event):
+        """Copy the image from the Agg canvas to the qt.drawable.
+
+        In Qt, all drawing should be done inside of here when a widget is
+        shown onscreen.
+        """
+        if self._update_dpi():
+            # The dpi update triggered its own paintEvent.
+            return
+        self._draw_idle()  # Only does something if a draw is pending.
+
+        # if the canvas does not have a renderer, then give up and wait for
+        # FigureCanvasAgg.draw(self) to be called
+        if not hasattr(self, 'renderer'):
+            return
+
+        painter = QtGui.QPainter(self)
+
+        if self._erase_before_paint:
+            painter.eraseRect(self.rect())
+            self._erase_before_paint = False
+
+        rect = event.rect()
+        left = rect.left()
+        top = rect.top()
+        width = rect.width()
+        height = rect.height()
+        # See documentation of QRect: bottom() and right() are off by 1, so use
+        # left() + width() and top() + height().
+        bbox = Bbox(
+            [[left, self.renderer.height - (top + height * self._dpi_ratio)],
+             [left + width * self._dpi_ratio, self.renderer.height - top]])
+        reg = self.copy_from_bbox(bbox)
+        buf = cbook._unmultiplied_rgba8888_to_premultiplied_argb32(
+            memoryview(reg))
+        qimage = QtGui.QImage(buf, buf.shape[1], buf.shape[0],
+                              QtGui.QImage.Format_ARGB32_Premultiplied)
+        if hasattr(qimage, 'setDevicePixelRatio'):
+            # Not available on Qt4 or some older Qt5.
+            qimage.setDevicePixelRatio(self._dpi_ratio)
+        origin = QtCore.QPoint(left, top)
+        painter.drawImage(origin / self._dpi_ratio, qimage)
+        # Adjust the buf reference count to work around a memory
+        # leak bug in QImage under PySide on Python 3.
+        if QT_API in ('PySide', 'PySide2'):
+            ctypes.c_long.from_address(id(buf)).value = 1
+
+        self._draw_rect_callback(painter)
+
+        painter.end()
+
+    def blit(self, bbox=None):
+        """Blit the region in bbox.
+        """
+        # If bbox is None, blit the entire canvas. Otherwise
+        # blit only the area defined by the bbox.
+        if bbox is None and self.figure:
+            bbox = self.figure.bbox
+
+        # repaint uses logical pixels, not physical pixels like the renderer.
+        l, b, w, h = [pt / self._dpi_ratio for pt in bbox.bounds]
+        t = b + h
+        self.repaint(l, self.renderer.height / self._dpi_ratio - t, w, h)
+
+    def print_figure(self, *args, **kwargs):
+        super().print_figure(*args, **kwargs)
+        self.draw()
+
+
+@_BackendQT5.export
+class _BackendQT5Agg(_BackendQT5):
+    FigureCanvas = FigureCanvasQTAgg

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_qt5cairo.py

@@ -0,0 +1,50 @@
+import ctypes
+
+from .backend_cairo import cairo, FigureCanvasCairo, RendererCairo
+from .backend_qt5 import QtCore, QtGui, _BackendQT5, FigureCanvasQT
+from .qt_compat import QT_API
+
+
+class FigureCanvasQTCairo(FigureCanvasQT, FigureCanvasCairo):
+    def __init__(self, figure):
+        super().__init__(figure=figure)
+        self._renderer = RendererCairo(self.figure.dpi)
+        self._renderer.set_width_height(-1, -1)  # Invalid values.
+
+    def draw(self):
+        if hasattr(self._renderer.gc, "ctx"):
+            self.figure.draw(self._renderer)
+        super().draw()
+
+    def paintEvent(self, event):
+        self._update_dpi()
+        dpi_ratio = self._dpi_ratio
+        width = dpi_ratio * self.width()
+        height = dpi_ratio * self.height()
+        if (width, height) != self._renderer.get_canvas_width_height():
+            surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
+            self._renderer.set_ctx_from_surface(surface)
+            self._renderer.set_width_height(width, height)
+            self.figure.draw(self._renderer)
+        buf = self._renderer.gc.ctx.get_target().get_data()
+        qimage = QtGui.QImage(buf, width, height,
+                              QtGui.QImage.Format_ARGB32_Premultiplied)
+        # Adjust the buf reference count to work around a memory leak bug in
+        # QImage under PySide on Python 3.
+        if QT_API == 'PySide':
+            ctypes.c_long.from_address(id(buf)).value = 1
+        if hasattr(qimage, 'setDevicePixelRatio'):
+            # Not available on Qt4 or some older Qt5.
+            qimage.setDevicePixelRatio(dpi_ratio)
+        painter = QtGui.QPainter(self)
+        if self._erase_before_paint:
+            painter.eraseRect(self.rect())
+            self._erase_before_paint = False
+        painter.drawImage(0, 0, qimage)
+        self._draw_rect_callback(painter)
+        painter.end()
+
+
+@_BackendQT5.export
+class _BackendQT5Cairo(_BackendQT5):
+    FigureCanvas = FigureCanvasQTCairo

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_template.py

@@ -0,0 +1,266 @@
+"""
+This is a fully functional do nothing backend to provide a template to
+backend writers.  It is fully functional in that you can select it as
+a backend with
+
+  import matplotlib
+  matplotlib.use('Template')
+
+and your matplotlib scripts will (should!) run without error, though
+no output is produced.  This provides a nice starting point for
+backend writers because you can selectively implement methods
+(draw_rectangle, draw_lines, etc...) and slowly see your figure come
+to life w/o having to have a full blown implementation before getting
+any results.
+
+Copy this to backend_xxx.py and replace all instances of 'template'
+with 'xxx'.  Then implement the class methods and functions below, and
+add 'xxx' to the switchyard in matplotlib/backends/__init__.py and
+'xxx' to the backends list in the validate_backend methon in
+matplotlib/__init__.py and you're off.  You can use your backend with::
+
+  import matplotlib
+  matplotlib.use('xxx')
+  import matplotlib.pyplot as plt
+  plt.plot([1,2,3])
+  plt.show()
+
+matplotlib also supports external backends, so you can place you can
+use any module in your PYTHONPATH with the syntax::
+
+  import matplotlib
+  matplotlib.use('module://my_backend')
+
+where my_backend.py is your module name.  This syntax is also
+recognized in the rc file and in the -d argument in pylab, e.g.,::
+
+  python simple_plot.py -dmodule://my_backend
+
+If your backend implements support for saving figures (i.e. has a print_xyz()
+method) you can register it as the default handler for a given file type
+
+  from matplotlib.backend_bases import register_backend
+  register_backend('xyz', 'my_backend', 'XYZ File Format')
+  ...
+  plt.savefig("figure.xyz")
+
+The files that are most relevant to backend_writers are
+
+  matplotlib/backends/backend_your_backend.py
+  matplotlib/backend_bases.py
+  matplotlib/backends/__init__.py
+  matplotlib/__init__.py
+  matplotlib/_pylab_helpers.py
+
+Naming Conventions
+
+  * classes Upper or MixedUpperCase
+
+  * variables lower or lowerUpper
+
+  * functions lower or underscore_separated
+
+"""
+
+from matplotlib._pylab_helpers import Gcf
+from matplotlib.backend_bases import (
+     FigureCanvasBase, FigureManagerBase, GraphicsContextBase, RendererBase)
+from matplotlib.figure import Figure
+
+
+class RendererTemplate(RendererBase):
+    """
+    The renderer handles drawing/rendering operations.
+
+    This is a minimal do-nothing class that can be used to get started when
+    writing a new backend. Refer to backend_bases.RendererBase for
+    documentation of the classes methods.
+    """
+    def __init__(self, dpi):
+        self.dpi = dpi
+
+    def draw_path(self, gc, path, transform, rgbFace=None):
+        pass
+
+    # draw_markers is optional, and we get more correct relative
+    # timings by leaving it out.  backend implementers concerned with
+    # performance will probably want to implement it
+#     def draw_markers(self, gc, marker_path, marker_trans, path, trans,
+#                      rgbFace=None):
+#         pass
+
+    # draw_path_collection is optional, and we get more correct
+    # relative timings by leaving it out. backend implementers concerned with
+    # performance will probably want to implement it
+#     def draw_path_collection(self, gc, master_transform, paths,
+#                              all_transforms, offsets, offsetTrans,
+#                              facecolors, edgecolors, linewidths, linestyles,
+#                              antialiaseds):
+#         pass
+
+    # draw_quad_mesh is optional, and we get more correct
+    # relative timings by leaving it out.  backend implementers concerned with
+    # performance will probably want to implement it
+#     def draw_quad_mesh(self, gc, master_transform, meshWidth, meshHeight,
+#                        coordinates, offsets, offsetTrans, facecolors,
+#                        antialiased, edgecolors):
+#         pass
+
+    def draw_image(self, gc, x, y, im):
+        pass
+
+    def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
+        pass
+
+    def flipy(self):
+        return True
+
+    def get_canvas_width_height(self):
+        return 100, 100
+
+    def get_text_width_height_descent(self, s, prop, ismath):
+        return 1, 1, 1
+
+    def new_gc(self):
+        return GraphicsContextTemplate()
+
+    def points_to_pixels(self, points):
+        # if backend doesn't have dpi, e.g., postscript or svg
+        return points
+        # elif backend assumes a value for pixels_per_inch
+        #return points/72.0 * self.dpi.get() * pixels_per_inch/72.0
+        # else
+        #return points/72.0 * self.dpi.get()
+
+
+class GraphicsContextTemplate(GraphicsContextBase):
+    """
+    The graphics context provides the color, line styles, etc...  See the cairo
+    and postscript backends for examples of mapping the graphics context
+    attributes (cap styles, join styles, line widths, colors) to a particular
+    backend.  In cairo this is done by wrapping a cairo.Context object and
+    forwarding the appropriate calls to it using a dictionary mapping styles
+    to gdk constants.  In Postscript, all the work is done by the renderer,
+    mapping line styles to postscript calls.
+
+    If it's more appropriate to do the mapping at the renderer level (as in
+    the postscript backend), you don't need to override any of the GC methods.
+    If it's more appropriate to wrap an instance (as in the cairo backend) and
+    do the mapping here, you'll need to override several of the setter
+    methods.
+
+    The base GraphicsContext stores colors as a RGB tuple on the unit
+    interval, e.g., (0.5, 0.0, 1.0). You may need to map this to colors
+    appropriate for your backend.
+    """
+
+
+########################################################################
+#
+# The following functions and classes are for pylab and implement
+# window/figure managers, etc...
+#
+########################################################################
+
+def draw_if_interactive():
+    """
+    For image backends - is not required.
+    For GUI backends - this should be overridden if drawing should be done in
+    interactive python mode.
+    """
+
+
+def show(block=None):
+    """
+    For image backends - is not required.
+    For GUI backends - show() is usually the last line of a pyplot script and
+    tells the backend that it is time to draw.  In interactive mode, this
+    should do nothing.
+    """
+    for manager in Gcf.get_all_fig_managers():
+        # do something to display the GUI
+        pass
+
+
+def new_figure_manager(num, *args, FigureClass=Figure, **kwargs):
+    """
+    Create a new figure manager instance
+    """
+    # If a main-level app must be created, this (and
+    # new_figure_manager_given_figure) is the usual place to do it -- see
+    # backend_wx, backend_wxagg and backend_tkagg for examples.  Not all GUIs
+    # require explicit instantiation of a main-level app (e.g., backend_gtk3)
+    # for pylab.
+    thisFig = FigureClass(*args, **kwargs)
+    return new_figure_manager_given_figure(num, thisFig)
+
+
+def new_figure_manager_given_figure(num, figure):
+    """
+    Create a new figure manager instance for the given figure.
+    """
+    canvas = FigureCanvasTemplate(figure)
+    manager = FigureManagerTemplate(canvas, num)
+    return manager
+
+
+class FigureCanvasTemplate(FigureCanvasBase):
+    """
+    The canvas the figure renders into.  Calls the draw and print fig
+    methods, creates the renderers, etc.
+
+    Note: GUI templates will want to connect events for button presses,
+    mouse movements and key presses to functions that call the base
+    class methods button_press_event, button_release_event,
+    motion_notify_event, key_press_event, and key_release_event.  See the
+    implementations of the interactive backends for examples.
+
+    Attributes
+    ----------
+    figure : `matplotlib.figure.Figure`
+        A high-level Figure instance
+    """
+
+    def draw(self):
+        """
+        Draw the figure using the renderer
+        """
+        renderer = RendererTemplate(self.figure.dpi)
+        self.figure.draw(renderer)
+
+    # You should provide a print_xxx function for every file format
+    # you can write.
+
+    # If the file type is not in the base set of filetypes,
+    # you should add it to the class-scope filetypes dictionary as follows:
+    filetypes = FigureCanvasBase.filetypes.copy()
+    filetypes['foo'] = 'My magic Foo format'
+
+    def print_foo(self, filename, *args, **kwargs):
+        """
+        Write out format foo.  The dpi, facecolor and edgecolor are restored
+        to their original values after this call, so you don't need to
+        save and restore them.
+        """
+        pass
+
+    def get_default_filetype(self):
+        return 'foo'
+
+
+class FigureManagerTemplate(FigureManagerBase):
+    """
+    Wrap everything up into a window for the pylab interface
+
+    For non interactive backends, the base class does all the work
+    """
+    pass
+
+########################################################################
+#
+# Now just provide the standard names that backend.__init__ is expecting
+#
+########################################################################
+
+FigureCanvas = FigureCanvasTemplate
+FigureManager = FigureManagerTemplate

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_tkagg.py

@@ -0,0 +1,21 @@
+from . import _backend_tk
+from .backend_agg import FigureCanvasAgg
+from ._backend_tk import (
+    _BackendTk, FigureCanvasTk, FigureManagerTk, NavigationToolbar2Tk)
+
+
+class FigureCanvasTkAgg(FigureCanvasAgg, FigureCanvasTk):
+    def draw(self):
+        super(FigureCanvasTkAgg, self).draw()
+        _backend_tk.blit(self._tkphoto, self.renderer._renderer, (0, 1, 2, 3))
+        self._master.update_idletasks()
+
+    def blit(self, bbox=None):
+        _backend_tk.blit(
+            self._tkphoto, self.renderer._renderer, (0, 1, 2, 3), bbox=bbox)
+        self._master.update_idletasks()
+
+
+@_BackendTk.export
+class _BackendTkAgg(_BackendTk):
+    FigureCanvas = FigureCanvasTkAgg

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_tkcairo.py

@@ -0,0 +1,31 @@
+import sys
+
+import numpy as np
+
+from . import _backend_tk
+from .backend_cairo import cairo, FigureCanvasCairo, RendererCairo
+from ._backend_tk import _BackendTk, FigureCanvasTk
+
+
+class FigureCanvasTkCairo(FigureCanvasCairo, FigureCanvasTk):
+    def __init__(self, *args, **kwargs):
+        super(FigureCanvasTkCairo, self).__init__(*args, **kwargs)
+        self._renderer = RendererCairo(self.figure.dpi)
+
+    def draw(self):
+        width = int(self.figure.bbox.width)
+        height = int(self.figure.bbox.height)
+        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
+        self._renderer.set_ctx_from_surface(surface)
+        self._renderer.set_width_height(width, height)
+        self.figure.draw(self._renderer)
+        buf = np.reshape(surface.get_data(), (height, width, 4))
+        _backend_tk.blit(
+            self._tkphoto, buf,
+            (2, 1, 0, 3) if sys.byteorder == "little" else (1, 2, 3, 0))
+        self._master.update_idletasks()
+
+
+@_BackendTk.export
+class _BackendTkCairo(_BackendTk):
+    FigureCanvas = FigureCanvasTkCairo

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_webagg.py

@@ -0,0 +1,335 @@
+"""
+Displays Agg images in the browser, with interactivity
+"""
+
+# The WebAgg backend is divided into two modules:
+#
+# - `backend_webagg_core.py` contains code necessary to embed a WebAgg
+#   plot inside of a web application, and communicate in an abstract
+#   way over a web socket.
+#
+# - `backend_webagg.py` contains a concrete implementation of a basic
+#   application, implemented with tornado.
+
+from contextlib import contextmanager
+import errno
+from io import BytesIO
+import json
+import os
+from pathlib import Path
+import random
+import sys
+import signal
+import socket
+import threading
+
+try:
+    import tornado
+except ImportError:
+    raise RuntimeError("The WebAgg backend requires Tornado.")
+
+import tornado.web
+import tornado.ioloop
+import tornado.websocket
+
+from matplotlib import rcParams
+from matplotlib.backend_bases import _Backend
+from matplotlib._pylab_helpers import Gcf
+from . import backend_webagg_core as core
+from .backend_webagg_core import TimerTornado
+
+
+class ServerThread(threading.Thread):
+    def run(self):
+        tornado.ioloop.IOLoop.instance().start()
+
+
+webagg_server_thread = ServerThread()
+
+
+class FigureCanvasWebAgg(core.FigureCanvasWebAggCore):
+    def show(self):
+        # show the figure window
+        global show  # placates pyflakes: created by @_Backend.export below
+        show()
+
+    def new_timer(self, *args, **kwargs):
+        return TimerTornado(*args, **kwargs)
+
+
+class WebAggApplication(tornado.web.Application):
+    initialized = False
+    started = False
+
+    class FavIcon(tornado.web.RequestHandler):
+        def get(self):
+            self.set_header('Content-Type', 'image/png')
+            image_path = Path(rcParams["datapath"], "images", "matplotlib.png")
+            self.write(image_path.read_bytes())
+
+    class SingleFigurePage(tornado.web.RequestHandler):
+        def __init__(self, application, request, *, url_prefix='', **kwargs):
+            self.url_prefix = url_prefix
+            super().__init__(application, request, **kwargs)
+
+        def get(self, fignum):
+            fignum = int(fignum)
+            manager = Gcf.get_fig_manager(fignum)
+
+            ws_uri = 'ws://{req.host}{prefix}/'.format(req=self.request,
+                                                       prefix=self.url_prefix)
+            self.render(
+                "single_figure.html",
+                prefix=self.url_prefix,
+                ws_uri=ws_uri,
+                fig_id=fignum,
+                toolitems=core.NavigationToolbar2WebAgg.toolitems,
+                canvas=manager.canvas)
+
+    class AllFiguresPage(tornado.web.RequestHandler):
+        def __init__(self, application, request, *, url_prefix='', **kwargs):
+            self.url_prefix = url_prefix
+            super().__init__(application, request, **kwargs)
+
+        def get(self):
+            ws_uri = 'ws://{req.host}{prefix}/'.format(req=self.request,
+                                                       prefix=self.url_prefix)
+            self.render(
+                "all_figures.html",
+                prefix=self.url_prefix,
+                ws_uri=ws_uri,
+                figures=sorted(Gcf.figs.items()),
+                toolitems=core.NavigationToolbar2WebAgg.toolitems)
+
+    class MplJs(tornado.web.RequestHandler):
+        def get(self):
+            self.set_header('Content-Type', 'application/javascript')
+
+            js_content = core.FigureManagerWebAgg.get_javascript()
+
+            self.write(js_content)
+
+    class Download(tornado.web.RequestHandler):
+        def get(self, fignum, fmt):
+            fignum = int(fignum)
+            manager = Gcf.get_fig_manager(fignum)
+
+            # TODO: Move this to a central location
+            mimetypes = {
+                'ps': 'application/postscript',
+                'eps': 'application/postscript',
+                'pdf': 'application/pdf',
+                'svg': 'image/svg+xml',
+                'png': 'image/png',
+                'jpeg': 'image/jpeg',
+                'tif': 'image/tiff',
+                'emf': 'application/emf'
+            }
+
+            self.set_header('Content-Type', mimetypes.get(fmt, 'binary'))
+
+            buff = BytesIO()
+            manager.canvas.figure.savefig(buff, format=fmt)
+            self.write(buff.getvalue())
+
+    class WebSocket(tornado.websocket.WebSocketHandler):
+        supports_binary = True
+
+        def open(self, fignum):
+            self.fignum = int(fignum)
+            self.manager = Gcf.get_fig_manager(self.fignum)
+            self.manager.add_web_socket(self)
+            if hasattr(self, 'set_nodelay'):
+                self.set_nodelay(True)
+
+        def on_close(self):
+            self.manager.remove_web_socket(self)
+
+        def on_message(self, message):
+            message = json.loads(message)
+            # The 'supports_binary' message is on a client-by-client
+            # basis.  The others affect the (shared) canvas as a
+            # whole.
+            if message['type'] == 'supports_binary':
+                self.supports_binary = message['value']
+            else:
+                manager = Gcf.get_fig_manager(self.fignum)
+                # It is possible for a figure to be closed,
+                # but a stale figure UI is still sending messages
+                # from the browser.
+                if manager is not None:
+                    manager.handle_json(message)
+
+        def send_json(self, content):
+            self.write_message(json.dumps(content))
+
+        def send_binary(self, blob):
+            if self.supports_binary:
+                self.write_message(blob, binary=True)
+            else:
+                data_uri = "data:image/png;base64,{0}".format(
+                    blob.encode('base64').replace('\n', ''))
+                self.write_message(data_uri)
+
+    def __init__(self, url_prefix=''):
+        if url_prefix:
+            assert url_prefix[0] == '/' and url_prefix[-1] != '/', \
+                'url_prefix must start with a "/" and not end with one.'
+
+        super().__init__(
+            [
+                # Static files for the CSS and JS
+                (url_prefix + r'/_static/(.*)',
+                 tornado.web.StaticFileHandler,
+                 {'path': core.FigureManagerWebAgg.get_static_file_path()}),
+
+                # An MPL favicon
+                (url_prefix + r'/favicon.ico', self.FavIcon),
+
+                # The page that contains all of the pieces
+                (url_prefix + r'/([0-9]+)', self.SingleFigurePage,
+                 {'url_prefix': url_prefix}),
+
+                # The page that contains all of the figures
+                (url_prefix + r'/?', self.AllFiguresPage,
+                 {'url_prefix': url_prefix}),
+
+                (url_prefix + r'/js/mpl.js', self.MplJs),
+
+                # Sends images and events to the browser, and receives
+                # events from the browser
+                (url_prefix + r'/([0-9]+)/ws', self.WebSocket),
+
+                # Handles the downloading (i.e., saving) of static images
+                (url_prefix + r'/([0-9]+)/download.([a-z0-9.]+)',
+                 self.Download),
+            ],
+            template_path=core.FigureManagerWebAgg.get_static_file_path())
+
+    @classmethod
+    def initialize(cls, url_prefix='', port=None, address=None):
+        if cls.initialized:
+            return
+
+        # Create the class instance
+        app = cls(url_prefix=url_prefix)
+
+        cls.url_prefix = url_prefix
+
+        # This port selection algorithm is borrowed, more or less
+        # verbatim, from IPython.
+        def random_ports(port, n):
+            """
+            Generate a list of n random ports near the given port.
+
+            The first 5 ports will be sequential, and the remaining n-5 will be
+            randomly selected in the range [port-2*n, port+2*n].
+            """
+            for i in range(min(5, n)):
+                yield port + i
+            for i in range(n - 5):
+                yield port + random.randint(-2 * n, 2 * n)
+
+        if address is None:
+            cls.address = rcParams['webagg.address']
+        else:
+            cls.address = address
+        cls.port = rcParams['webagg.port']
+        for port in random_ports(cls.port, rcParams['webagg.port_retries']):
+            try:
+                app.listen(port, cls.address)
+            except socket.error as e:
+                if e.errno != errno.EADDRINUSE:
+                    raise
+            else:
+                cls.port = port
+                break
+        else:
+            raise SystemExit(
+                "The webagg server could not be started because an available "
+                "port could not be found")
+
+        cls.initialized = True
+
+    @classmethod
+    def start(cls):
+        if cls.started:
+            return
+
+        """
+        IOLoop.running() was removed as of Tornado 2.4; see for example
+        https://groups.google.com/forum/#!topic/python-tornado/QLMzkpQBGOY
+        Thus there is no correct way to check if the loop has already been
+        launched. We may end up with two concurrently running loops in that
+        unlucky case with all the expected consequences.
+        """
+        ioloop = tornado.ioloop.IOLoop.instance()
+
+        def shutdown():
+            ioloop.stop()
+            print("Server is stopped")
+            sys.stdout.flush()
+            cls.started = False
+
+        @contextmanager
+        def catch_sigint():
+            old_handler = signal.signal(
+                signal.SIGINT,
+                lambda sig, frame: ioloop.add_callback_from_signal(shutdown))
+            try:
+                yield
+            finally:
+                signal.signal(signal.SIGINT, old_handler)
+
+        # Set the flag to True *before* blocking on ioloop.start()
+        cls.started = True
+
+        print("Press Ctrl+C to stop WebAgg server")
+        sys.stdout.flush()
+        with catch_sigint():
+            ioloop.start()
+
+
+def ipython_inline_display(figure):
+    import tornado.template
+
+    WebAggApplication.initialize()
+    if not webagg_server_thread.is_alive():
+        webagg_server_thread.start()
+
+    fignum = figure.number
+    tpl = Path(core.FigureManagerWebAgg.get_static_file_path(),
+               "ipython_inline_figure.html").read_text()
+    t = tornado.template.Template(tpl)
+    return t.generate(
+        prefix=WebAggApplication.url_prefix,
+        fig_id=fignum,
+        toolitems=core.NavigationToolbar2WebAgg.toolitems,
+        canvas=figure.canvas,
+        port=WebAggApplication.port).decode('utf-8')
+
+
+@_Backend.export
+class _BackendWebAgg(_Backend):
+    FigureCanvas = FigureCanvasWebAgg
+    FigureManager = core.FigureManagerWebAgg
+
+    @staticmethod
+    def trigger_manager_draw(manager):
+        manager.canvas.draw_idle()
+
+    @staticmethod
+    def show():
+        WebAggApplication.initialize()
+
+        url = "http://127.0.0.1:{port}{prefix}".format(
+            port=WebAggApplication.port,
+            prefix=WebAggApplication.url_prefix)
+
+        if rcParams['webagg.open_in_browser']:
+            import webbrowser
+            webbrowser.open(url)
+        else:
+            print("To view figure, visit {0}".format(url))
+
+        WebAggApplication.start()

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_webagg_core.py

@@ -0,0 +1,528 @@
+"""
+Displays Agg images in the browser, with interactivity
+"""
+# The WebAgg backend is divided into two modules:
+#
+# - `backend_webagg_core.py` contains code necessary to embed a WebAgg
+#   plot inside of a web application, and communicate in an abstract
+#   way over a web socket.
+#
+# - `backend_webagg.py` contains a concrete implementation of a basic
+#   application, implemented with tornado.
+
+import datetime
+from io import StringIO
+import json
+import os
+from pathlib import Path
+import warnings
+
+import numpy as np
+import tornado
+
+from matplotlib.backends import backend_agg
+from matplotlib.backend_bases import _Backend
+from matplotlib import backend_bases, _png
+
+
+# http://www.cambiaresearch.com/articles/15/javascript-char-codes-key-codes
+_SHIFT_LUT = {59: ':',
+              61: '+',
+              173: '_',
+              186: ':',
+              187: '+',
+              188: '<',
+              189: '_',
+              190: '>',
+              191: '?',
+              192: '~',
+              219: '{',
+              220: '|',
+              221: '}',
+              222: '"'}
+
+_LUT = {8: 'backspace',
+        9: 'tab',
+        13: 'enter',
+        16: 'shift',
+        17: 'control',
+        18: 'alt',
+        19: 'pause',
+        20: 'caps',
+        27: 'escape',
+        32: ' ',
+        33: 'pageup',
+        34: 'pagedown',
+        35: 'end',
+        36: 'home',
+        37: 'left',
+        38: 'up',
+        39: 'right',
+        40: 'down',
+        45: 'insert',
+        46: 'delete',
+        91: 'super',
+        92: 'super',
+        93: 'select',
+        106: '*',
+        107: '+',
+        109: '-',
+        110: '.',
+        111: '/',
+        144: 'num_lock',
+        145: 'scroll_lock',
+        186: ':',
+        187: '=',
+        188: ',',
+        189: '-',
+        190: '.',
+        191: '/',
+        192: '`',
+        219: '[',
+        220: '\\',
+        221: ']',
+        222: "'"}
+
+
+def _handle_key(key):
+    """Handle key codes"""
+    code = int(key[key.index('k') + 1:])
+    value = chr(code)
+    # letter keys
+    if 65 <= code <= 90:
+        if 'shift+' in key:
+            key = key.replace('shift+', '')
+        else:
+            value = value.lower()
+    # number keys
+    elif 48 <= code <= 57:
+        if 'shift+' in key:
+            value = ')!@#$%^&*('[int(value)]
+            key = key.replace('shift+', '')
+    # function keys
+    elif 112 <= code <= 123:
+        value = 'f%s' % (code - 111)
+    # number pad keys
+    elif 96 <= code <= 105:
+        value = '%s' % (code - 96)
+    # keys with shift alternatives
+    elif code in _SHIFT_LUT and 'shift+' in key:
+        key = key.replace('shift+', '')
+        value = _SHIFT_LUT[code]
+    elif code in _LUT:
+        value = _LUT[code]
+    key = key[:key.index('k')] + value
+    return key
+
+
+class FigureCanvasWebAggCore(backend_agg.FigureCanvasAgg):
+    supports_blit = False
+
+    def __init__(self, *args, **kwargs):
+        backend_agg.FigureCanvasAgg.__init__(self, *args, **kwargs)
+
+        # Set to True when the renderer contains data that is newer
+        # than the PNG buffer.
+        self._png_is_old = True
+
+        # Set to True by the `refresh` message so that the next frame
+        # sent to the clients will be a full frame.
+        self._force_full = True
+
+        # Store the current image mode so that at any point, clients can
+        # request the information. This should be changed by calling
+        # self.set_image_mode(mode) so that the notification can be given
+        # to the connected clients.
+        self._current_image_mode = 'full'
+
+        # Store the DPI ratio of the browser.  This is the scaling that
+        # occurs automatically for all images on a HiDPI display.
+        self._dpi_ratio = 1
+
+    def show(self):
+        # show the figure window
+        from matplotlib.pyplot import show
+        show()
+
+    def draw(self):
+        self._png_is_old = True
+        try:
+            super().draw()
+        finally:
+            self.manager.refresh_all()  # Swap the frames.
+
+    def draw_idle(self):
+        self.send_event("draw")
+
+    def set_image_mode(self, mode):
+        """
+        Set the image mode for any subsequent images which will be sent
+        to the clients. The modes may currently be either 'full' or 'diff'.
+
+        Note: diff images may not contain transparency, therefore upon
+        draw this mode may be changed if the resulting image has any
+        transparent component.
+
+        """
+        if mode not in ['full', 'diff']:
+            raise ValueError('image mode must be either full or diff.')
+        if self._current_image_mode != mode:
+            self._current_image_mode = mode
+            self.handle_send_image_mode(None)
+
+    def get_diff_image(self):
+        if self._png_is_old:
+            renderer = self.get_renderer()
+
+            # The buffer is created as type uint32 so that entire
+            # pixels can be compared in one numpy call, rather than
+            # needing to compare each plane separately.
+            buff = (np.frombuffer(renderer.buffer_rgba(), dtype=np.uint32)
+                    .reshape((renderer.height, renderer.width)))
+
+            # If any pixels have transparency, we need to force a full
+            # draw as we cannot overlay new on top of old.
+            pixels = buff.view(dtype=np.uint8).reshape(buff.shape + (4,))
+
+            if self._force_full or np.any(pixels[:, :, 3] != 255):
+                self.set_image_mode('full')
+                output = buff
+            else:
+                self.set_image_mode('diff')
+                last_buffer = (np.frombuffer(self._last_renderer.buffer_rgba(),
+                                             dtype=np.uint32)
+                               .reshape((renderer.height, renderer.width)))
+                diff = buff != last_buffer
+                output = np.where(diff, buff, 0)
+
+            # TODO: We should write a new version of write_png that
+            # handles the differencing inline
+            buff = _png.write_png(
+                output.view(dtype=np.uint8).reshape(output.shape + (4,)),
+                None, compression=6, filter=_png.PNG_FILTER_NONE)
+
+            # Swap the renderer frames
+            self._renderer, self._last_renderer = (
+                self._last_renderer, renderer)
+            self._force_full = False
+            self._png_is_old = False
+            return buff
+
+    def get_renderer(self, cleared=None):
+        # Mirrors super.get_renderer, but caches the old one
+        # so that we can do things such as produce a diff image
+        # in get_diff_image
+        _, _, w, h = self.figure.bbox.bounds
+        w, h = int(w), int(h)
+        key = w, h, self.figure.dpi
+        try:
+            self._lastKey, self._renderer
+        except AttributeError:
+            need_new_renderer = True
+        else:
+            need_new_renderer = (self._lastKey != key)
+
+        if need_new_renderer:
+            self._renderer = backend_agg.RendererAgg(
+                w, h, self.figure.dpi)
+            self._last_renderer = backend_agg.RendererAgg(
+                w, h, self.figure.dpi)
+            self._lastKey = key
+
+        elif cleared:
+            self._renderer.clear()
+
+        return self._renderer
+
+    def handle_event(self, event):
+        e_type = event['type']
+        handler = getattr(self, 'handle_{0}'.format(e_type),
+                          self.handle_unknown_event)
+        return handler(event)
+
+    def handle_unknown_event(self, event):
+        warnings.warn('Unhandled message type {0}. {1}'.format(
+            event['type'], event), stacklevel=2)
+
+    def handle_ack(self, event):
+        # Network latency tends to decrease if traffic is flowing
+        # in both directions.  Therefore, the browser sends back
+        # an "ack" message after each image frame is received.
+        # This could also be used as a simple sanity check in the
+        # future, but for now the performance increase is enough
+        # to justify it, even if the server does nothing with it.
+        pass
+
+    def handle_draw(self, event):
+        self.draw()
+
+    def _handle_mouse(self, event):
+        x = event['x']
+        y = event['y']
+        y = self.get_renderer().height - y
+
+        # Javascript button numbers and matplotlib button numbers are
+        # off by 1
+        button = event['button'] + 1
+
+        # The right mouse button pops up a context menu, which
+        # doesn't work very well, so use the middle mouse button
+        # instead.  It doesn't seem that it's possible to disable
+        # the context menu in recent versions of Chrome.  If this
+        # is resolved, please also adjust the docstring in MouseEvent.
+        if button == 2:
+            button = 3
+
+        e_type = event['type']
+        guiEvent = event.get('guiEvent', None)
+        if e_type == 'button_press':
+            self.button_press_event(x, y, button, guiEvent=guiEvent)
+        elif e_type == 'button_release':
+            self.button_release_event(x, y, button, guiEvent=guiEvent)
+        elif e_type == 'motion_notify':
+            self.motion_notify_event(x, y, guiEvent=guiEvent)
+        elif e_type == 'figure_enter':
+            self.enter_notify_event(xy=(x, y), guiEvent=guiEvent)
+        elif e_type == 'figure_leave':
+            self.leave_notify_event()
+        elif e_type == 'scroll':
+            self.scroll_event(x, y, event['step'], guiEvent=guiEvent)
+    handle_button_press = handle_button_release = handle_motion_notify = \
+        handle_figure_enter = handle_figure_leave = handle_scroll = \
+        _handle_mouse
+
+    def _handle_key(self, event):
+        key = _handle_key(event['key'])
+        e_type = event['type']
+        guiEvent = event.get('guiEvent', None)
+        if e_type == 'key_press':
+            self.key_press_event(key, guiEvent=guiEvent)
+        elif e_type == 'key_release':
+            self.key_release_event(key, guiEvent=guiEvent)
+    handle_key_press = handle_key_release = _handle_key
+
+    def handle_toolbar_button(self, event):
+        # TODO: Be more suspicious of the input
+        getattr(self.toolbar, event['name'])()
+
+    def handle_refresh(self, event):
+        figure_label = self.figure.get_label()
+        if not figure_label:
+            figure_label = "Figure {0}".format(self.manager.num)
+        self.send_event('figure_label', label=figure_label)
+        self._force_full = True
+        self.draw_idle()
+
+    def handle_resize(self, event):
+        x, y = event.get('width', 800), event.get('height', 800)
+        x, y = int(x) * self._dpi_ratio, int(y) * self._dpi_ratio
+        fig = self.figure
+        # An attempt at approximating the figure size in pixels.
+        fig.set_size_inches(x / fig.dpi, y / fig.dpi, forward=False)
+
+        _, _, w, h = self.figure.bbox.bounds
+        # Acknowledge the resize, and force the viewer to update the
+        # canvas size to the figure's new size (which is hopefully
+        # identical or within a pixel or so).
+        self._png_is_old = True
+        self.manager.resize(w, h)
+        self.resize_event()
+
+    def handle_send_image_mode(self, event):
+        # The client requests notification of what the current image mode is.
+        self.send_event('image_mode', mode=self._current_image_mode)
+
+    def handle_set_dpi_ratio(self, event):
+        dpi_ratio = event.get('dpi_ratio', 1)
+        if dpi_ratio != self._dpi_ratio:
+            # We don't want to scale up the figure dpi more than once.
+            if not hasattr(self.figure, '_original_dpi'):
+                self.figure._original_dpi = self.figure.dpi
+            self.figure.dpi = dpi_ratio * self.figure._original_dpi
+            self._dpi_ratio = dpi_ratio
+            self._force_full = True
+            self.draw_idle()
+
+    def send_event(self, event_type, **kwargs):
+        self.manager._send_event(event_type, **kwargs)
+
+
+_JQUERY_ICON_CLASSES = {
+    'home': 'ui-icon ui-icon-home',
+    'back': 'ui-icon ui-icon-circle-arrow-w',
+    'forward': 'ui-icon ui-icon-circle-arrow-e',
+    'zoom_to_rect': 'ui-icon ui-icon-search',
+    'move': 'ui-icon ui-icon-arrow-4',
+    'download': 'ui-icon ui-icon-disk',
+    None: None,
+}
+
+
+class NavigationToolbar2WebAgg(backend_bases.NavigationToolbar2):
+
+    # Use the standard toolbar items + download button
+    toolitems = [(text, tooltip_text, _JQUERY_ICON_CLASSES[image_file],
+                  name_of_method)
+                 for text, tooltip_text, image_file, name_of_method
+                 in (backend_bases.NavigationToolbar2.toolitems +
+                     (('Download', 'Download plot', 'download', 'download'),))
+                 if image_file in _JQUERY_ICON_CLASSES]
+
+    def _init_toolbar(self):
+        self.message = ''
+        self.cursor = 0
+
+    def set_message(self, message):
+        if message != self.message:
+            self.canvas.send_event("message", message=message)
+        self.message = message
+
+    def set_cursor(self, cursor):
+        if cursor != self.cursor:
+            self.canvas.send_event("cursor", cursor=cursor)
+        self.cursor = cursor
+
+    def draw_rubberband(self, event, x0, y0, x1, y1):
+        self.canvas.send_event(
+            "rubberband", x0=x0, y0=y0, x1=x1, y1=y1)
+
+    def release_zoom(self, event):
+        backend_bases.NavigationToolbar2.release_zoom(self, event)
+        self.canvas.send_event(
+            "rubberband", x0=-1, y0=-1, x1=-1, y1=-1)
+
+    def save_figure(self, *args):
+        """Save the current figure"""
+        self.canvas.send_event('save')
+
+
+class FigureManagerWebAgg(backend_bases.FigureManagerBase):
+    ToolbarCls = NavigationToolbar2WebAgg
+
+    def __init__(self, canvas, num):
+        backend_bases.FigureManagerBase.__init__(self, canvas, num)
+
+        self.web_sockets = set()
+
+        self.toolbar = self._get_toolbar(canvas)
+
+    def show(self):
+        pass
+
+    def _get_toolbar(self, canvas):
+        toolbar = self.ToolbarCls(canvas)
+        return toolbar
+
+    def resize(self, w, h):
+        self._send_event(
+            'resize',
+            size=(w / self.canvas._dpi_ratio, h / self.canvas._dpi_ratio))
+
+    def set_window_title(self, title):
+        self._send_event('figure_label', label=title)
+
+    # The following methods are specific to FigureManagerWebAgg
+
+    def add_web_socket(self, web_socket):
+        assert hasattr(web_socket, 'send_binary')
+        assert hasattr(web_socket, 'send_json')
+
+        self.web_sockets.add(web_socket)
+
+        _, _, w, h = self.canvas.figure.bbox.bounds
+        self.resize(w, h)
+        self._send_event('refresh')
+
+    def remove_web_socket(self, web_socket):
+        self.web_sockets.remove(web_socket)
+
+    def handle_json(self, content):
+        self.canvas.handle_event(content)
+
+    def refresh_all(self):
+        if self.web_sockets:
+            diff = self.canvas.get_diff_image()
+            if diff is not None:
+                for s in self.web_sockets:
+                    s.send_binary(diff)
+
+    @classmethod
+    def get_javascript(cls, stream=None):
+        if stream is None:
+            output = StringIO()
+        else:
+            output = stream
+
+        output.write((Path(__file__).parent / "web_backend/js/mpl.js")
+                     .read_text(encoding="utf-8"))
+
+        toolitems = []
+        for name, tooltip, image, method in cls.ToolbarCls.toolitems:
+            if name is None:
+                toolitems.append(['', '', '', ''])
+            else:
+                toolitems.append([name, tooltip, image, method])
+        output.write("mpl.toolbar_items = {0};\n\n".format(
+            json.dumps(toolitems)))
+
+        extensions = []
+        for filetype, ext in sorted(FigureCanvasWebAggCore.
+                                    get_supported_filetypes_grouped().
+                                    items()):
+            if not ext[0] == 'pgf':  # pgf does not support BytesIO
+                extensions.append(ext[0])
+        output.write("mpl.extensions = {0};\n\n".format(
+            json.dumps(extensions)))
+
+        output.write("mpl.default_extension = {0};".format(
+            json.dumps(FigureCanvasWebAggCore.get_default_filetype())))
+
+        if stream is None:
+            return output.getvalue()
+
+    @classmethod
+    def get_static_file_path(cls):
+        return os.path.join(os.path.dirname(__file__), 'web_backend')
+
+    def _send_event(self, event_type, **kwargs):
+        payload = {'type': event_type, **kwargs}
+        for s in self.web_sockets:
+            s.send_json(payload)
+
+
+class TimerTornado(backend_bases.TimerBase):
+    def _timer_start(self):
+        self._timer_stop()
+        if self._single:
+            ioloop = tornado.ioloop.IOLoop.instance()
+            self._timer = ioloop.add_timeout(
+                datetime.timedelta(milliseconds=self.interval),
+                self._on_timer)
+        else:
+            self._timer = tornado.ioloop.PeriodicCallback(
+                self._on_timer,
+                self.interval)
+            self._timer.start()
+
+    def _timer_stop(self):
+        if self._timer is None:
+            return
+        elif self._single:
+            ioloop = tornado.ioloop.IOLoop.instance()
+            ioloop.remove_timeout(self._timer)
+        else:
+            self._timer.stop()
+
+        self._timer = None
+
+    def _timer_set_interval(self):
+        # Only stop and restart it if the timer has already been started
+        if self._timer is not None:
+            self._timer_stop()
+            self._timer_start()
+
+
+@_Backend.export
+class _BackendWebAggCoreAgg(_Backend):
+    FigureCanvas = FigureCanvasWebAggCore
+    FigureManager = FigureManagerWebAgg

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_wxagg.py

@@ -0,0 +1,134 @@
+import wx
+
+from .backend_agg import FigureCanvasAgg
+from .backend_wx import (
+    _BackendWx, _FigureCanvasWxBase, FigureFrameWx,
+    NavigationToolbar2Wx as NavigationToolbar2WxAgg)
+
+
+class FigureFrameWxAgg(FigureFrameWx):
+    def get_canvas(self, fig):
+        return FigureCanvasWxAgg(self, -1, fig)
+
+
+class FigureCanvasWxAgg(FigureCanvasAgg, _FigureCanvasWxBase):
+    """
+    The FigureCanvas contains the figure and does event handling.
+
+    In the wxPython backend, it is derived from wxPanel, and (usually)
+    lives inside a frame instantiated by a FigureManagerWx. The parent
+    window probably implements a wxSizer to control the displayed
+    control size - but we give a hint as to our preferred minimum
+    size.
+    """
+
+    def draw(self, drawDC=None):
+        """
+        Render the figure using agg.
+        """
+        FigureCanvasAgg.draw(self)
+
+        self.bitmap = _convert_agg_to_wx_bitmap(self.get_renderer(), None)
+        self._isDrawn = True
+        self.gui_repaint(drawDC=drawDC, origin='WXAgg')
+
+    def blit(self, bbox=None):
+        """
+        Transfer the region of the agg buffer defined by bbox to the display.
+        If bbox is None, the entire buffer is transferred.
+        """
+        if bbox is None:
+            self.bitmap = _convert_agg_to_wx_bitmap(self.get_renderer(), None)
+            self.gui_repaint()
+            return
+
+        l, b, w, h = bbox.bounds
+        r = l + w
+        t = b + h
+        x = int(l)
+        y = int(self.bitmap.GetHeight() - t)
+
+        srcBmp = _convert_agg_to_wx_bitmap(self.get_renderer(), None)
+        srcDC = wx.MemoryDC()
+        srcDC.SelectObject(srcBmp)
+
+        destDC = wx.MemoryDC()
+        destDC.SelectObject(self.bitmap)
+
+        destDC.Blit(x, y, int(w), int(h), srcDC, x, y)
+
+        destDC.SelectObject(wx.NullBitmap)
+        srcDC.SelectObject(wx.NullBitmap)
+        self.gui_repaint()
+
+    filetypes = FigureCanvasAgg.filetypes
+
+
+# agg/wxPython image conversion functions (wxPython >= 2.8)
+
+def _convert_agg_to_wx_image(agg, bbox):
+    """
+    Convert the region of the agg buffer bounded by bbox to a wx.Image.  If
+    bbox is None, the entire buffer is converted.
+
+    Note: agg must be a backend_agg.RendererAgg instance.
+    """
+    if bbox is None:
+        # agg => rgb -> image
+        image = wx.Image(int(agg.width), int(agg.height))
+        image.SetData(agg.tostring_rgb())
+        return image
+    else:
+        # agg => rgba buffer -> bitmap => clipped bitmap => image
+        return wx.ImageFromBitmap(_WX28_clipped_agg_as_bitmap(agg, bbox))
+
+
+def _convert_agg_to_wx_bitmap(agg, bbox):
+    """
+    Convert the region of the agg buffer bounded by bbox to a wx.Bitmap.  If
+    bbox is None, the entire buffer is converted.
+
+    Note: agg must be a backend_agg.RendererAgg instance.
+    """
+    if bbox is None:
+        # agg => rgba buffer -> bitmap
+        return wx.Bitmap.FromBufferRGBA(int(agg.width), int(agg.height),
+                                        agg.buffer_rgba())
+    else:
+        # agg => rgba buffer -> bitmap => clipped bitmap
+        return _WX28_clipped_agg_as_bitmap(agg, bbox)
+
+
+def _WX28_clipped_agg_as_bitmap(agg, bbox):
+    """
+    Convert the region of a the agg buffer bounded by bbox to a wx.Bitmap.
+
+    Note: agg must be a backend_agg.RendererAgg instance.
+    """
+    l, b, width, height = bbox.bounds
+    r = l + width
+    t = b + height
+
+    srcBmp = wx.Bitmap.FromBufferRGBA(int(agg.width), int(agg.height),
+                                      agg.buffer_rgba())
+    srcDC = wx.MemoryDC()
+    srcDC.SelectObject(srcBmp)
+
+    destBmp = wx.Bitmap(int(width), int(height))
+    destDC = wx.MemoryDC()
+    destDC.SelectObject(destBmp)
+
+    x = int(l)
+    y = int(int(agg.height) - t)
+    destDC.Blit(0, 0, int(width), int(height), srcDC, x, y)
+
+    srcDC.SelectObject(wx.NullBitmap)
+    destDC.SelectObject(wx.NullBitmap)
+
+    return destBmp
+
+
+@_BackendWx.export
+class _BackendWxAgg(_BackendWx):
+    FigureCanvas = FigureCanvasWxAgg
+    _frame_class = FigureFrameWxAgg

utils/venv/lib/python3.6/site-packages/matplotlib/backends/backend_wxcairo.py

@@ -0,0 +1,48 @@
+import wx
+
+from .backend_cairo import cairo, FigureCanvasCairo, RendererCairo
+from .backend_wx import (
+    _BackendWx, _FigureCanvasWxBase, FigureFrameWx,
+    NavigationToolbar2Wx as NavigationToolbar2WxCairo)
+import wx.lib.wxcairo as wxcairo
+
+
+class FigureFrameWxCairo(FigureFrameWx):
+    def get_canvas(self, fig):
+        return FigureCanvasWxCairo(self, -1, fig)
+
+
+class FigureCanvasWxCairo(_FigureCanvasWxBase, FigureCanvasCairo):
+    """
+    The FigureCanvas contains the figure and does event handling.
+
+    In the wxPython backend, it is derived from wxPanel, and (usually) lives
+    inside a frame instantiated by a FigureManagerWx. The parent window
+    probably implements a wxSizer to control the displayed control size - but
+    we give a hint as to our preferred minimum size.
+    """
+
+    def __init__(self, parent, id, figure):
+        # _FigureCanvasWxBase should be fixed to have the same signature as
+        # every other FigureCanvas and use cooperative inheritance, but in the
+        # meantime the following will make do.
+        _FigureCanvasWxBase.__init__(self, parent, id, figure)
+        FigureCanvasCairo.__init__(self, figure)
+        self._renderer = RendererCairo(self.figure.dpi)
+
+    def draw(self, drawDC=None):
+        width = int(self.figure.bbox.width)
+        height = int(self.figure.bbox.height)
+        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
+        self._renderer.set_ctx_from_surface(surface)
+        self._renderer.set_width_height(width, height)
+        self.figure.draw(self._renderer)
+        self.bitmap = wxcairo.BitmapFromImageSurface(surface)
+        self._isDrawn = True
+        self.gui_repaint(drawDC=drawDC, origin='WXCairo')
+
+
+@_BackendWx.export
+class _BackendWxCairo(_BackendWx):
+    FigureCanvas = FigureCanvasWxCairo
+    _frame_class = FigureFrameWxCairo

utils/venv/lib/python3.6/site-packages/matplotlib/backends/qt_compat.py

@@ -0,0 +1,173 @@
+"""
+Qt binding and backend selector.
+
+The selection logic is as follows:
+- if any of PyQt5, PySide2, PyQt4 or PySide have already been imported
+  (checked in that order), use it;
+- otherwise, if the QT_API environment variable (used by Enthought) is
+  set, use it to determine which binding to use (but do not change the
+  backend based on it; i.e. if the Qt4Agg backend is requested but QT_API
+  is set to "pyqt5", then actually use Qt4 with the binding specified by
+  ``rcParams["backend.qt4"]``;
+- otherwise, use whatever the rcParams indicate.
+"""
+
+from distutils.version import LooseVersion
+import os
+import sys
+
+from matplotlib import rcParams
+
+
+QT_API_PYQT5 = "PyQt5"
+QT_API_PYSIDE2 = "PySide2"
+QT_API_PYQTv2 = "PyQt4v2"
+QT_API_PYSIDE = "PySide"
+QT_API_PYQT = "PyQt4"   # Use the old sip v1 API (Py3 defaults to v2).
+QT_API_ENV = os.environ.get("QT_API")
+# Mapping of QT_API_ENV to requested binding.  ETS does not support PyQt4v1.
+# (https://github.com/enthought/pyface/blob/master/pyface/qt/__init__.py)
+_ETS = {"pyqt5": QT_API_PYQT5, "pyside2": QT_API_PYSIDE2,
+        "pyqt": QT_API_PYQTv2, "pyside": QT_API_PYSIDE,
+        None: None}
+# First, check if anything is already imported.
+if "PyQt5" in sys.modules:
+    QT_API = QT_API_PYQT5
+    dict.__setitem__(rcParams, "backend.qt5", QT_API)
+elif "PySide2" in sys.modules:
+    QT_API = QT_API_PYSIDE2
+    dict.__setitem__(rcParams, "backend.qt5", QT_API)
+elif "PyQt4" in sys.modules:
+    QT_API = QT_API_PYQTv2
+    dict.__setitem__(rcParams, "backend.qt4", QT_API)
+elif "PySide" in sys.modules:
+    QT_API = QT_API_PYSIDE
+    dict.__setitem__(rcParams, "backend.qt4", QT_API)
+# Otherwise, check the QT_API environment variable (from Enthought).  This can
+# only override the binding, not the backend (in other words, we check that the
+# requested backend actually matches).
+elif rcParams["backend"] in ["Qt5Agg", "Qt5Cairo"]:
+    if QT_API_ENV == "pyqt5":
+        dict.__setitem__(rcParams, "backend.qt5", QT_API_PYQT5)
+    elif QT_API_ENV == "pyside2":
+        dict.__setitem__(rcParams, "backend.qt5", QT_API_PYSIDE2)
+    QT_API = dict.__getitem__(rcParams, "backend.qt5")
+elif rcParams["backend"] in ["Qt4Agg", "Qt4Cairo"]:
+    if QT_API_ENV == "pyqt4":
+        dict.__setitem__(rcParams, "backend.qt4", QT_API_PYQTv2)
+    elif QT_API_ENV == "pyside":
+        dict.__setitem__(rcParams, "backend.qt4", QT_API_PYSIDE)
+    QT_API = dict.__getitem__(rcParams, "backend.qt4")
+# A non-Qt backend was selected but we still got there (possible, e.g., when
+# fully manually embedding Matplotlib in a Qt app without using pyplot).
+else:
+    try:
+        QT_API = _ETS[QT_API_ENV]
+    except KeyError:
+        raise RuntimeError(
+            "The environment variable QT_API has the unrecognized value {!r};"
+            "valid values are 'pyqt5', 'pyside2', 'pyqt', and 'pyside'")
+
+
+def _setup_pyqt5():
+    global QtCore, QtGui, QtWidgets, __version__, is_pyqt5, _getSaveFileName
+
+    if QT_API == QT_API_PYQT5:
+        from PyQt5 import QtCore, QtGui, QtWidgets
+        __version__ = QtCore.PYQT_VERSION_STR
+        QtCore.Signal = QtCore.pyqtSignal
+        QtCore.Slot = QtCore.pyqtSlot
+        QtCore.Property = QtCore.pyqtProperty
+    elif QT_API == QT_API_PYSIDE2:
+        from PySide2 import QtCore, QtGui, QtWidgets, __version__
+    else:
+        raise ValueError("Unexpected value for the 'backend.qt5' rcparam")
+    _getSaveFileName = QtWidgets.QFileDialog.getSaveFileName
+
+    def is_pyqt5():
+        return True
+
+
+def _setup_pyqt4():
+    global QtCore, QtGui, QtWidgets, __version__, is_pyqt5, _getSaveFileName
+
+    def _setup_pyqt4_internal(api):
+        global QtCore, QtGui, QtWidgets, \
+            __version__, is_pyqt5, _getSaveFileName
+        # List of incompatible APIs:
+        # http://pyqt.sourceforge.net/Docs/PyQt4/incompatible_apis.html
+        _sip_apis = ["QDate", "QDateTime", "QString", "QTextStream", "QTime",
+                     "QUrl", "QVariant"]
+        try:
+            import sip
+        except ImportError:
+            pass
+        else:
+            for _sip_api in _sip_apis:
+                try:
+                    sip.setapi(_sip_api, api)
+                except ValueError:
+                    pass
+        from PyQt4 import QtCore, QtGui
+        __version__ = QtCore.PYQT_VERSION_STR
+        # PyQt 4.6 introduced getSaveFileNameAndFilter:
+        # https://riverbankcomputing.com/news/pyqt-46
+        if __version__ < LooseVersion("4.6"):
+            raise ImportError("PyQt<4.6 is not supported")
+        QtCore.Signal = QtCore.pyqtSignal
+        QtCore.Slot = QtCore.pyqtSlot
+        QtCore.Property = QtCore.pyqtProperty
+        _getSaveFileName = QtGui.QFileDialog.getSaveFileNameAndFilter
+
+    if QT_API == QT_API_PYQTv2:
+        _setup_pyqt4_internal(api=2)
+    elif QT_API == QT_API_PYSIDE:
+        from PySide import QtCore, QtGui, __version__, __version_info__
+        # PySide 1.0.3 fixed the following:
+        # https://srinikom.github.io/pyside-bz-archive/809.html
+        if __version_info__ < (1, 0, 3):
+            raise ImportError("PySide<1.0.3 is not supported")
+        _getSaveFileName = QtGui.QFileDialog.getSaveFileName
+    elif QT_API == QT_API_PYQT:
+        _setup_pyqt4_internal(api=1)
+    else:
+        raise ValueError("Unexpected value for the 'backend.qt4' rcparam")
+    QtWidgets = QtGui
+
+    def is_pyqt5():
+        return False
+
+
+if QT_API in [QT_API_PYQT5, QT_API_PYSIDE2]:
+    _setup_pyqt5()
+elif QT_API in [QT_API_PYQTv2, QT_API_PYSIDE, QT_API_PYQT]:
+    _setup_pyqt4()
+elif QT_API is None:
+    if rcParams["backend"] == "Qt4Agg":
+        _candidates = [(_setup_pyqt4, QT_API_PYQTv2),
+                       (_setup_pyqt4, QT_API_PYSIDE),
+                       (_setup_pyqt4, QT_API_PYQT),
+                       (_setup_pyqt5, QT_API_PYQT5),
+                       (_setup_pyqt5, QT_API_PYSIDE2)]
+    else:
+        _candidates = [(_setup_pyqt5, QT_API_PYQT5),
+                       (_setup_pyqt5, QT_API_PYSIDE2),
+                       (_setup_pyqt4, QT_API_PYQTv2),
+                       (_setup_pyqt4, QT_API_PYSIDE),
+                       (_setup_pyqt4, QT_API_PYQT)]
+    for _setup, QT_API in _candidates:
+        try:
+            _setup()
+        except ImportError:
+            continue
+        break
+    else:
+        raise ImportError("Failed to import any qt binding")
+else:  # We should not get there.
+    raise AssertionError("Unexpected QT_API: {}".format(QT_API))
+
+
+# These globals are only defined for backcompatibilty purposes.
+ETS = dict(pyqt=(QT_API_PYQTv2, 4), pyside=(QT_API_PYSIDE, 4),
+           pyqt5=(QT_API_PYQT5, 5), pyside2=(QT_API_PYSIDE2, 5))
+QT_RC_MAJOR_VERSION = 5 if is_pyqt5() else 4

utils/venv/lib/python3.6/site-packages/matplotlib/backends/qt_editor/figureoptions.py

@@ -0,0 +1,257 @@
+# Copyright © 2009 Pierre Raybaut
+# Licensed under the terms of the MIT License
+# see the mpl licenses directory for a copy of the license
+
+
+"""Module that provides a GUI-based editor for matplotlib's figure options."""
+
+import os.path
+import re
+
+import matplotlib
+from matplotlib import cm, colors as mcolors, markers, image as mimage
+import matplotlib.backends.qt_editor.formlayout as formlayout
+from matplotlib.backends.qt_compat import QtGui
+
+
+def get_icon(name):
+    basedir = os.path.join(matplotlib.rcParams['datapath'], 'images')
+    return QtGui.QIcon(os.path.join(basedir, name))
+
+
+LINESTYLES = {'-': 'Solid',
+              '--': 'Dashed',
+              '-.': 'DashDot',
+              ':': 'Dotted',
+              'None': 'None',
+              }
+
+DRAWSTYLES = {
+    'default': 'Default',
+    'steps-pre': 'Steps (Pre)', 'steps': 'Steps (Pre)',
+    'steps-mid': 'Steps (Mid)',
+    'steps-post': 'Steps (Post)'}
+
+MARKERS = markers.MarkerStyle.markers
+
+
+def figure_edit(axes, parent=None):
+    """Edit matplotlib figure options"""
+    sep = (None, None)  # separator
+
+    # Get / General
+    # Cast to builtin floats as they have nicer reprs.
+    xmin, xmax = map(float, axes.get_xlim())
+    ymin, ymax = map(float, axes.get_ylim())
+    general = [('Title', axes.get_title()),
+               sep,
+               (None, "<b>X-Axis</b>"),
+               ('Left', xmin), ('Right', xmax),
+               ('Label', axes.get_xlabel()),
+               ('Scale', [axes.get_xscale(), 'linear', 'log', 'logit']),
+               sep,
+               (None, "<b>Y-Axis</b>"),
+               ('Bottom', ymin), ('Top', ymax),
+               ('Label', axes.get_ylabel()),
+               ('Scale', [axes.get_yscale(), 'linear', 'log', 'logit']),
+               sep,
+               ('(Re-)Generate automatic legend', False),
+               ]
+
+    # Save the unit data
+    xconverter = axes.xaxis.converter
+    yconverter = axes.yaxis.converter
+    xunits = axes.xaxis.get_units()
+    yunits = axes.yaxis.get_units()
+
+    # Sorting for default labels (_lineXXX, _imageXXX).
+    def cmp_key(label):
+        match = re.match(r"(_line|_image)(\d+)", label)
+        if match:
+            return match.group(1), int(match.group(2))
+        else:
+            return label, 0
+
+    # Get / Curves
+    linedict = {}
+    for line in axes.get_lines():
+        label = line.get_label()
+        if label == '_nolegend_':
+            continue
+        linedict[label] = line
+    curves = []
+
+    def prepare_data(d, init):
+        """Prepare entry for FormLayout.
+
+        `d` is a mapping of shorthands to style names (a single style may
+        have multiple shorthands, in particular the shorthands `None`,
+        `"None"`, `"none"` and `""` are synonyms); `init` is one shorthand
+        of the initial style.
+
+        This function returns an list suitable for initializing a
+        FormLayout combobox, namely `[initial_name, (shorthand,
+        style_name), (shorthand, style_name), ...]`.
+        """
+        if init not in d:
+            d = {**d, init: str(init)}
+        # Drop duplicate shorthands from dict (by overwriting them during
+        # the dict comprehension).
+        name2short = {name: short for short, name in d.items()}
+        # Convert back to {shorthand: name}.
+        short2name = {short: name for name, short in name2short.items()}
+        # Find the kept shorthand for the style specified by init.
+        canonical_init = name2short[d[init]]
+        # Sort by representation and prepend the initial value.
+        return ([canonical_init] +
+                sorted(short2name.items(),
+                       key=lambda short_and_name: short_and_name[1]))
+
+    curvelabels = sorted(linedict, key=cmp_key)
+    for label in curvelabels:
+        line = linedict[label]
+        color = mcolors.to_hex(
+            mcolors.to_rgba(line.get_color(), line.get_alpha()),
+            keep_alpha=True)
+        ec = mcolors.to_hex(
+            mcolors.to_rgba(line.get_markeredgecolor(), line.get_alpha()),
+            keep_alpha=True)
+        fc = mcolors.to_hex(
+            mcolors.to_rgba(line.get_markerfacecolor(), line.get_alpha()),
+            keep_alpha=True)
+        curvedata = [
+            ('Label', label),
+            sep,
+            (None, '<b>Line</b>'),
+            ('Line style', prepare_data(LINESTYLES, line.get_linestyle())),
+            ('Draw style', prepare_data(DRAWSTYLES, line.get_drawstyle())),
+            ('Width', line.get_linewidth()),
+            ('Color (RGBA)', color),
+            sep,
+            (None, '<b>Marker</b>'),
+            ('Style', prepare_data(MARKERS, line.get_marker())),
+            ('Size', line.get_markersize()),
+            ('Face color (RGBA)', fc),
+            ('Edge color (RGBA)', ec)]
+        curves.append([curvedata, label, ""])
+    # Is there a curve displayed?
+    has_curve = bool(curves)
+
+    # Get / Images
+    imagedict = {}
+    for image in axes.get_images():
+        label = image.get_label()
+        if label == '_nolegend_':
+            continue
+        imagedict[label] = image
+    imagelabels = sorted(imagedict, key=cmp_key)
+    images = []
+    cmaps = [(cmap, name) for name, cmap in sorted(cm.cmap_d.items())]
+    for label in imagelabels:
+        image = imagedict[label]
+        cmap = image.get_cmap()
+        if cmap not in cm.cmap_d.values():
+            cmaps = [(cmap, cmap.name)] + cmaps
+        low, high = image.get_clim()
+        imagedata = [
+            ('Label', label),
+            ('Colormap', [cmap.name] + cmaps),
+            ('Min. value', low),
+            ('Max. value', high),
+            ('Interpolation',
+             [image.get_interpolation()]
+             + [(name, name) for name in sorted(mimage.interpolations_names)])]
+        images.append([imagedata, label, ""])
+    # Is there an image displayed?
+    has_image = bool(images)
+
+    datalist = [(general, "Axes", "")]
+    if curves:
+        datalist.append((curves, "Curves", ""))
+    if images:
+        datalist.append((images, "Images", ""))
+
+    def apply_callback(data):
+        """This function will be called to apply changes"""
+        orig_xlim = axes.get_xlim()
+        orig_ylim = axes.get_ylim()
+
+        general = data.pop(0)
+        curves = data.pop(0) if has_curve else []
+        images = data.pop(0) if has_image else []
+        if data:
+            raise ValueError("Unexpected field")
+
+        # Set / General
+        (title, xmin, xmax, xlabel, xscale, ymin, ymax, ylabel, yscale,
+         generate_legend) = general
+
+        if axes.get_xscale() != xscale:
+            axes.set_xscale(xscale)
+        if axes.get_yscale() != yscale:
+            axes.set_yscale(yscale)
+
+        axes.set_title(title)
+        axes.set_xlim(xmin, xmax)
+        axes.set_xlabel(xlabel)
+        axes.set_ylim(ymin, ymax)
+        axes.set_ylabel(ylabel)
+
+        # Restore the unit data
+        axes.xaxis.converter = xconverter
+        axes.yaxis.converter = yconverter
+        axes.xaxis.set_units(xunits)
+        axes.yaxis.set_units(yunits)
+        axes.xaxis._update_axisinfo()
+        axes.yaxis._update_axisinfo()
+
+        # Set / Curves
+        for index, curve in enumerate(curves):
+            line = linedict[curvelabels[index]]
+            (label, linestyle, drawstyle, linewidth, color, marker, markersize,
+             markerfacecolor, markeredgecolor) = curve
+            line.set_label(label)
+            line.set_linestyle(linestyle)
+            line.set_drawstyle(drawstyle)
+            line.set_linewidth(linewidth)
+            rgba = mcolors.to_rgba(color)
+            line.set_alpha(None)
+            line.set_color(rgba)
+            if marker is not 'none':
+                line.set_marker(marker)
+                line.set_markersize(markersize)
+                line.set_markerfacecolor(markerfacecolor)
+                line.set_markeredgecolor(markeredgecolor)
+
+        # Set / Images
+        for index, image_settings in enumerate(images):
+            image = imagedict[imagelabels[index]]
+            label, cmap, low, high, interpolation = image_settings
+            image.set_label(label)
+            image.set_cmap(cm.get_cmap(cmap))
+            image.set_clim(*sorted([low, high]))
+            image.set_interpolation(interpolation)
+
+        # re-generate legend, if checkbox is checked
+        if generate_legend:
+            draggable = None
+            ncol = 1
+            if axes.legend_ is not None:
+                old_legend = axes.get_legend()
+                draggable = old_legend._draggable is not None
+                ncol = old_legend._ncol
+            new_legend = axes.legend(ncol=ncol)
+            if new_legend:
+                new_legend.set_draggable(draggable)
+
+        # Redraw
+        figure = axes.get_figure()
+        figure.canvas.draw()
+        if not (axes.get_xlim() == orig_xlim and axes.get_ylim() == orig_ylim):
+            figure.canvas.toolbar.push_current()
+
+    data = formlayout.fedit(datalist, title="Figure options", parent=parent,
+                            icon=get_icon('qt4_editor_options.svg'),
+                            apply=apply_callback)
+    if data is not None:
+        apply_callback(data)

utils/venv/lib/python3.6/site-packages/matplotlib/backends/qt_editor/formlayout.py

@@ -0,0 +1,542 @@
+"""
+formlayout
+==========
+
+Module creating Qt form dialogs/layouts to edit various type of parameters
+
+
+formlayout License Agreement (MIT License)
+------------------------------------------
+
+Copyright (c) 2009 Pierre Raybaut
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+"""
+
+# History:
+# 1.0.10: added float validator (disable "Ok" and "Apply" button when not valid)
+# 1.0.7: added support for "Apply" button
+# 1.0.6: code cleaning
+
+__version__ = '1.0.10'
+__license__ = __doc__
+
+import copy
+import datetime
+from numbers import Integral, Real
+import warnings
+
+from matplotlib import colors as mcolors
+from matplotlib.backends.qt_compat import QtGui, QtWidgets, QtCore
+
+
+BLACKLIST = {"title", "label"}
+
+
+class ColorButton(QtWidgets.QPushButton):
+    """
+    Color choosing push button
+    """
+    colorChanged = QtCore.Signal(QtGui.QColor)
+
+    def __init__(self, parent=None):
+        QtWidgets.QPushButton.__init__(self, parent)
+        self.setFixedSize(20, 20)
+        self.setIconSize(QtCore.QSize(12, 12))
+        self.clicked.connect(self.choose_color)
+        self._color = QtGui.QColor()
+
+    def choose_color(self):
+        color = QtWidgets.QColorDialog.getColor(
+            self._color, self.parentWidget(), "",
+            QtWidgets.QColorDialog.ShowAlphaChannel)
+        if color.isValid():
+            self.set_color(color)
+
+    def get_color(self):
+        return self._color
+
+    @QtCore.Slot(QtGui.QColor)
+    def set_color(self, color):
+        if color != self._color:
+            self._color = color
+            self.colorChanged.emit(self._color)
+            pixmap = QtGui.QPixmap(self.iconSize())
+            pixmap.fill(color)
+            self.setIcon(QtGui.QIcon(pixmap))
+
+    color = QtCore.Property(QtGui.QColor, get_color, set_color)
+
+
+def to_qcolor(color):
+    """Create a QColor from a matplotlib color"""
+    qcolor = QtGui.QColor()
+    try:
+        rgba = mcolors.to_rgba(color)
+    except ValueError:
+        warnings.warn('Ignoring invalid color %r' % color, stacklevel=2)
+        return qcolor  # return invalid QColor
+    qcolor.setRgbF(*rgba)
+    return qcolor
+
+
+class ColorLayout(QtWidgets.QHBoxLayout):
+    """Color-specialized QLineEdit layout"""
+    def __init__(self, color, parent=None):
+        QtWidgets.QHBoxLayout.__init__(self)
+        assert isinstance(color, QtGui.QColor)
+        self.lineedit = QtWidgets.QLineEdit(
+            mcolors.to_hex(color.getRgbF(), keep_alpha=True), parent)
+        self.lineedit.editingFinished.connect(self.update_color)
+        self.addWidget(self.lineedit)
+        self.colorbtn = ColorButton(parent)
+        self.colorbtn.color = color
+        self.colorbtn.colorChanged.connect(self.update_text)
+        self.addWidget(self.colorbtn)
+
+    def update_color(self):
+        color = self.text()
+        qcolor = to_qcolor(color)
+        self.colorbtn.color = qcolor  # defaults to black if not qcolor.isValid()
+
+    def update_text(self, color):
+        self.lineedit.setText(mcolors.to_hex(color.getRgbF(), keep_alpha=True))
+
+    def text(self):
+        return self.lineedit.text()
+
+
+def font_is_installed(font):
+    """Check if font is installed"""
+    return [fam for fam in QtGui.QFontDatabase().families()
+            if str(fam) == font]
+
+
+def tuple_to_qfont(tup):
+    """
+    Create a QFont from tuple:
+        (family [string], size [int], italic [bool], bold [bool])
+    """
+    if not (isinstance(tup, tuple) and len(tup) == 4
+            and font_is_installed(tup[0])
+            and isinstance(tup[1], Integral)
+            and isinstance(tup[2], bool)
+            and isinstance(tup[3], bool)):
+        return None
+    font = QtGui.QFont()
+    family, size, italic, bold = tup
+    font.setFamily(family)
+    font.setPointSize(size)
+    font.setItalic(italic)
+    font.setBold(bold)
+    return font
+
+
+def qfont_to_tuple(font):
+    return (str(font.family()), int(font.pointSize()),
+            font.italic(), font.bold())
+
+
+class FontLayout(QtWidgets.QGridLayout):
+    """Font selection"""
+    def __init__(self, value, parent=None):
+        QtWidgets.QGridLayout.__init__(self)
+        font = tuple_to_qfont(value)
+        assert font is not None
+
+        # Font family
+        self.family = QtWidgets.QFontComboBox(parent)
+        self.family.setCurrentFont(font)
+        self.addWidget(self.family, 0, 0, 1, -1)
+
+        # Font size
+        self.size = QtWidgets.QComboBox(parent)
+        self.size.setEditable(True)
+        sizelist = [*range(6, 12), *range(12, 30, 2), 36, 48, 72]
+        size = font.pointSize()
+        if size not in sizelist:
+            sizelist.append(size)
+            sizelist.sort()
+        self.size.addItems([str(s) for s in sizelist])
+        self.size.setCurrentIndex(sizelist.index(size))
+        self.addWidget(self.size, 1, 0)
+
+        # Italic or not
+        self.italic = QtWidgets.QCheckBox(self.tr("Italic"), parent)
+        self.italic.setChecked(font.italic())
+        self.addWidget(self.italic, 1, 1)
+
+        # Bold or not
+        self.bold = QtWidgets.QCheckBox(self.tr("Bold"), parent)
+        self.bold.setChecked(font.bold())
+        self.addWidget(self.bold, 1, 2)
+
+    def get_font(self):
+        font = self.family.currentFont()
+        font.setItalic(self.italic.isChecked())
+        font.setBold(self.bold.isChecked())
+        font.setPointSize(int(self.size.currentText()))
+        return qfont_to_tuple(font)
+
+
+def is_edit_valid(edit):
+    text = edit.text()
+    state = edit.validator().validate(text, 0)[0]
+
+    return state == QtGui.QDoubleValidator.Acceptable
+
+
+class FormWidget(QtWidgets.QWidget):
+    update_buttons = QtCore.Signal()
+    def __init__(self, data, comment="", parent=None):
+        QtWidgets.QWidget.__init__(self, parent)
+        self.data = copy.deepcopy(data)
+        self.widgets = []
+        self.formlayout = QtWidgets.QFormLayout(self)
+        if comment:
+            self.formlayout.addRow(QtWidgets.QLabel(comment))
+            self.formlayout.addRow(QtWidgets.QLabel(" "))
+
+    def get_dialog(self):
+        """Return FormDialog instance"""
+        dialog = self.parent()
+        while not isinstance(dialog, QtWidgets.QDialog):
+            dialog = dialog.parent()
+        return dialog
+
+    def setup(self):
+        for label, value in self.data:
+            if label is None and value is None:
+                # Separator: (None, None)
+                self.formlayout.addRow(QtWidgets.QLabel(" "), QtWidgets.QLabel(" "))
+                self.widgets.append(None)
+                continue
+            elif label is None:
+                # Comment
+                self.formlayout.addRow(QtWidgets.QLabel(value))
+                self.widgets.append(None)
+                continue
+            elif tuple_to_qfont(value) is not None:
+                field = FontLayout(value, self)
+            elif (label.lower() not in BLACKLIST
+                  and mcolors.is_color_like(value)):
+                field = ColorLayout(to_qcolor(value), self)
+            elif isinstance(value, str):
+                field = QtWidgets.QLineEdit(value, self)
+            elif isinstance(value, (list, tuple)):
+                if isinstance(value, tuple):
+                    value = list(value)
+                # Note: get() below checks the type of value[0] in self.data so
+                # it is essential that value gets modified in-place.
+                # This means that the code is actually broken in the case where
+                # value is a tuple, but fortunately we always pass a list...
+                selindex = value.pop(0)
+                field = QtWidgets.QComboBox(self)
+                if isinstance(value[0], (list, tuple)):
+                    keys = [key for key, _val in value]
+                    value = [val for _key, val in value]
+                else:
+                    keys = value
+                field.addItems(value)
+                if selindex in value:
+                    selindex = value.index(selindex)
+                elif selindex in keys:
+                    selindex = keys.index(selindex)
+                elif not isinstance(selindex, Integral):
+                    warnings.warn(
+                        "index '%s' is invalid (label: %s, value: %s)" %
+                        (selindex, label, value), stacklevel=2)
+                    selindex = 0
+                field.setCurrentIndex(selindex)
+            elif isinstance(value, bool):
+                field = QtWidgets.QCheckBox(self)
+                if value:
+                    field.setCheckState(QtCore.Qt.Checked)
+                else:
+                    field.setCheckState(QtCore.Qt.Unchecked)
+            elif isinstance(value, Integral):
+                field = QtWidgets.QSpinBox(self)
+                field.setRange(-1e9, 1e9)
+                field.setValue(value)
+            elif isinstance(value, Real):
+                field = QtWidgets.QLineEdit(repr(value), self)
+                field.setCursorPosition(0)
+                field.setValidator(QtGui.QDoubleValidator(field))
+                field.validator().setLocale(QtCore.QLocale("C"))
+                dialog = self.get_dialog()
+                dialog.register_float_field(field)
+                field.textChanged.connect(lambda text: dialog.update_buttons())
+            elif isinstance(value, datetime.datetime):
+                field = QtWidgets.QDateTimeEdit(self)
+                field.setDateTime(value)
+            elif isinstance(value, datetime.date):
+                field = QtWidgets.QDateEdit(self)
+                field.setDate(value)
+            else:
+                field = QtWidgets.QLineEdit(repr(value), self)
+            self.formlayout.addRow(label, field)
+            self.widgets.append(field)
+
+    def get(self):
+        valuelist = []
+        for index, (label, value) in enumerate(self.data):
+            field = self.widgets[index]
+            if label is None:
+                # Separator / Comment
+                continue
+            elif tuple_to_qfont(value) is not None:
+                value = field.get_font()
+            elif isinstance(value, str) or mcolors.is_color_like(value):
+                value = str(field.text())
+            elif isinstance(value, (list, tuple)):
+                index = int(field.currentIndex())
+                if isinstance(value[0], (list, tuple)):
+                    value = value[index][0]
+                else:
+                    value = value[index]
+            elif isinstance(value, bool):
+                value = field.checkState() == QtCore.Qt.Checked
+            elif isinstance(value, Integral):
+                value = int(field.value())
+            elif isinstance(value, Real):
+                value = float(str(field.text()))
+            elif isinstance(value, datetime.datetime):
+                value = field.dateTime().toPyDateTime()
+            elif isinstance(value, datetime.date):
+                value = field.date().toPyDate()
+            else:
+                value = eval(str(field.text()))
+            valuelist.append(value)
+        return valuelist
+
+
+class FormComboWidget(QtWidgets.QWidget):
+    update_buttons = QtCore.Signal()
+
+    def __init__(self, datalist, comment="", parent=None):
+        QtWidgets.QWidget.__init__(self, parent)
+        layout = QtWidgets.QVBoxLayout()
+        self.setLayout(layout)
+        self.combobox = QtWidgets.QComboBox()
+        layout.addWidget(self.combobox)
+
+        self.stackwidget = QtWidgets.QStackedWidget(self)
+        layout.addWidget(self.stackwidget)
+        self.combobox.currentIndexChanged.connect(self.stackwidget.setCurrentIndex)
+
+        self.widgetlist = []
+        for data, title, comment in datalist:
+            self.combobox.addItem(title)
+            widget = FormWidget(data, comment=comment, parent=self)
+            self.stackwidget.addWidget(widget)
+            self.widgetlist.append(widget)
+
+    def setup(self):
+        for widget in self.widgetlist:
+            widget.setup()
+
+    def get(self):
+        return [widget.get() for widget in self.widgetlist]
+
+
+class FormTabWidget(QtWidgets.QWidget):
+    update_buttons = QtCore.Signal()
+
+    def __init__(self, datalist, comment="", parent=None):
+        QtWidgets.QWidget.__init__(self, parent)
+        layout = QtWidgets.QVBoxLayout()
+        self.tabwidget = QtWidgets.QTabWidget()
+        layout.addWidget(self.tabwidget)
+        self.setLayout(layout)
+        self.widgetlist = []
+        for data, title, comment in datalist:
+            if len(data[0]) == 3:
+                widget = FormComboWidget(data, comment=comment, parent=self)
+            else:
+                widget = FormWidget(data, comment=comment, parent=self)
+            index = self.tabwidget.addTab(widget, title)
+            self.tabwidget.setTabToolTip(index, comment)
+            self.widgetlist.append(widget)
+
+    def setup(self):
+        for widget in self.widgetlist:
+            widget.setup()
+
+    def get(self):
+        return [widget.get() for widget in self.widgetlist]
+
+
+class FormDialog(QtWidgets.QDialog):
+    """Form Dialog"""
+    def __init__(self, data, title="", comment="",
+                 icon=None, parent=None, apply=None):
+        QtWidgets.QDialog.__init__(self, parent)
+
+        self.apply_callback = apply
+
+        # Form
+        if isinstance(data[0][0], (list, tuple)):
+            self.formwidget = FormTabWidget(data, comment=comment,
+                                            parent=self)
+        elif len(data[0]) == 3:
+            self.formwidget = FormComboWidget(data, comment=comment,
+                                              parent=self)
+        else:
+            self.formwidget = FormWidget(data, comment=comment,
+                                         parent=self)
+        layout = QtWidgets.QVBoxLayout()
+        layout.addWidget(self.formwidget)
+
+        self.float_fields = []
+        self.formwidget.setup()
+
+        # Button box
+        self.bbox = bbox = QtWidgets.QDialogButtonBox(
+            QtWidgets.QDialogButtonBox.Ok | QtWidgets.QDialogButtonBox.Cancel)
+        self.formwidget.update_buttons.connect(self.update_buttons)
+        if self.apply_callback is not None:
+            apply_btn = bbox.addButton(QtWidgets.QDialogButtonBox.Apply)
+            apply_btn.clicked.connect(self.apply)
+
+        bbox.accepted.connect(self.accept)
+        bbox.rejected.connect(self.reject)
+        layout.addWidget(bbox)
+
+        self.setLayout(layout)
+
+        self.setWindowTitle(title)
+        if not isinstance(icon, QtGui.QIcon):
+            icon = QtWidgets.QWidget().style().standardIcon(QtWidgets.QStyle.SP_MessageBoxQuestion)
+        self.setWindowIcon(icon)
+
+    def register_float_field(self, field):
+        self.float_fields.append(field)
+
+    def update_buttons(self):
+        valid = True
+        for field in self.float_fields:
+            if not is_edit_valid(field):
+                valid = False
+        for btn_type in (QtWidgets.QDialogButtonBox.Ok,
+                         QtWidgets.QDialogButtonBox.Apply):
+            btn = self.bbox.button(btn_type)
+            if btn is not None:
+                btn.setEnabled(valid)
+
+    def accept(self):
+        self.data = self.formwidget.get()
+        QtWidgets.QDialog.accept(self)
+
+    def reject(self):
+        self.data = None
+        QtWidgets.QDialog.reject(self)
+
+    def apply(self):
+        self.apply_callback(self.formwidget.get())
+
+    def get(self):
+        """Return form result"""
+        return self.data
+
+
+def fedit(data, title="", comment="", icon=None, parent=None, apply=None):
+    """
+    Create form dialog and return result
+    (if Cancel button is pressed, return None)
+
+    data: datalist, datagroup
+    title: string
+    comment: string
+    icon: QIcon instance
+    parent: parent QWidget
+    apply: apply callback (function)
+
+    datalist: list/tuple of (field_name, field_value)
+    datagroup: list/tuple of (datalist *or* datagroup, title, comment)
+
+    -> one field for each member of a datalist
+    -> one tab for each member of a top-level datagroup
+    -> one page (of a multipage widget, each page can be selected with a combo
+       box) for each member of a datagroup inside a datagroup
+
+    Supported types for field_value:
+      - int, float, str, unicode, bool
+      - colors: in Qt-compatible text form, i.e. in hex format or name (red,...)
+                (automatically detected from a string)
+      - list/tuple:
+          * the first element will be the selected index (or value)
+          * the other elements can be couples (key, value) or only values
+    """
+
+    # Create a QApplication instance if no instance currently exists
+    # (e.g., if the module is used directly from the interpreter)
+    if QtWidgets.QApplication.startingUp():
+        _app = QtWidgets.QApplication([])
+    dialog = FormDialog(data, title, comment, icon, parent, apply)
+    if dialog.exec_():
+        return dialog.get()
+
+
+if __name__ == "__main__":
+
+    def create_datalist_example():
+        return [('str', 'this is a string'),
+                ('list', [0, '1', '3', '4']),
+                ('list2', ['--', ('none', 'None'), ('--', 'Dashed'),
+                           ('-.', 'DashDot'), ('-', 'Solid'),
+                           ('steps', 'Steps'), (':', 'Dotted')]),
+                ('float', 1.2),
+                (None, 'Other:'),
+                ('int', 12),
+                ('font', ('Arial', 10, False, True)),
+                ('color', '#123409'),
+                ('bool', True),
+                ('date', datetime.date(2010, 10, 10)),
+                ('datetime', datetime.datetime(2010, 10, 10)),
+                ]
+
+    def create_datagroup_example():
+        datalist = create_datalist_example()
+        return ((datalist, "Category 1", "Category 1 comment"),
+                (datalist, "Category 2", "Category 2 comment"),
+                (datalist, "Category 3", "Category 3 comment"))
+
+    #--------- datalist example
+    datalist = create_datalist_example()
+
+    def apply_test(data):
+        print("data:", data)
+    print("result:", fedit(datalist, title="Example",
+                           comment="This is just an <b>example</b>.",
+                           apply=apply_test))
+
+    #--------- datagroup example
+    datagroup = create_datagroup_example()
+    print("result:", fedit(datagroup, "Global title"))
+
+    #--------- datagroup inside a datagroup example
+    datalist = create_datalist_example()
+    datagroup = create_datagroup_example()
+    print("result:", fedit(((datagroup, "Title 1", "Tab 1 comment"),
+                            (datalist, "Title 2", "Tab 2 comment"),
+                            (datalist, "Title 3", "Tab 3 comment")),
+                            "Global title"))

utils/venv/lib/python3.6/site-packages/matplotlib/backends/qt_editor/formsubplottool.py

@@ -0,0 +1,56 @@
+from matplotlib.backends.qt_compat import QtWidgets
+
+
+class UiSubplotTool(QtWidgets.QDialog):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.setObjectName("SubplotTool")
+        self._widgets = {}
+
+        layout = QtWidgets.QHBoxLayout()
+        self.setLayout(layout)
+
+        left = QtWidgets.QVBoxLayout()
+        layout.addLayout(left)
+        right = QtWidgets.QVBoxLayout()
+        layout.addLayout(right)
+
+        box = QtWidgets.QGroupBox("Borders")
+        left.addWidget(box)
+        inner = QtWidgets.QFormLayout(box)
+        for side in ["top", "bottom", "left", "right"]:
+            self._widgets[side] = widget = QtWidgets.QDoubleSpinBox()
+            widget.setMinimum(0)
+            widget.setMaximum(1)
+            widget.setDecimals(3)
+            widget.setSingleStep(.005)
+            widget.setKeyboardTracking(False)
+            inner.addRow(side, widget)
+        left.addStretch(1)
+
+        box = QtWidgets.QGroupBox("Spacings")
+        right.addWidget(box)
+        inner = QtWidgets.QFormLayout(box)
+        for side in ["hspace", "wspace"]:
+            self._widgets[side] = widget = QtWidgets.QDoubleSpinBox()
+            widget.setMinimum(0)
+            widget.setMaximum(1)
+            widget.setDecimals(3)
+            widget.setSingleStep(.005)
+            widget.setKeyboardTracking(False)
+            inner.addRow(side, widget)
+        right.addStretch(1)
+
+        widget = QtWidgets.QPushButton("Export values")
+        self._widgets["Export values"] = widget
+        # Don't trigger on <enter>, which is used to input values.
+        widget.setAutoDefault(False)
+        left.addWidget(widget)
+
+        for action in ["Tight layout", "Reset", "Close"]:
+            self._widgets[action] = widget = QtWidgets.QPushButton(action)
+            widget.setAutoDefault(False)
+            right.addWidget(widget)
+
+        self._widgets["Close"].setFocus()

utils/venv/lib/python3.6/site-packages/matplotlib/backends/tkagg.py

@@ -0,0 +1,46 @@
+import tkinter as Tk
+
+import numpy as np
+
+from matplotlib import cbook
+from matplotlib.backends import _tkagg
+
+
+cbook.warn_deprecated(
+    "3.0", "The matplotlib.backends.tkagg module is deprecated.")
+
+
+def blit(photoimage, aggimage, bbox=None, colormode=1):
+    tk = photoimage.tk
+
+    if bbox is not None:
+        bbox_array = bbox.__array__()
+        # x1, x2, y1, y2
+        bboxptr = (bbox_array[0, 0], bbox_array[1, 0],
+                   bbox_array[0, 1], bbox_array[1, 1])
+    else:
+        bboxptr = 0
+    data = np.asarray(aggimage)
+    dataptr = (data.shape[0], data.shape[1], data.ctypes.data)
+    try:
+        tk.call(
+            "PyAggImagePhoto", photoimage,
+            dataptr, colormode, bboxptr)
+    except Tk.TclError:
+        if hasattr(tk, 'interpaddr'):
+            _tkagg.tkinit(tk.interpaddr(), 1)
+        else:
+            # very old python?
+            _tkagg.tkinit(tk, 0)
+        tk.call("PyAggImagePhoto", photoimage,
+                dataptr, colormode, bboxptr)
+
+def test(aggimage):
+    r = Tk.Tk()
+    c = Tk.Canvas(r, width=aggimage.width, height=aggimage.height)
+    c.pack()
+    p = Tk.PhotoImage(width=aggimage.width, height=aggimage.height)
+    blit(p, aggimage)
+    c.create_image(aggimage.width,aggimage.height,image=p)
+    blit(p, aggimage)
+    while True: r.update_idletasks()

utils/venv/lib/python3.6/site-packages/matplotlib/backends/web_backend/all_figures.html

@@ -0,0 +1,43 @@
+<html>
+  <head>
+    <link rel="stylesheet" href="{{ prefix }}/_static/css/page.css" type="text/css">
+    <link rel="stylesheet" href="{{ prefix }}/_static/css/boilerplate.css" type="text/css" />
+    <link rel="stylesheet" href="{{ prefix }}/_static/css/fbm.css" type="text/css" />
+    <link rel="stylesheet" href="{{ prefix }}/_static/jquery/css/themes/base/jquery-ui.min.css" >
+    <script src="{{ prefix }}/_static/jquery/js/jquery-1.11.3.min.js"></script>
+    <script src="{{ prefix }}/_static/jquery/js/jquery-ui.min.js"></script>
+    <script src="{{ prefix }}/_static/js/mpl_tornado.js"></script>
+    <script src="{{ prefix }}/js/mpl.js"></script>
+
+    <script>
+      {% for (fig_id, fig_manager) in figures %}
+        $(document).ready(
+        function() {
+          var main_div = $('div#figures');
+          var figure_div = $('<div id="figure-div"/>')
+          main_div.append(figure_div);
+          var websocket_type = mpl.get_websocket_type();
+          var websocket = new websocket_type(
+              "{{ ws_uri }}" + "{{ fig_id }}" + "/ws");
+          var fig = new mpl.figure(
+              "{{ fig_id }}", websocket, mpl_ondownload, figure_div);
+
+          fig.focus_on_mouseover = true;
+
+          $(fig.canvas).attr('tabindex', {{ fig_id }});
+          }
+        );
+
+	{% end %}
+    </script>
+
+  <title>MPL | WebAgg current figures</title>
+
+  </head>
+  <body>
+    <div id="mpl-warnings" class="mpl-warnings"></div>
+
+    <div id="figures" style="margin: 10px 10px;"></div>
+
+  </body>
+</html>

utils/venv/lib/python3.6/site-packages/matplotlib/backends/web_backend/css/boilerplate.css

@@ -0,0 +1,77 @@
+/**
+ * HTML5 ✰ Boilerplate
+ *
+ * style.css contains a reset, font normalization and some base styles.
+ *
+ * Credit is left where credit is due.
+ * Much inspiration was taken from these projects:
+ * - yui.yahooapis.com/2.8.1/build/base/base.css
+ * - camendesign.com/design/
+ * - praegnanz.de/weblog/htmlcssjs-kickstart
+ */
+
+
+/**
+ * html5doctor.com Reset Stylesheet (Eric Meyer's Reset Reloaded + HTML5 baseline)
+ * v1.6.1 2010-09-17 | Authors: Eric Meyer & Richard Clark
+ * html5doctor.com/html-5-reset-stylesheet/
+ */
+
+html, body, div, span, object, iframe,
+h1, h2, h3, h4, h5, h6, p, blockquote, pre,
+abbr, address, cite, code, del, dfn, em, img, ins, kbd, q, samp,
+small, strong, sub, sup, var, b, i, dl, dt, dd, ol, ul, li,
+fieldset, form, label, legend,
+table, caption, tbody, tfoot, thead, tr, th, td,
+article, aside, canvas, details, figcaption, figure,
+footer, header, hgroup, menu, nav, section, summary,
+time, mark, audio, video {
+  margin: 0;
+  padding: 0;
+  border: 0;
+  font-size: 100%;
+  font: inherit;
+  vertical-align: baseline;
+}
+
+sup { vertical-align: super; }
+sub { vertical-align: sub; }
+
+article, aside, details, figcaption, figure,
+footer, header, hgroup, menu, nav, section {
+  display: block;
+}
+
+blockquote, q { quotes: none; }
+
+blockquote:before, blockquote:after,
+q:before, q:after { content: ""; content: none; }
+
+ins { background-color: #ff9; color: #000; text-decoration: none; }
+
+mark { background-color: #ff9; color: #000; font-style: italic; font-weight: bold; }
+
+del { text-decoration: line-through; }
+
+abbr[title], dfn[title] { border-bottom: 1px dotted; cursor: help; }
+
+table { border-collapse: collapse; border-spacing: 0; }
+
+hr { display: block; height: 1px; border: 0; border-top: 1px solid #ccc; margin: 1em 0; padding: 0; }
+
+input, select { vertical-align: middle; }
+
+
+/**
+ * Font normalization inspired by YUI Library's fonts.css: developer.yahoo.com/yui/
+ */
+
+body { font:13px/1.231 sans-serif; *font-size:small; } /* Hack retained to preserve specificity */
+select, input, textarea, button { font:99% sans-serif; }
+
+/* Normalize monospace sizing:
+   en.wikipedia.org/wiki/MediaWiki_talk:Common.css/Archive_11#Teletype_style_fix_for_Chrome */
+pre, code, kbd, samp { font-family: monospace, sans-serif; }
+
+em,i { font-style: italic; }
+b,strong { font-weight: bold; }

utils/venv/lib/python3.6/site-packages/matplotlib/backends/web_backend/css/fbm.css

@@ -0,0 +1,97 @@
+
+/* Flexible box model classes */
+/* Taken from Alex Russell http://infrequently.org/2009/08/css-3-progress/ */
+ 
+.hbox {
+	display: -webkit-box;
+	-webkit-box-orient: horizontal;
+	-webkit-box-align: stretch;
+ 
+	display: -moz-box;
+	-moz-box-orient: horizontal;
+	-moz-box-align: stretch;
+ 
+	display: box;
+	box-orient: horizontal;
+	box-align: stretch;
+}
+ 
+.hbox > * {
+	-webkit-box-flex: 0;
+	-moz-box-flex: 0;
+	box-flex: 0;
+}
+ 
+.vbox {
+	display: -webkit-box;
+	-webkit-box-orient: vertical;
+	-webkit-box-align: stretch;
+ 
+	display: -moz-box;
+	-moz-box-orient: vertical;
+	-moz-box-align: stretch;
+ 
+	display: box;
+	box-orient: vertical;
+	box-align: stretch;
+}
+ 
+.vbox > * {
+	-webkit-box-flex: 0;
+	-moz-box-flex: 0;
+	box-flex: 0;
+}
+  
+.reverse {
+	-webkit-box-direction: reverse;
+	-moz-box-direction: reverse;
+	box-direction: reverse;
+}
+ 
+.box-flex0 {
+	-webkit-box-flex: 0;
+	-moz-box-flex: 0;
+	box-flex: 0;
+}
+ 
+.box-flex1, .box-flex {
+	-webkit-box-flex: 1;
+	-moz-box-flex: 1;
+	box-flex: 1;
+}
+ 
+.box-flex2 {
+	-webkit-box-flex: 2;
+	-moz-box-flex: 2;
+	box-flex: 2;
+}
+ 
+.box-group1 {
+	-webkit-box-flex-group: 1;
+	-moz-box-flex-group: 1;
+	box-flex-group: 1;
+}
+ 
+.box-group2 {
+	-webkit-box-flex-group: 2;
+	-moz-box-flex-group: 2;
+	box-flex-group: 2;
+}
+ 
+.start {
+	-webkit-box-pack: start;
+	-moz-box-pack: start;
+	box-pack: start;
+}
+ 
+.end {
+	-webkit-box-pack: end;
+	-moz-box-pack: end;
+	box-pack: end;
+}
+ 
+.center {
+	-webkit-box-pack: center;
+	-moz-box-pack: center;
+	box-pack: center;
+}

utils/venv/lib/python3.6/site-packages/matplotlib/backends/web_backend/css/page.css

@@ -0,0 +1,82 @@
+/**
+ * Primary styles
+ *
+ * Author: IPython Development Team
+ */
+
+
+body {
+    background-color: white;
+    /* This makes sure that the body covers the entire window and needs to
+       be in a different element than the display: box in wrapper below */
+    position: absolute;
+    left: 0px;
+    right: 0px;
+    top: 0px;
+    bottom: 0px;
+    overflow: visible;
+}
+
+
+div#header {
+    /* Initially hidden to prevent FLOUC */
+    display: none;
+    position: relative;
+    height: 40px;
+    padding: 5px;
+    margin: 0px;
+    width: 100%;
+}
+
+span#ipython_notebook {
+    position: absolute;
+    padding: 2px 2px 2px 5px;
+}
+
+span#ipython_notebook img {
+    font-family: Verdana, "Helvetica Neue", Arial, Helvetica, Geneva, sans-serif;
+    height: 24px;
+    text-decoration:none;
+    display: inline;
+    color: black;
+}
+
+#site {
+    width: 100%;
+    display: none;
+}
+
+/* We set the fonts by hand here to override the values in the theme */
+.ui-widget {
+    font-family: "Lucinda Grande", "Lucinda Sans Unicode", Helvetica, Arial, Verdana, sans-serif;
+}
+
+.ui-widget input, .ui-widget select, .ui-widget textarea, .ui-widget button {
+    font-family: "Lucinda Grande", "Lucinda Sans Unicode", Helvetica, Arial, Verdana, sans-serif;
+}
+
+/* Smaller buttons */
+.ui-button .ui-button-text {
+    padding: 0.2em 0.8em;
+    font-size: 77%;
+}
+
+input.ui-button {
+    padding: 0.3em 0.9em;
+}
+
+span#login_widget {
+    float: right;
+}
+
+.border-box-sizing {
+    box-sizing: border-box;
+    -moz-box-sizing: border-box;
+    -webkit-box-sizing: border-box;
+}
+
+#figure-div {
+    display: inline-block;
+    margin: 10px;
+}
+

utils/venv/lib/python3.6/site-packages/matplotlib/backends/web_backend/ipython_inline_figure.html

@@ -0,0 +1,34 @@
+<!-- Within the kernel, we don't know the address of the matplotlib
+     websocket server, so we have to get in client-side and fetch our
+     resources that way. -->
+<script>
+  // We can't proceed until these Javascript files are fetched, so
+  // we fetch them synchronously
+  $.ajaxSetup({async: false});
+  $.getScript("http://" + window.location.hostname + ":{{ port }}{{prefix}}/_static/js/mpl_tornado.js");
+  $.getScript("http://" + window.location.hostname + ":{{ port }}{{prefix}}/js/mpl.js");
+  $.ajaxSetup({async: true});
+
+  function init_figure{{ fig_id }}(e) {
+    $('div.output').off('resize');
+
+    var output_div = $(e.target).find('div.output_subarea');
+    var websocket_type = mpl.get_websocket_type();
+    var websocket = new websocket_type(
+        "ws://" + window.location.hostname + ":{{ port }}{{ prefix}}/" +
+        {{ repr(str(fig_id)) }} + "/ws");
+
+    var fig = new mpl.figure(
+        {{repr(str(fig_id))}}, websocket, mpl_ondownload, output_div);
+
+    // Fetch the first image
+    fig.context.drawImage(fig.imageObj, 0, 0);
+
+    fig.focus_on_mouseover = true;
+  }
+
+  // We can't initialize the figure contents until our content
+  // has been added to the DOM.  This is a bit of hack to get an
+  // event for that.
+  $('div.output').resize(init_figure{{ fig_id }});
+</script>

utils/venv/lib/python3.6/site-packages/matplotlib/backends/web_backend/js/mpl.js

@@ -0,0 +1,554 @@
+/* Put everything inside the global mpl namespace */
+window.mpl = {};
+
+
+mpl.get_websocket_type = function() {
+    if (typeof(WebSocket) !== 'undefined') {
+        return WebSocket;
+    } else if (typeof(MozWebSocket) !== 'undefined') {
+        return MozWebSocket;
+    } else {
+        alert('Your browser does not have WebSocket support.' +
+              'Please try Chrome, Safari or Firefox ≥ 6. ' +
+              'Firefox 4 and 5 are also supported but you ' +
+              'have to enable WebSockets in about:config.');
+    };
+}
+
+mpl.figure = function(figure_id, websocket, ondownload, parent_element) {
+    this.id = figure_id;
+
+    this.ws = websocket;
+
+    this.supports_binary = (this.ws.binaryType != undefined);
+
+    if (!this.supports_binary) {
+        var warnings = document.getElementById("mpl-warnings");
+        if (warnings) {
+            warnings.style.display = 'block';
+            warnings.textContent = (
+                "This browser does not support binary websocket messages. " +
+                    "Performance may be slow.");
+        }
+    }
+
+    this.imageObj = new Image();
+
+    this.context = undefined;
+    this.message = undefined;
+    this.canvas = undefined;
+    this.rubberband_canvas = undefined;
+    this.rubberband_context = undefined;
+    this.format_dropdown = undefined;
+
+    this.image_mode = 'full';
+
+    this.root = $('<div/>');
+    this._root_extra_style(this.root)
+    this.root.attr('style', 'display: inline-block');
+
+    $(parent_element).append(this.root);
+
+    this._init_header(this);
+    this._init_canvas(this);
+    this._init_toolbar(this);
+
+    var fig = this;
+
+    this.waiting = false;
+
+    this.ws.onopen =  function () {
+            fig.send_message("supports_binary", {value: fig.supports_binary});
+            fig.send_message("send_image_mode", {});
+            if (mpl.ratio != 1) {
+                fig.send_message("set_dpi_ratio", {'dpi_ratio': mpl.ratio});
+            }
+            fig.send_message("refresh", {});
+        }
+
+    this.imageObj.onload = function() {
+            if (fig.image_mode == 'full') {
+                // Full images could contain transparency (where diff images
+                // almost always do), so we need to clear the canvas so that
+                // there is no ghosting.
+                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);
+            }
+            fig.context.drawImage(fig.imageObj, 0, 0);
+        };
+
+    this.imageObj.onunload = function() {
+        fig.ws.close();
+    }
+
+    this.ws.onmessage = this._make_on_message_function(this);
+
+    this.ondownload = ondownload;
+}
+
+mpl.figure.prototype._init_header = function() {
+    var titlebar = $(
+        '<div class="ui-dialog-titlebar ui-widget-header ui-corner-all ' +
+        'ui-helper-clearfix"/>');
+    var titletext = $(
+        '<div class="ui-dialog-title" style="width: 100%; ' +
+        'text-align: center; padding: 3px;"/>');
+    titlebar.append(titletext)
+    this.root.append(titlebar);
+    this.header = titletext[0];
+}
+
+
+
+mpl.figure.prototype._canvas_extra_style = function(canvas_div) {
+
+}
+
+
+mpl.figure.prototype._root_extra_style = function(canvas_div) {
+
+}
+
+mpl.figure.prototype._init_canvas = function() {
+    var fig = this;
+
+    var canvas_div = $('<div/>');
+
+    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');
+
+    function canvas_keyboard_event(event) {
+        return fig.key_event(event, event['data']);
+    }
+
+    canvas_div.keydown('key_press', canvas_keyboard_event);
+    canvas_div.keyup('key_release', canvas_keyboard_event);
+    this.canvas_div = canvas_div
+    this._canvas_extra_style(canvas_div)
+    this.root.append(canvas_div);
+
+    var canvas = $('<canvas/>');
+    canvas.addClass('mpl-canvas');
+    canvas.attr('style', "left: 0; top: 0; z-index: 0; outline: 0")
+
+    this.canvas = canvas[0];
+    this.context = canvas[0].getContext("2d");
+
+    var backingStore = this.context.backingStorePixelRatio ||
+	this.context.webkitBackingStorePixelRatio ||
+	this.context.mozBackingStorePixelRatio ||
+	this.context.msBackingStorePixelRatio ||
+	this.context.oBackingStorePixelRatio ||
+	this.context.backingStorePixelRatio || 1;
+
+    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;
+
+    var rubberband = $('<canvas/>');
+    rubberband.attr('style', "position: absolute; left: 0; top: 0; z-index: 1;")
+
+    var pass_mouse_events = true;
+
+    canvas_div.resizable({
+        start: function(event, ui) {
+            pass_mouse_events = false;
+        },
+        resize: function(event, ui) {
+            fig.request_resize(ui.size.width, ui.size.height);
+        },
+        stop: function(event, ui) {
+            pass_mouse_events = true;
+            fig.request_resize(ui.size.width, ui.size.height);
+        },
+    });
+
+    function mouse_event_fn(event) {
+        if (pass_mouse_events)
+            return fig.mouse_event(event, event['data']);
+    }
+
+    rubberband.mousedown('button_press', mouse_event_fn);
+    rubberband.mouseup('button_release', mouse_event_fn);
+    // Throttle sequential mouse events to 1 every 20ms.
+    rubberband.mousemove('motion_notify', mouse_event_fn);
+
+    rubberband.mouseenter('figure_enter', mouse_event_fn);
+    rubberband.mouseleave('figure_leave', mouse_event_fn);
+
+    canvas_div.on("wheel", function (event) {
+        event = event.originalEvent;
+        event['data'] = 'scroll'
+        if (event.deltaY < 0) {
+            event.step = 1;
+        } else {
+            event.step = -1;
+        }
+        mouse_event_fn(event);
+    });
+
+    canvas_div.append(canvas);
+    canvas_div.append(rubberband);
+
+    this.rubberband = rubberband;
+    this.rubberband_canvas = rubberband[0];
+    this.rubberband_context = rubberband[0].getContext("2d");
+    this.rubberband_context.strokeStyle = "#000000";
+
+    this._resize_canvas = function(width, height) {
+        // Keep the size of the canvas, canvas container, and rubber band
+        // canvas in synch.
+        canvas_div.css('width', width)
+        canvas_div.css('height', height)
+
+        canvas.attr('width', width * mpl.ratio);
+        canvas.attr('height', height * mpl.ratio);
+        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');
+
+        rubberband.attr('width', width);
+        rubberband.attr('height', height);
+    }
+
+    // Set the figure to an initial 600x600px, this will subsequently be updated
+    // upon first draw.
+    this._resize_canvas(600, 600);
+
+    // Disable right mouse context menu.
+    $(this.rubberband_canvas).bind("contextmenu",function(e){
+        return false;
+    });
+
+    function set_focus () {
+        canvas.focus();
+        canvas_div.focus();
+    }
+
+    window.setTimeout(set_focus, 100);
+}
+
+mpl.figure.prototype._init_toolbar = function() {
+    var fig = this;
+
+    var nav_element = $('<div/>')
+    nav_element.attr('style', 'width: 100%');
+    this.root.append(nav_element);
+
+    // Define a callback function for later on.
+    function toolbar_event(event) {
+        return fig.toolbar_button_onclick(event['data']);
+    }
+    function toolbar_mouse_event(event) {
+        return fig.toolbar_button_onmouseover(event['data']);
+    }
+
+    for(var toolbar_ind in mpl.toolbar_items) {
+        var name = mpl.toolbar_items[toolbar_ind][0];
+        var tooltip = mpl.toolbar_items[toolbar_ind][1];
+        var image = mpl.toolbar_items[toolbar_ind][2];
+        var method_name = mpl.toolbar_items[toolbar_ind][3];
+
+        if (!name) {
+            // put a spacer in here.
+            continue;
+        }
+        var button = $('<button/>');
+        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +
+                        'ui-button-icon-only');
+        button.attr('role', 'button');
+        button.attr('aria-disabled', 'false');
+        button.click(method_name, toolbar_event);
+        button.mouseover(tooltip, toolbar_mouse_event);
+
+        var icon_img = $('<span/>');
+        icon_img.addClass('ui-button-icon-primary ui-icon');
+        icon_img.addClass(image);
+        icon_img.addClass('ui-corner-all');
+
+        var tooltip_span = $('<span/>');
+        tooltip_span.addClass('ui-button-text');
+        tooltip_span.html(tooltip);
+
+        button.append(icon_img);
+        button.append(tooltip_span);
+
+        nav_element.append(button);
+    }
+
+    var fmt_picker_span = $('<span/>');
+
+    var fmt_picker = $('<select/>');
+    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');
+    fmt_picker_span.append(fmt_picker);
+    nav_element.append(fmt_picker_span);
+    this.format_dropdown = fmt_picker[0];
+
+    for (var ind in mpl.extensions) {
+        var fmt = mpl.extensions[ind];
+        var option = $(
+            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);
+        fmt_picker.append(option)
+    }
+
+    // Add hover states to the ui-buttons
+    $( ".ui-button" ).hover(
+        function() { $(this).addClass("ui-state-hover");},
+        function() { $(this).removeClass("ui-state-hover");}
+    );
+
+    var status_bar = $('<span class="mpl-message"/>');
+    nav_element.append(status_bar);
+    this.message = status_bar[0];
+}
+
+mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {
+    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,
+    // which will in turn request a refresh of the image.
+    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});
+}
+
+mpl.figure.prototype.send_message = function(type, properties) {
+    properties['type'] = type;
+    properties['figure_id'] = this.id;
+    this.ws.send(JSON.stringify(properties));
+}
+
+mpl.figure.prototype.send_draw_message = function() {
+    if (!this.waiting) {
+        this.waiting = true;
+        this.ws.send(JSON.stringify({type: "draw", figure_id: this.id}));
+    }
+}
+
+
+mpl.figure.prototype.handle_save = function(fig, msg) {
+    var format_dropdown = fig.format_dropdown;
+    var format = format_dropdown.options[format_dropdown.selectedIndex].value;
+    fig.ondownload(fig, format);
+}
+
+
+mpl.figure.prototype.handle_resize = function(fig, msg) {
+    var size = msg['size'];
+    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {
+        fig._resize_canvas(size[0], size[1]);
+        fig.send_message("refresh", {});
+    };
+}
+
+mpl.figure.prototype.handle_rubberband = function(fig, msg) {
+    var x0 = msg['x0'] / mpl.ratio;
+    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;
+    var x1 = msg['x1'] / mpl.ratio;
+    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;
+    x0 = Math.floor(x0) + 0.5;
+    y0 = Math.floor(y0) + 0.5;
+    x1 = Math.floor(x1) + 0.5;
+    y1 = Math.floor(y1) + 0.5;
+    var min_x = Math.min(x0, x1);
+    var min_y = Math.min(y0, y1);
+    var width = Math.abs(x1 - x0);
+    var height = Math.abs(y1 - y0);
+
+    fig.rubberband_context.clearRect(
+        0, 0, fig.canvas.width, fig.canvas.height);
+
+    fig.rubberband_context.strokeRect(min_x, min_y, width, height);
+}
+
+mpl.figure.prototype.handle_figure_label = function(fig, msg) {
+    // Updates the figure title.
+    fig.header.textContent = msg['label'];
+}
+
+mpl.figure.prototype.handle_cursor = function(fig, msg) {
+    var cursor = msg['cursor'];
+    switch(cursor)
+    {
+    case 0:
+        cursor = 'pointer';
+        break;
+    case 1:
+        cursor = 'default';
+        break;
+    case 2:
+        cursor = 'crosshair';
+        break;
+    case 3:
+        cursor = 'move';
+        break;
+    }
+    fig.rubberband_canvas.style.cursor = cursor;
+}
+
+mpl.figure.prototype.handle_message = function(fig, msg) {
+    fig.message.textContent = msg['message'];
+}
+
+mpl.figure.prototype.handle_draw = function(fig, msg) {
+    // Request the server to send over a new figure.
+    fig.send_draw_message();
+}
+
+mpl.figure.prototype.handle_image_mode = function(fig, msg) {
+    fig.image_mode = msg['mode'];
+}
+
+mpl.figure.prototype.updated_canvas_event = function() {
+    // Called whenever the canvas gets updated.
+    this.send_message("ack", {});
+}
+
+// A function to construct a web socket function for onmessage handling.
+// Called in the figure constructor.
+mpl.figure.prototype._make_on_message_function = function(fig) {
+    return function socket_on_message(evt) {
+        if (evt.data instanceof Blob) {
+            /* FIXME: We get "Resource interpreted as Image but
+             * transferred with MIME type text/plain:" errors on
+             * Chrome.  But how to set the MIME type?  It doesn't seem
+             * to be part of the websocket stream */
+            evt.data.type = "image/png";
+
+            /* Free the memory for the previous frames */
+            if (fig.imageObj.src) {
+                (window.URL || window.webkitURL).revokeObjectURL(
+                    fig.imageObj.src);
+            }
+
+            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(
+                evt.data);
+            fig.updated_canvas_event();
+            fig.waiting = false;
+            return;
+        }
+        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == "data:image/png;base64") {
+            fig.imageObj.src = evt.data;
+            fig.updated_canvas_event();
+            fig.waiting = false;
+            return;
+        }
+
+        var msg = JSON.parse(evt.data);
+        var msg_type = msg['type'];
+
+        // Call the  "handle_{type}" callback, which takes
+        // the figure and JSON message as its only arguments.
+        try {
+            var callback = fig["handle_" + msg_type];
+        } catch (e) {
+            console.log("No handler for the '" + msg_type + "' message type: ", msg);
+            return;
+        }
+
+        if (callback) {
+            try {
+                // console.log("Handling '" + msg_type + "' message: ", msg);
+                callback(fig, msg);
+            } catch (e) {
+                console.log("Exception inside the 'handler_" + msg_type + "' callback:", e, e.stack, msg);
+            }
+        }
+    };
+}
+
+// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas
+mpl.findpos = function(e) {
+    //this section is from http://www.quirksmode.org/js/events_properties.html
+    var targ;
+    if (!e)
+        e = window.event;
+    if (e.target)
+        targ = e.target;
+    else if (e.srcElement)
+        targ = e.srcElement;
+    if (targ.nodeType == 3) // defeat Safari bug
+        targ = targ.parentNode;
+
+    // jQuery normalizes the pageX and pageY
+    // pageX,Y are the mouse positions relative to the document
+    // offset() returns the position of the element relative to the document
+    var x = e.pageX - $(targ).offset().left;
+    var y = e.pageY - $(targ).offset().top;
+
+    return {"x": x, "y": y};
+};
+
+/*
+ * return a copy of an object with only non-object keys
+ * we need this to avoid circular references
+ * http://stackoverflow.com/a/24161582/3208463
+ */
+function simpleKeys (original) {
+  return Object.keys(original).reduce(function (obj, key) {
+    if (typeof original[key] !== 'object')
+        obj[key] = original[key]
+    return obj;
+  }, {});
+}
+
+mpl.figure.prototype.mouse_event = function(event, name) {
+    var canvas_pos = mpl.findpos(event)
+
+    if (name === 'button_press')
+    {
+        this.canvas.focus();
+        this.canvas_div.focus();
+    }
+
+    var x = canvas_pos.x * mpl.ratio;
+    var y = canvas_pos.y * mpl.ratio;
+
+    this.send_message(name, {x: x, y: y, button: event.button,
+                             step: event.step,
+                             guiEvent: simpleKeys(event)});
+
+    /* This prevents the web browser from automatically changing to
+     * the text insertion cursor when the button is pressed.  We want
+     * to control all of the cursor setting manually through the
+     * 'cursor' event from matplotlib */
+    event.preventDefault();
+    return false;
+}
+
+mpl.figure.prototype._key_event_extra = function(event, name) {
+    // Handle any extra behaviour associated with a key event
+}
+
+mpl.figure.prototype.key_event = function(event, name) {
+
+    // Prevent repeat events
+    if (name == 'key_press')
+    {
+        if (event.which === this._key)
+            return;
+        else
+            this._key = event.which;
+    }
+    if (name == 'key_release')
+        this._key = null;
+
+    var value = '';
+    if (event.ctrlKey && event.which != 17)
+        value += "ctrl+";
+    if (event.altKey && event.which != 18)
+        value += "alt+";
+    if (event.shiftKey && event.which != 16)
+        value += "shift+";
+
+    value += 'k';
+    value += event.which.toString();
+
+    this._key_event_extra(event, name);
+
+    this.send_message(name, {key: value,
+                             guiEvent: simpleKeys(event)});
+    return false;
+}
+
+mpl.figure.prototype.toolbar_button_onclick = function(name) {
+    if (name == 'download') {
+        this.handle_save(this, null);
+    } else {
+        this.send_message("toolbar_button", {name: name});
+    }
+};
+
+mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {
+    this.message.textContent = tooltip;
+};

utils/venv/lib/python3.6/site-packages/matplotlib/backends/web_backend/js/mpl_tornado.js

@@ -0,0 +1,7 @@
+/* This .js file contains functions for matplotlib's built-in
+   tornado-based server, that are not relevant when embedding WebAgg
+   in another web application. */
+
+function mpl_ondownload(figure, format) {
+    window.open(figure.id + '/download.' + format, '_blank');
+}

utils/venv/lib/python3.6/site-packages/matplotlib/backends/web_backend/js/nbagg_mpl.js

@@ -0,0 +1,211 @@
+var comm_websocket_adapter = function(comm) {
+    // Create a "websocket"-like object which calls the given IPython comm
+    // object with the appropriate methods. Currently this is a non binary
+    // socket, so there is still some room for performance tuning.
+    var ws = {};
+
+    ws.close = function() {
+        comm.close()
+    };
+    ws.send = function(m) {
+        //console.log('sending', m);
+        comm.send(m);
+    };
+    // Register the callback with on_msg.
+    comm.on_msg(function(msg) {
+        //console.log('receiving', msg['content']['data'], msg);
+        // Pass the mpl event to the overridden (by mpl) onmessage function.
+        ws.onmessage(msg['content']['data'])
+    });
+    return ws;
+}
+
+mpl.mpl_figure_comm = function(comm, msg) {
+    // This is the function which gets called when the mpl process
+    // starts-up an IPython Comm through the "matplotlib" channel.
+
+    var id = msg.content.data.id;
+    // Get hold of the div created by the display call when the Comm
+    // socket was opened in Python.
+    var element = $("#" + id);
+    var ws_proxy = comm_websocket_adapter(comm)
+
+    function ondownload(figure, format) {
+        window.open(figure.imageObj.src);
+    }
+
+    var fig = new mpl.figure(id, ws_proxy,
+                           ondownload,
+                           element.get(0));
+
+    // Call onopen now - mpl needs it, as it is assuming we've passed it a real
+    // web socket which is closed, not our websocket->open comm proxy.
+    ws_proxy.onopen();
+
+    fig.parent_element = element.get(0);
+    fig.cell_info = mpl.find_output_cell("<div id='" + id + "'></div>");
+    if (!fig.cell_info) {
+        console.error("Failed to find cell for figure", id, fig);
+        return;
+    }
+
+    var output_index = fig.cell_info[2]
+    var cell = fig.cell_info[0];
+
+};
+
+mpl.figure.prototype.handle_close = function(fig, msg) {
+    var width = fig.canvas.width/mpl.ratio
+    fig.root.unbind('remove')
+
+    // Update the output cell to use the data from the current canvas.
+    fig.push_to_output();
+    var dataURL = fig.canvas.toDataURL();
+    // Re-enable the keyboard manager in IPython - without this line, in FF,
+    // the notebook keyboard shortcuts fail.
+    IPython.keyboard_manager.enable()
+    $(fig.parent_element).html('<img src="' + dataURL + '" width="' + width + '">');
+    fig.close_ws(fig, msg);
+}
+
+mpl.figure.prototype.close_ws = function(fig, msg){
+    fig.send_message('closing', msg);
+    // fig.ws.close()
+}
+
+mpl.figure.prototype.push_to_output = function(remove_interactive) {
+    // Turn the data on the canvas into data in the output cell.
+    var width = this.canvas.width/mpl.ratio
+    var dataURL = this.canvas.toDataURL();
+    this.cell_info[1]['text/html'] = '<img src="' + dataURL + '" width="' + width + '">';
+}
+
+mpl.figure.prototype.updated_canvas_event = function() {
+    // Tell IPython that the notebook contents must change.
+    IPython.notebook.set_dirty(true);
+    this.send_message("ack", {});
+    var fig = this;
+    // Wait a second, then push the new image to the DOM so
+    // that it is saved nicely (might be nice to debounce this).
+    setTimeout(function () { fig.push_to_output() }, 1000);
+}
+
+mpl.figure.prototype._init_toolbar = function() {
+    var fig = this;
+
+    var nav_element = $('<div/>')
+    nav_element.attr('style', 'width: 100%');
+    this.root.append(nav_element);
+
+    // Define a callback function for later on.
+    function toolbar_event(event) {
+        return fig.toolbar_button_onclick(event['data']);
+    }
+    function toolbar_mouse_event(event) {
+        return fig.toolbar_button_onmouseover(event['data']);
+    }
+
+    for(var toolbar_ind in mpl.toolbar_items){
+        var name = mpl.toolbar_items[toolbar_ind][0];
+        var tooltip = mpl.toolbar_items[toolbar_ind][1];
+        var image = mpl.toolbar_items[toolbar_ind][2];
+        var method_name = mpl.toolbar_items[toolbar_ind][3];
+
+        if (!name) { continue; };
+
+        var button = $('<button class="btn btn-default" href="#" title="' + name + '"><i class="fa ' + image + ' fa-lg"></i></button>');
+        button.click(method_name, toolbar_event);
+        button.mouseover(tooltip, toolbar_mouse_event);
+        nav_element.append(button);
+    }
+
+    // Add the status bar.
+    var status_bar = $('<span class="mpl-message" style="text-align:right; float: right;"/>');
+    nav_element.append(status_bar);
+    this.message = status_bar[0];
+
+    // Add the close button to the window.
+    var buttongrp = $('<div class="btn-group inline pull-right"></div>');
+    var button = $('<button class="btn btn-mini btn-primary" href="#" title="Stop Interaction"><i class="fa fa-power-off icon-remove icon-large"></i></button>');
+    button.click(function (evt) { fig.handle_close(fig, {}); } );
+    button.mouseover('Stop Interaction', toolbar_mouse_event);
+    buttongrp.append(button);
+    var titlebar = this.root.find($('.ui-dialog-titlebar'));
+    titlebar.prepend(buttongrp);
+}
+
+mpl.figure.prototype._root_extra_style = function(el){
+    var fig = this
+    el.on("remove", function(){
+	fig.close_ws(fig, {});
+    });
+}
+
+mpl.figure.prototype._canvas_extra_style = function(el){
+    // this is important to make the div 'focusable
+    el.attr('tabindex', 0)
+    // reach out to IPython and tell the keyboard manager to turn it's self
+    // off when our div gets focus
+
+    // location in version 3
+    if (IPython.notebook.keyboard_manager) {
+        IPython.notebook.keyboard_manager.register_events(el);
+    }
+    else {
+        // location in version 2
+        IPython.keyboard_manager.register_events(el);
+    }
+
+}
+
+mpl.figure.prototype._key_event_extra = function(event, name) {
+    var manager = IPython.notebook.keyboard_manager;
+    if (!manager)
+        manager = IPython.keyboard_manager;
+
+    // Check for shift+enter
+    if (event.shiftKey && event.which == 13) {
+        this.canvas_div.blur();
+        event.shiftKey = false;
+        // Send a "J" for go to next cell
+        event.which = 74;
+        event.keyCode = 74;
+        manager.command_mode();
+        manager.handle_keydown(event);
+    }
+}
+
+mpl.figure.prototype.handle_save = function(fig, msg) {
+    fig.ondownload(fig, null);
+}
+
+
+mpl.find_output_cell = function(html_output) {
+    // Return the cell and output element which can be found *uniquely* in the notebook.
+    // Note - this is a bit hacky, but it is done because the "notebook_saving.Notebook"
+    // IPython event is triggered only after the cells have been serialised, which for
+    // our purposes (turning an active figure into a static one), is too late.
+    var cells = IPython.notebook.get_cells();
+    var ncells = cells.length;
+    for (var i=0; i<ncells; i++) {
+        var cell = cells[i];
+        if (cell.cell_type === 'code'){
+            for (var j=0; j<cell.output_area.outputs.length; j++) {
+                var data = cell.output_area.outputs[j];
+                if (data.data) {
+                    // IPython >= 3 moved mimebundle to data attribute of output
+                    data = data.data;
+                }
+                if (data['text/html'] == html_output) {
+                    return [cell, data, j];
+                }
+            }
+        }
+    }
+}
+
+// Register the function which deals with the matplotlib target/channel.
+// The kernel may be null if the page has been refreshed.
+if (IPython.notebook.kernel != null) {
+    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);
+}

utils/venv/lib/python3.6/site-packages/matplotlib/backends/web_backend/nbagg_uat.ipynb

@@ -0,0 +1,639 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "from imp import reload"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## UAT for NbAgg backend.\n",
+    "\n",
+    "The first line simply reloads matplotlib, uses the nbagg backend and then reloads the backend, just to ensure we have the latest modification to the backend code. Note: The underlying JavaScript will not be updated by this process, so a refresh of the browser after clearing the output and saving is necessary to clear everything fully."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "import matplotlib\n",
+    "reload(matplotlib)\n",
+    "\n",
+    "matplotlib.use('nbagg')\n",
+    "\n",
+    "import matplotlib.backends.backend_nbagg\n",
+    "reload(matplotlib.backends.backend_nbagg)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### UAT 1 - Simple figure creation using pyplot\n",
+    "\n",
+    "Should produce a figure window which is interactive with the pan and zoom buttons. (Do not press the close button, but any others may be used)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "import matplotlib.backends.backend_webagg_core\n",
+    "reload(matplotlib.backends.backend_webagg_core)\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "plt.interactive(False)\n",
+    "\n",
+    "fig1 = plt.figure()\n",
+    "plt.plot(range(10))\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### UAT 2 - Creation of another figure, without the need to do plt.figure.\n",
+    "\n",
+    "As above, a new figure should be created."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "plt.plot([3, 2, 1])\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### UAT 3 - Connection info\n",
+    "\n",
+    "The printout should show that there are two figures which have active CommSockets, and no figures pending show."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "print(matplotlib.backends.backend_nbagg.connection_info())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### UAT 4 - Closing figures\n",
+    "\n",
+    "Closing a specific figure instance should turn the figure into a plain image - the UI should have been removed. In this case, scroll back to the first figure and assert this is the case."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "plt.close(fig1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### UAT 5 - No show without plt.show in non-interactive mode\n",
+    "\n",
+    "Simply doing a plt.plot should not show a new figure, nor indeed update an existing one (easily verified in UAT 6).\n",
+    "The output should simply be a list of Line2D instances."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "plt.plot(range(10))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### UAT 6 - Connection information\n",
+    "\n",
+    "We just created a new figure, but didn't show it. Connection info should no longer have \"Figure 1\" (as we closed it in UAT 4) and should have figure 2 and 3, with Figure 3 without any connections. There should be 1 figure pending."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "print(matplotlib.backends.backend_nbagg.connection_info())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### UAT 7 - Show of previously created figure\n",
+    "\n",
+    "We should be able to show a figure we've previously created. The following should produce two figure windows."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "plt.show()\n",
+    "plt.figure()\n",
+    "plt.plot(range(5))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### UAT 8 - Interactive mode\n",
+    "\n",
+    "In interactive mode, creating a line should result in a figure being shown."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "plt.interactive(True)\n",
+    "plt.figure()\n",
+    "plt.plot([3, 2, 1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Subsequent lines should be added to the existing figure, rather than creating a new one."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "plt.plot(range(3))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Calling connection_info in interactive mode should not show any pending figures."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "print(matplotlib.backends.backend_nbagg.connection_info())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Disable interactive mode again."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "plt.interactive(False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### UAT 9 - Multiple shows\n",
+    "\n",
+    "Unlike most of the other matplotlib backends, we may want to see a figure multiple times (with or without synchronisation between the views, though the former is not yet implemented). Assert that plt.gcf().canvas.manager.reshow() results in another figure window which is synchronised upon pan & zoom."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "plt.gcf().canvas.manager.reshow()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### UAT 10 - Saving notebook\n",
+    "\n",
+    "Saving the notebook (with CTRL+S or File->Save) should result in the saved notebook having static versions of the figues embedded within. The image should be the last update from user interaction and interactive plotting. (check by converting with ``ipython nbconvert <notebook>``)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### UAT 11 - Creation of a new figure on second show\n",
+    "\n",
+    "Create a figure, show it, then create a new axes and show it. The result should be a new figure.\n",
+    "\n",
+    "**BUG: Sometimes this doesn't work - not sure why (@pelson).**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "fig = plt.figure()\n",
+    "plt.axes()\n",
+    "plt.show()\n",
+    "\n",
+    "plt.plot([1, 2, 3])\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### UAT 12 - OO interface\n",
+    "\n",
+    "Should produce a new figure and plot it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "from matplotlib.backends.backend_nbagg import new_figure_manager,show\n",
+    "\n",
+    "manager = new_figure_manager(1000)\n",
+    "fig = manager.canvas.figure\n",
+    "ax = fig.add_subplot(1,1,1)\n",
+    "ax.plot([1,2,3])\n",
+    "fig.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## UAT 13 - Animation\n",
+    "\n",
+    "The following should generate an animated line:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "import matplotlib.animation as animation\n",
+    "import numpy as np\n",
+    "\n",
+    "fig, ax = plt.subplots()\n",
+    "\n",
+    "x = np.arange(0, 2*np.pi, 0.01)        # x-array\n",
+    "line, = ax.plot(x, np.sin(x))\n",
+    "\n",
+    "def animate(i):\n",
+    "    line.set_ydata(np.sin(x+i/10.0))  # update the data\n",
+    "    return line,\n",
+    "\n",
+    "#Init only required for blitting to give a clean slate.\n",
+    "def init():\n",
+    "    line.set_ydata(np.ma.array(x, mask=True))\n",
+    "    return line,\n",
+    "\n",
+    "ani = animation.FuncAnimation(fig, animate, np.arange(1, 200), init_func=init,\n",
+    "                              interval=32., blit=True)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### UAT 14 - Keyboard shortcuts in IPython after close of figure\n",
+    "\n",
+    "After closing the previous figure (with the close button above the figure) the IPython keyboard shortcuts should still function.\n",
+    "\n",
+    "### UAT 15 - Figure face colours\n",
+    "\n",
+    "The nbagg honours all colours apart from that of the figure.patch. The two plots below should produce a figure with a red background. There should be no yellow figure."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "import matplotlib\n",
+    "matplotlib.rcParams.update({'figure.facecolor': 'red',\n",
+    "                            'savefig.facecolor': 'yellow'})\n",
+    "plt.figure()\n",
+    "plt.plot([3, 2, 1])\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### UAT 16 - Events\n",
+    "\n",
+    "Pressing any keyboard key or mouse button (or scrolling) should cycle the line line while the figure has focus.  The figure should have focus by default when it is created and re-gain it by clicking on the canvas.  Clicking anywhere outside of the figure should release focus, but moving the mouse out of the figure should not release focus."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "import itertools\n",
+    "fig, ax = plt.subplots()\n",
+    "x = np.linspace(0,10,10000)\n",
+    "y = np.sin(x)\n",
+    "ln, = ax.plot(x,y)\n",
+    "evt = []\n",
+    "colors = iter(itertools.cycle(['r', 'g', 'b', 'k', 'c']))\n",
+    "def on_event(event):\n",
+    "    if event.name.startswith('key'):\n",
+    "        fig.suptitle('%s: %s' % (event.name, event.key))\n",
+    "    elif event.name == 'scroll_event':\n",
+    "        fig.suptitle('%s: %s' % (event.name, event.step))\n",
+    "    else:\n",
+    "        fig.suptitle('%s: %s' % (event.name, event.button))\n",
+    "    evt.append(event)\n",
+    "    ln.set_color(next(colors))\n",
+    "    fig.canvas.draw()\n",
+    "    fig.canvas.draw_idle()\n",
+    "\n",
+    "fig.canvas.mpl_connect('button_press_event', on_event)\n",
+    "fig.canvas.mpl_connect('button_release_event', on_event)\n",
+    "fig.canvas.mpl_connect('scroll_event', on_event)\n",
+    "fig.canvas.mpl_connect('key_press_event', on_event)\n",
+    "fig.canvas.mpl_connect('key_release_event', on_event)\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### UAT 17 - Timers\n",
+    "\n",
+    "Single-shot timers follow a completely different code path in the nbagg backend than regular timers (such as those used in the animation example above.)  The next set of tests ensures that both \"regular\" and \"single-shot\" timers work properly.\n",
+    "\n",
+    "The following should show a simple clock that updates twice a second:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "import time\n",
+    "\n",
+    "fig, ax = plt.subplots()\n",
+    "text = ax.text(0.5, 0.5, '', ha='center')\n",
+    "\n",
+    "def update(text):\n",
+    "    text.set(text=time.ctime())\n",
+    "    text.axes.figure.canvas.draw()\n",
+    "    \n",
+    "timer = fig.canvas.new_timer(500, [(update, [text], {})])\n",
+    "timer.start()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "However, the following should only update once and then stop:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "text = ax.text(0.5, 0.5, '', ha='center') \n",
+    "timer = fig.canvas.new_timer(500, [(update, [text], {})])\n",
+    "\n",
+    "timer.single_shot = True\n",
+    "timer.start()\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And the next two examples should never show any visible text at all:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "text = ax.text(0.5, 0.5, '', ha='center')\n",
+    "timer = fig.canvas.new_timer(500, [(update, [text], {})])\n",
+    "\n",
+    "timer.start()\n",
+    "timer.stop()\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "text = ax.text(0.5, 0.5, '', ha='center')\n",
+    "timer = fig.canvas.new_timer(500, [(update, [text], {})])\n",
+    "\n",
+    "timer.single_shot = True\n",
+    "timer.start()\n",
+    "timer.stop()\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### UAT17 - stopping figure when removed from DOM\n",
+    "\n",
+    "When the div that contains from the figure is removed from the DOM the figure should shut down it's comm, and if the python-side figure has no more active comms, it should destroy the figure. Repeatedly running the cell below should always have the same figure number"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "ax.plot(range(5))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Running the cell below will re-show the figure. After this, re-running the cell above should result in a new figure number."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "fig.canvas.manager.reshow()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.4.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

utils/venv/lib/python3.6/site-packages/matplotlib/backends/web_backend/single_figure.html

@@ -0,0 +1,30 @@
+<html>
+  <head>
+    <link rel="stylesheet" href="{{ prefix }}/_static/css/page.css" type="text/css">
+    <link rel="stylesheet" href="{{ prefix }}/_static/css/boilerplate.css" type="text/css" />
+    <link rel="stylesheet" href="{{ prefix }}/_static/css/fbm.css" type="text/css" />
+    <link rel="stylesheet" href="{{ prefix }}/_static/jquery/css/themes/base/jquery-ui.min.css" >
+    <script src="{{ prefix }}/_static/jquery/js/jquery-1.11.3.min.js"></script>
+    <script src="{{ prefix }}/_static/jquery/js/jquery-ui.min.js"></script>
+    <script src="{{ prefix }}/_static/js/mpl_tornado.js"></script>
+    <script src="{{ prefix }}/js/mpl.js"></script>
+    <script>
+      $(document).ready(
+        function() {
+          var websocket_type = mpl.get_websocket_type();
+          var websocket = new websocket_type(
+              "{{ ws_uri }}" + {{ repr(str(fig_id)) }} + "/ws");
+	  var fig = new mpl.figure(
+              {{repr(str(fig_id))}}, websocket, mpl_ondownload, $('div#figure'));
+        }
+      );
+    </script>
+
+    <title>matplotlib</title>
+  </head>
+
+  <body>
+    <div id="mpl-warnings" class="mpl-warnings"></div>
+    <div id="figure" style="margin: 10px 10px;"></div>
+  </body>
+</html>

utils/venv/lib/python3.6/site-packages/matplotlib/backends/windowing.py

@@ -0,0 +1,31 @@
+"""
+MS Windows-specific helper for the TkAgg backend.
+
+With rcParams['tk.window_focus'] default of False, it is
+effectively disabled.
+
+It uses a tiny C++ extension module to access MS Win functions.
+
+This module is deprecated and will be removed in version 3.2
+"""
+
+from matplotlib import rcParams, cbook
+
+cbook.warn_deprecated('3.0', obj_type='module', name='backends.windowing')
+
+try:
+    if not rcParams['tk.window_focus']:
+        raise ImportError
+    from matplotlib._windowing import GetForegroundWindow, SetForegroundWindow
+except ImportError:
+    def GetForegroundWindow():
+        return 0
+    def SetForegroundWindow(hwnd):
+        pass
+
+class FocusManager(object):
+    def __init__(self):
+        self._shellWindow = GetForegroundWindow()
+
+    def __del__(self):
+        SetForegroundWindow(self._shellWindow)

utils/venv/lib/python3.6/site-packages/matplotlib/backends/wx_compat.py

@@ -0,0 +1,36 @@
+"""
+A wx API adapter to hide differences between wxPython classic and phoenix.
+
+It is assumed that the user code is selecting what version it wants to use,
+here we just ensure that it meets the minimum required by matplotlib.
+
+For an example see embedding_in_wx2.py
+"""
+import wx
+
+from .. import cbook
+from .backend_wx import RendererWx
+
+
+cbook.warn_deprecated("3.0", "{} is deprecated.".format(__name__))
+
+backend_version = wx.VERSION_STRING
+is_phoenix = 'phoenix' in wx.PlatformInfo
+
+fontweights = RendererWx.fontweights
+fontangles = RendererWx.fontangles
+fontnames = RendererWx.fontnames
+
+dashd_wx = {'solid': wx.PENSTYLE_SOLID,
+            'dashed': wx.PENSTYLE_SHORT_DASH,
+            'dashdot': wx.PENSTYLE_DOT_DASH,
+            'dotted': wx.PENSTYLE_DOT}
+
+# functions changes
+BitmapFromBuffer = wx.Bitmap.FromBufferRGBA
+EmptyBitmap = wx.Bitmap
+EmptyImage = wx.Image
+Cursor = wx.Cursor
+EventLoop = wx.GUIEventLoop
+NamedColour = wx.Colour
+StockCursor = wx.Cursor