Rework backend loading.

anntzer · anntzer · commit 2c73ababcecc · 2017-12-29T15:58:53.000-08:00
This is preliminary work towards fixing the runtime detection of default
backend problem (the first step being to make it easier to check whether
a backend *can* be loaded).  No publically visible API is changed.

Backend loading now defines default versions of `backend_version`,
`draw_if_interactive`, and `show` using the same inheritance strategy as
builtin backends do.

For non-interactive backends (which don't override `mainloop`), restore
the default implementation of `show()` that prints a warning when run
from a console (the backend refactor accidentally removed this error
message as it provided a silent default `show()`).

The `_Backend` class had to be moved to the end of the module as
`FigureManagerBase` needs to be defined first.  The `ShowBase` class had
to be moved even after that as it depends on the `_Backend` class.
diff --git a/lib/matplotlib/backend_bases.py b/lib/matplotlib/backend_bases.py
@@ -41,6 +41,7 @@
 from contextlib import contextmanager
 from functools import partial
 import importlib
+import inspect
 import io
 import os
 import sys
@@ -126,120 +127,6 @@ def get_registered_canvas_class(format):
     return backend_class
 
 
-class _Backend(object):
-    # A backend can be defined by using the following pattern:
-    #
-    # @_Backend.export
-    # class FooBackend(_Backend):
-    #     # override the attributes and methods documented below.
-
-    # The following attributes and methods must be overridden by subclasses.
-
-    # The `FigureCanvas` and `FigureManager` classes must be defined.
-    FigureCanvas = None
-    FigureManager = None
-
-    # The following methods must be left as None for non-interactive backends.
-    # For interactive backends, `trigger_manager_draw` should be a function
-    # taking a manager as argument and triggering a canvas draw, and `mainloop`
-    # should be a function taking no argument and starting the backend main
-    # loop.
-    trigger_manager_draw = None
-    mainloop = None
-
-    # The following methods will be automatically defined and exported, but
-    # can be overridden.
-
-    @classmethod
-    def new_figure_manager(cls, num, *args, **kwargs):
-        """Create a new figure manager instance.
-        """
-        # This import needs to happen here due to circular imports.
-        from matplotlib.figure import Figure
-        fig_cls = kwargs.pop('FigureClass', Figure)
-        fig = fig_cls(*args, **kwargs)
-        return cls.new_figure_manager_given_figure(num, fig)
-
-    @classmethod
-    def new_figure_manager_given_figure(cls, num, figure):
-        """Create a new figure manager instance for the given figure.
-        """
-        canvas = cls.FigureCanvas(figure)
-        manager = cls.FigureManager(canvas, num)
-        return manager
-
-    @classmethod
-    def draw_if_interactive(cls):
-        if cls.trigger_manager_draw is not None and is_interactive():
-            manager = Gcf.get_active()
-            if manager:
-                cls.trigger_manager_draw(manager)
-
-    @classmethod
-    def show(cls, block=None):
-        """Show all figures.
-
-        `show` blocks by calling `mainloop` if *block* is ``True``, or if it
-        is ``None`` and we are neither in IPython's ``%pylab`` mode, nor in
-        `interactive` mode.
-        """
-        if cls.mainloop is None:
-            return
-        managers = Gcf.get_all_fig_managers()
-        if not managers:
-            return
-        for manager in managers:
-            manager.show()
-        if block is None:
-            # Hack: Are we in IPython's pylab mode?
-            from matplotlib import pyplot
-            try:
-                # IPython versions >= 0.10 tack the _needmain attribute onto
-                # pyplot.show, and always set it to False, when in %pylab mode.
-                ipython_pylab = not pyplot.show._needmain
-            except AttributeError:
-                ipython_pylab = False
-            block = not ipython_pylab and not is_interactive()
-            # TODO: The above is a hack to get the WebAgg backend working with
-            # ipython's `%pylab` mode until proper integration is implemented.
-            if get_backend() == "WebAgg":
-                block = True
-        if block:
-            cls.mainloop()
-
-    # This method is the one actually exporting the required methods.
-
-    @staticmethod
-    def export(cls):
-        for name in ["FigureCanvas",
-                     "FigureManager",
-                     "new_figure_manager",
-                     "new_figure_manager_given_figure",
-                     "draw_if_interactive",
-                     "show"]:
-            setattr(sys.modules[cls.__module__], name, getattr(cls, name))
-
-        # For back-compatibility, generate a shim `Show` class.
-
-        class Show(ShowBase):
-            def mainloop(self):
-                return cls.mainloop()
-
-        setattr(sys.modules[cls.__module__], "Show", Show)
-        return cls
-
-
-class ShowBase(_Backend):
-    """
-    Simple base class to generate a show() callable in backends.
-
-    Subclass must override mainloop() method.
-    """
-
-    def __call__(self, block=None):
-        return self.show(block=block)
-
-
 class RendererBase(object):
     """An abstract base class to handle drawing/rendering operations.
 
@@ -3364,3 +3251,129 @@ def set_message(self, s):
             Message text
         """
         pass
+
+
+class _Backend(object):
+    # A backend can be defined by using the following pattern:
+    #
+    # @_Backend.export
+    # class FooBackend(_Backend):
+    #     # override the attributes and methods documented below.
+
+    # May be overridden by the subclass.
+    backend_version = "unknown"
+    # The `FigureCanvas` class must be overridden.
+    FigureCanvas = None
+    # For interactive backends, the `FigureManager` class must be overridden.
+    FigureManager = FigureManagerBase
+    # The following methods must be left as None for non-interactive backends.
+    # For interactive backends, `trigger_manager_draw` should be a function
+    # taking a manager as argument and triggering a canvas draw, and `mainloop`
+    # should be a function taking no argument and starting the backend main
+    # loop.
+    trigger_manager_draw = None
+    mainloop = None
+
+    # The following methods will be automatically defined and exported, but
+    # can be overridden.
+
+    @classmethod
+    def new_figure_manager(cls, num, *args, **kwargs):
+        """Create a new figure manager instance.
+        """
+        # This import needs to happen here due to circular imports.
+        from matplotlib.figure import Figure
+        fig_cls = kwargs.pop('FigureClass', Figure)
+        fig = fig_cls(*args, **kwargs)
+        return cls.new_figure_manager_given_figure(num, fig)
+
+    @classmethod
+    def new_figure_manager_given_figure(cls, num, figure):
+        """Create a new figure manager instance for the given figure.
+        """
+        canvas = cls.FigureCanvas(figure)
+        manager = cls.FigureManager(canvas, num)
+        return manager
+
+    @classmethod
+    def draw_if_interactive(cls):
+        if cls.trigger_manager_draw is not None and is_interactive():
+            manager = Gcf.get_active()
+            if manager:
+                cls.trigger_manager_draw(manager)
+
+    @classmethod
+    def show(cls, block=None):
+        """Show all figures.
+
+        `show` blocks by calling `mainloop` if *block* is ``True``, or if it
+        is ``None`` and we are neither in IPython's ``%pylab`` mode, nor in
+        `interactive` mode.
+        """
+        if cls.mainloop is None:
+            frame = inspect.currentframe()
+            while frame:
+                if frame.f_code.co_filename in [
+                        "<stdin>", "<ipython console>"]:
+                    warnings.warn("""\
+Your currently selected backend does not support show().
+Please select a GUI backend in your matplotlibrc file ('{}')
+or with matplotlib.use()""".format(matplotlib.matplotlib_fname()))
+                    break
+                else:
+                    frame = frame.f_back
+            return
+        managers = Gcf.get_all_fig_managers()
+        if not managers:
+            return
+        for manager in managers:
+            manager.show()
+        if block is None:
+            # Hack: Are we in IPython's pylab mode?
+            from matplotlib import pyplot
+            try:
+                # IPython versions >= 0.10 tack the _needmain attribute onto
+                # pyplot.show, and always set it to False, when in %pylab mode.
+                ipython_pylab = not pyplot.show._needmain
+            except AttributeError:
+                ipython_pylab = False
+            block = not ipython_pylab and not is_interactive()
+            # TODO: The above is a hack to get the WebAgg backend working with
+            # ipython's `%pylab` mode until proper integration is implemented.
+            if get_backend() == "WebAgg":
+                block = True
+        if block:
+            cls.mainloop()
+
+    # This method is the one actually exporting the required methods.
+
+    @staticmethod
+    def export(cls):
+        for name in ["backend_version",
+                     "FigureCanvas",
+                     "FigureManager",
+                     "new_figure_manager",
+                     "new_figure_manager_given_figure",
+                     "draw_if_interactive",
+                     "show"]:
+            setattr(sys.modules[cls.__module__], name, getattr(cls, name))
+
+        # For back-compatibility, generate a shim `Show` class.
+
+        class Show(ShowBase):
+            def mainloop(self):
+                return cls.mainloop()
+
+        setattr(sys.modules[cls.__module__], "Show", Show)
+        return cls
+
+
+class ShowBase(_Backend):
+    """
+    Simple base class to generate a show() callable in backends.
+
+    Subclass must override mainloop() method.
+    """
+
+    def __call__(self, block=None):
+        return self.show(block=block)
diff --git a/lib/matplotlib/backends/__init__.py b/lib/matplotlib/backends/__init__.py
@@ -3,11 +3,13 @@
 
 import six
 
-import matplotlib
-import inspect
-import traceback
-import warnings
+import importlib
 import logging
+import traceback
+
+import matplotlib
+from matplotlib.backend_bases import _Backend
+
 
 _log = logging.getLogger(__name__)
 
@@ -47,50 +49,30 @@ def pylab_setup(name=None):
     '''
     # Import the requested backend into a generic module object
     if name is None:
-        # validates, to match all_backends
         name = matplotlib.get_backend()
-    if name.startswith('module://'):
-        backend_name = name[9:]
-    else:
-        backend_name = 'backend_' + name
-        backend_name = backend_name.lower()  # until we banish mixed case
-        backend_name = 'matplotlib.backends.%s' % backend_name.lower()
-
-    # the last argument is specifies whether to use absolute or relative
-    # imports. 0 means only perform absolute imports.
-    backend_mod = __import__(backend_name, globals(), locals(),
-                             [backend_name], 0)
-
-    # Things we pull in from all backends
-    new_figure_manager = backend_mod.new_figure_manager
-
-    # image backends like pdf, agg or svg do not need to do anything
-    # for "show" or "draw_if_interactive", so if they are not defined
-    # by the backend, just do nothing
-    def do_nothing_show(*args, **kwargs):
-        frame = inspect.currentframe()
-        fname = frame.f_back.f_code.co_filename
-        if fname in ('<stdin>', '<ipython console>'):
-            warnings.warn("""
-Your currently selected backend, '%s' does not support show().
-Please select a GUI backend in your matplotlibrc file ('%s')
-or with matplotlib.use()""" %
-                          (name, matplotlib.matplotlib_fname()))
-
-    def do_nothing(*args, **kwargs):
-        pass
-
-    backend_version = getattr(backend_mod, 'backend_version', 'unknown')
-
-    show = getattr(backend_mod, 'show', do_nothing_show)
-
-    draw_if_interactive = getattr(backend_mod, 'draw_if_interactive',
-                                  do_nothing)
-
-    _log.info('backend %s version %s' % (name, backend_version))
+    backend_name = (name[9:] if name.startswith("module://")
+                    else "matplotlib.backends.backend_{}".format(name.lower()))
+
+    backend_mod = importlib.import_module(backend_name)
+    Backend = type(str("Backend"), (_Backend,), vars(backend_mod))
+    _log.info('backend %s version %s', name, Backend.backend_version)
 
     # need to keep a global reference to the backend for compatibility
     # reasons. See https://github.com/matplotlib/matplotlib/issues/6092
     global backend
     backend = name
-    return backend_mod, new_figure_manager, draw_if_interactive, show
+
+    # We want to get functions out of a class namespace and call them *without
+    # the first argument being an instance of the class*.  This works directly
+    # on Py3.  On Py2, we need to remove the check that the first argument be
+    # an instance of the class.  The only relevant case is if `.im_self` is
+    # None, in which case we need to use `.im_func` (if we have a bound method
+    # (e.g. a classmethod), everything is fine).
+    def _dont_check_first_arg(func):
+        return (func.im_func if getattr(func, "im_self", 0) is None
+                else func)
+
+    return (backend_mod,
+            _dont_check_first_arg(Backend.new_figure_manager),
+            _dont_check_first_arg(Backend.draw_if_interactive),
+            _dont_check_first_arg(Backend.show))
diff --git a/lib/matplotlib/backends/backend_pdf.py b/lib/matplotlib/backends/backend_pdf.py
@@ -2594,11 +2594,9 @@ def print_pdf(self, filename, **kwargs):
                 file.close()
 
 
-class FigureManagerPdf(FigureManagerBase):
-    pass
+FigureManagerPdf = FigureManagerBase
 
 
 @_Backend.export
 class _BackendPdf(_Backend):
     FigureCanvas = FigureCanvasPdf
-    FigureManager = FigureManagerPdf
diff --git a/lib/matplotlib/backends/backend_ps.py b/lib/matplotlib/backends/backend_ps.py
@@ -1721,8 +1721,7 @@ def pstoeps(tmpfile, bbox=None, rotated=False):
     shutil.move(epsfile, tmpfile)
 
 
-class FigureManagerPS(FigureManagerBase):
-    pass
+FigureManagerPS = FigureManagerBase
 
 
 # The following Python dictionary psDefs contains the entries for the
@@ -1768,4 +1767,3 @@ class FigureManagerPS(FigureManagerBase):
 @_Backend.export
 class _BackendPS(_Backend):
     FigureCanvas = FigureCanvasPS
-    FigureManager = FigureManagerPS
diff --git a/lib/matplotlib/backends/backend_svg.py b/lib/matplotlib/backends/backend_svg.py
@@ -1252,8 +1252,8 @@ def _print_svg(self, filename, svgwriter, **kwargs):
     def get_default_filetype(self):
         return 'svg'
 
-class FigureManagerSVG(FigureManagerBase):
-    pass
+
+FigureManagerSVG = FigureManagerBase
 
 
 svgProlog = """\
@@ -1267,4 +1267,3 @@ class FigureManagerSVG(FigureManagerBase):
 @_Backend.export
 class _BackendSVG(_Backend):
     FigureCanvas = FigureCanvasSVG
-    FigureManager = FigureManagerSVG
