From e9656aae26e0358d5378e5b63dcac5c8dbe0e4d0 Mon Sep 17 00:00:00 2001
From: shadchin <shadchin@yandex-team.ru>
Date: Thu, 10 Feb 2022 16:44:39 +0300
Subject: Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit
2 of 2.
---
.../matplotlib_inline/backend_inline.py | 612 ++++++++++-----------
.../matplotlib-inline/matplotlib_inline/config.py | 214 +++----
2 files changed, 413 insertions(+), 413 deletions(-)
(limited to 'contrib/python/matplotlib-inline/matplotlib_inline')
diff --git a/contrib/python/matplotlib-inline/matplotlib_inline/backend_inline.py b/contrib/python/matplotlib-inline/matplotlib_inline/backend_inline.py
index 1e3431fc0f..ca2e003186 100644
--- a/contrib/python/matplotlib-inline/matplotlib_inline/backend_inline.py
+++ b/contrib/python/matplotlib-inline/matplotlib_inline/backend_inline.py
@@ -1,306 +1,306 @@
-"""A matplotlib backend for publishing figures via display_data"""
-
-# Copyright (c) IPython Development Team.
-# Distributed under the terms of the BSD 3-Clause License.
-
-import matplotlib
-from matplotlib.backends.backend_agg import ( # noqa
- new_figure_manager,
- FigureCanvasAgg,
- new_figure_manager_given_figure,
-)
-from matplotlib import colors
-from matplotlib._pylab_helpers import Gcf
-
-from IPython.core.interactiveshell import InteractiveShell
-from IPython.core.getipython import get_ipython
-from IPython.core.pylabtools import select_figure_formats
-from IPython.display import display
-
-from .config import InlineBackend
-
-
-def show(close=None, block=None):
- """Show all figures as SVG/PNG payloads sent to the IPython clients.
-
- Parameters
- ----------
- close : bool, optional
- If true, a ``plt.close('all')`` call is automatically issued after
- sending all the figures. If this is set, the figures will entirely
- removed from the internal list of figures.
- block : Not used.
- The `block` parameter is a Matplotlib experimental parameter.
- We accept it in the function signature for compatibility with other
- backends.
- """
- if close is None:
- close = InlineBackend.instance().close_figures
- try:
- for figure_manager in Gcf.get_all_fig_managers():
- display(
- figure_manager.canvas.figure,
- metadata=_fetch_figure_metadata(figure_manager.canvas.figure)
- )
- finally:
- show._to_draw = []
- # only call close('all') if any to close
- # close triggers gc.collect, which can be slow
- if close and Gcf.get_all_fig_managers():
- matplotlib.pyplot.close('all')
-
-
-# This flag will be reset by draw_if_interactive when called
-show._draw_called = False
-# list of figures to draw when flush_figures is called
-show._to_draw = []
-
-
-def draw_if_interactive():
- """
- Is called after every pylab drawing command
- """
- # signal that the current active figure should be sent at the end of
- # execution. Also sets the _draw_called flag, signaling that there will be
- # something to send. At the end of the code execution, a separate call to
- # flush_figures() will act upon these values
- manager = Gcf.get_active()
- if manager is None:
- return
- fig = manager.canvas.figure
-
- # Hack: matplotlib FigureManager objects in interacive backends (at least
- # in some of them) monkeypatch the figure object and add a .show() method
- # to it. This applies the same monkeypatch in order to support user code
- # that might expect `.show()` to be part of the official API of figure
- # objects.
- # For further reference:
- # https://github.com/ipython/ipython/issues/1612
- # https://github.com/matplotlib/matplotlib/issues/835
-
- if not hasattr(fig, 'show'):
- # Queue up `fig` for display
- fig.show = lambda *a: display(fig, metadata=_fetch_figure_metadata(fig))
-
- # If matplotlib was manually set to non-interactive mode, this function
- # should be a no-op (otherwise we'll generate duplicate plots, since a user
- # who set ioff() manually expects to make separate draw/show calls).
- if not matplotlib.is_interactive():
- return
-
- # ensure current figure will be drawn, and each subsequent call
- # of draw_if_interactive() moves the active figure to ensure it is
- # drawn last
- try:
- show._to_draw.remove(fig)
- except ValueError:
- # ensure it only appears in the draw list once
- pass
- # Queue up the figure for drawing in next show() call
- show._to_draw.append(fig)
- show._draw_called = True
-
-
-def flush_figures():
- """Send all figures that changed
-
- This is meant to be called automatically and will call show() if, during
- prior code execution, there had been any calls to draw_if_interactive.
-
- This function is meant to be used as a post_execute callback in IPython,
- so user-caused errors are handled with showtraceback() instead of being
- allowed to raise. If this function is not called from within IPython,
- then these exceptions will raise.
- """
- if not show._draw_called:
- return
-
- if InlineBackend.instance().close_figures:
- # ignore the tracking, just draw and close all figures
- try:
- return show(True)
- except Exception as e:
- # safely show traceback if in IPython, else raise
- ip = get_ipython()
- if ip is None:
- raise e
- else:
- ip.showtraceback()
- return
- try:
- # exclude any figures that were closed:
- active = set([fm.canvas.figure for fm in Gcf.get_all_fig_managers()])
- for fig in [fig for fig in show._to_draw if fig in active]:
- try:
- display(fig, metadata=_fetch_figure_metadata(fig))
- except Exception as e:
- # safely show traceback if in IPython, else raise
- ip = get_ipython()
- if ip is None:
- raise e
- else:
- ip.showtraceback()
- return
- finally:
- # clear flags for next round
- show._to_draw = []
- show._draw_called = False
-
-
-# Changes to matplotlib in version 1.2 requires a mpl backend to supply a default
-# figurecanvas. This is set here to a Agg canvas
-# See https://github.com/matplotlib/matplotlib/pull/1125
-FigureCanvas = FigureCanvasAgg
-
-
-def configure_inline_support(shell, backend):
- """Configure an IPython shell object for matplotlib use.
-
- Parameters
- ----------
- shell : InteractiveShell instance
-
- backend : matplotlib backend
- """
- # If using our svg payload backend, register the post-execution
- # function that will pick up the results for display. This can only be
- # done with access to the real shell object.
-
- cfg = InlineBackend.instance(parent=shell)
- cfg.shell = shell
- if cfg not in shell.configurables:
- shell.configurables.append(cfg)
-
- if backend == 'module://matplotlib_inline.backend_inline':
- shell.events.register('post_execute', flush_figures)
-
- # Save rcParams that will be overwrittern
- shell._saved_rcParams = {}
- for k in cfg.rc:
- shell._saved_rcParams[k] = matplotlib.rcParams[k]
- # load inline_rc
- matplotlib.rcParams.update(cfg.rc)
- new_backend_name = "inline"
- else:
- try:
- shell.events.unregister('post_execute', flush_figures)
- except ValueError:
- pass
- if hasattr(shell, '_saved_rcParams'):
- matplotlib.rcParams.update(shell._saved_rcParams)
- del shell._saved_rcParams
- new_backend_name = "other"
-
- # only enable the formats once -> don't change the enabled formats (which the user may
- # has changed) when getting another "%matplotlib inline" call.
- # See https://github.com/ipython/ipykernel/issues/29
- cur_backend = getattr(configure_inline_support, "current_backend", "unset")
- if new_backend_name != cur_backend:
- # Setup the default figure format
- select_figure_formats(shell, cfg.figure_formats, **cfg.print_figure_kwargs)
- configure_inline_support.current_backend = new_backend_name
-
-
-def _enable_matplotlib_integration():
- """Enable extra IPython matplotlib integration when we are loaded as the matplotlib backend."""
- from matplotlib import get_backend
- ip = get_ipython()
- backend = get_backend()
- if ip and backend == 'module://%s' % __name__:
- from IPython.core.pylabtools import activate_matplotlib
- try:
- activate_matplotlib(backend)
- configure_inline_support(ip, backend)
- except (ImportError, AttributeError):
- # bugs may cause a circular import on Python 2
- def configure_once(*args):
- activate_matplotlib(backend)
- configure_inline_support(ip, backend)
- ip.events.unregister('post_run_cell', configure_once)
- ip.events.register('post_run_cell', configure_once)
-
-
-_enable_matplotlib_integration()
-
-
-def _fetch_figure_metadata(fig):
- """Get some metadata to help with displaying a figure."""
- # determine if a background is needed for legibility
- if _is_transparent(fig.get_facecolor()):
- # the background is transparent
- ticksLight = _is_light([label.get_color()
- for axes in fig.axes
- for axis in (axes.xaxis, axes.yaxis)
- for label in axis.get_ticklabels()])
- if ticksLight.size and (ticksLight == ticksLight[0]).all():
- # there are one or more tick labels, all with the same lightness
- return {'needs_background': 'dark' if ticksLight[0] else 'light'}
-
- return None
-
-
-def _is_light(color):
- """Determines if a color (or each of a sequence of colors) is light (as
- opposed to dark). Based on ITU BT.601 luminance formula (see
- https://stackoverflow.com/a/596241)."""
- rgbaArr = colors.to_rgba_array(color)
- return rgbaArr[:, :3].dot((.299, .587, .114)) > .5
-
-
-def _is_transparent(color):
- """Determine transparency from alpha."""
- rgba = colors.to_rgba(color)
- return rgba[3] < .5
-
-
-def set_matplotlib_formats(*formats, **kwargs):
- """Select figure formats for the inline backend. Optionally pass quality for JPEG.
-
- For example, this enables PNG and JPEG output with a JPEG quality of 90%::
-
- In [1]: set_matplotlib_formats('png', 'jpeg', quality=90)
-
- To set this in your config files use the following::
-
- c.InlineBackend.figure_formats = {'png', 'jpeg'}
- c.InlineBackend.print_figure_kwargs.update({'quality' : 90})
-
- Parameters
- ----------
- *formats : strs
- One or more figure formats to enable: 'png', 'retina', 'jpeg', 'svg', 'pdf'.
- **kwargs
- Keyword args will be relayed to ``figure.canvas.print_figure``.
- """
- # build kwargs, starting with InlineBackend config
- cfg = InlineBackend.instance()
- kw = {}
- kw.update(cfg.print_figure_kwargs)
- kw.update(**kwargs)
- shell = InteractiveShell.instance()
- select_figure_formats(shell, formats, **kw)
-
-
-def set_matplotlib_close(close=True):
- """Set whether the inline backend closes all figures automatically or not.
-
- By default, the inline backend used in the IPython Notebook will close all
- matplotlib figures automatically after each cell is run. This means that
- plots in different cells won't interfere. Sometimes, you may want to make
- a plot in one cell and then refine it in later cells. This can be accomplished
- by::
-
- In [1]: set_matplotlib_close(False)
-
- To set this in your config files use the following::
-
- c.InlineBackend.close_figures = False
-
- Parameters
- ----------
- close : bool
- Should all matplotlib figures be automatically closed after each cell is
- run?
- """
- cfg = InlineBackend.instance()
- cfg.close_figures = close
+"""A matplotlib backend for publishing figures via display_data"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the BSD 3-Clause License.
+
+import matplotlib
+from matplotlib.backends.backend_agg import ( # noqa
+ new_figure_manager,
+ FigureCanvasAgg,
+ new_figure_manager_given_figure,
+)
+from matplotlib import colors
+from matplotlib._pylab_helpers import Gcf
+
+from IPython.core.interactiveshell import InteractiveShell
+from IPython.core.getipython import get_ipython
+from IPython.core.pylabtools import select_figure_formats
+from IPython.display import display
+
+from .config import InlineBackend
+
+
+def show(close=None, block=None):
+ """Show all figures as SVG/PNG payloads sent to the IPython clients.
+
+ Parameters
+ ----------
+ close : bool, optional
+ If true, a ``plt.close('all')`` call is automatically issued after
+ sending all the figures. If this is set, the figures will entirely
+ removed from the internal list of figures.
+ block : Not used.
+ The `block` parameter is a Matplotlib experimental parameter.
+ We accept it in the function signature for compatibility with other
+ backends.
+ """
+ if close is None:
+ close = InlineBackend.instance().close_figures
+ try:
+ for figure_manager in Gcf.get_all_fig_managers():
+ display(
+ figure_manager.canvas.figure,
+ metadata=_fetch_figure_metadata(figure_manager.canvas.figure)
+ )
+ finally:
+ show._to_draw = []
+ # only call close('all') if any to close
+ # close triggers gc.collect, which can be slow
+ if close and Gcf.get_all_fig_managers():
+ matplotlib.pyplot.close('all')
+
+
+# This flag will be reset by draw_if_interactive when called
+show._draw_called = False
+# list of figures to draw when flush_figures is called
+show._to_draw = []
+
+
+def draw_if_interactive():
+ """
+ Is called after every pylab drawing command
+ """
+ # signal that the current active figure should be sent at the end of
+ # execution. Also sets the _draw_called flag, signaling that there will be
+ # something to send. At the end of the code execution, a separate call to
+ # flush_figures() will act upon these values
+ manager = Gcf.get_active()
+ if manager is None:
+ return
+ fig = manager.canvas.figure
+
+ # Hack: matplotlib FigureManager objects in interacive backends (at least
+ # in some of them) monkeypatch the figure object and add a .show() method
+ # to it. This applies the same monkeypatch in order to support user code
+ # that might expect `.show()` to be part of the official API of figure
+ # objects.
+ # For further reference:
+ # https://github.com/ipython/ipython/issues/1612
+ # https://github.com/matplotlib/matplotlib/issues/835
+
+ if not hasattr(fig, 'show'):
+ # Queue up `fig` for display
+ fig.show = lambda *a: display(fig, metadata=_fetch_figure_metadata(fig))
+
+ # If matplotlib was manually set to non-interactive mode, this function
+ # should be a no-op (otherwise we'll generate duplicate plots, since a user
+ # who set ioff() manually expects to make separate draw/show calls).
+ if not matplotlib.is_interactive():
+ return
+
+ # ensure current figure will be drawn, and each subsequent call
+ # of draw_if_interactive() moves the active figure to ensure it is
+ # drawn last
+ try:
+ show._to_draw.remove(fig)
+ except ValueError:
+ # ensure it only appears in the draw list once
+ pass
+ # Queue up the figure for drawing in next show() call
+ show._to_draw.append(fig)
+ show._draw_called = True
+
+
+def flush_figures():
+ """Send all figures that changed
+
+ This is meant to be called automatically and will call show() if, during
+ prior code execution, there had been any calls to draw_if_interactive.
+
+ This function is meant to be used as a post_execute callback in IPython,
+ so user-caused errors are handled with showtraceback() instead of being
+ allowed to raise. If this function is not called from within IPython,
+ then these exceptions will raise.
+ """
+ if not show._draw_called:
+ return
+
+ if InlineBackend.instance().close_figures:
+ # ignore the tracking, just draw and close all figures
+ try:
+ return show(True)
+ except Exception as e:
+ # safely show traceback if in IPython, else raise
+ ip = get_ipython()
+ if ip is None:
+ raise e
+ else:
+ ip.showtraceback()
+ return
+ try:
+ # exclude any figures that were closed:
+ active = set([fm.canvas.figure for fm in Gcf.get_all_fig_managers()])
+ for fig in [fig for fig in show._to_draw if fig in active]:
+ try:
+ display(fig, metadata=_fetch_figure_metadata(fig))
+ except Exception as e:
+ # safely show traceback if in IPython, else raise
+ ip = get_ipython()
+ if ip is None:
+ raise e
+ else:
+ ip.showtraceback()
+ return
+ finally:
+ # clear flags for next round
+ show._to_draw = []
+ show._draw_called = False
+
+
+# Changes to matplotlib in version 1.2 requires a mpl backend to supply a default
+# figurecanvas. This is set here to a Agg canvas
+# See https://github.com/matplotlib/matplotlib/pull/1125
+FigureCanvas = FigureCanvasAgg
+
+
+def configure_inline_support(shell, backend):
+ """Configure an IPython shell object for matplotlib use.
+
+ Parameters
+ ----------
+ shell : InteractiveShell instance
+
+ backend : matplotlib backend
+ """
+ # If using our svg payload backend, register the post-execution
+ # function that will pick up the results for display. This can only be
+ # done with access to the real shell object.
+
+ cfg = InlineBackend.instance(parent=shell)
+ cfg.shell = shell
+ if cfg not in shell.configurables:
+ shell.configurables.append(cfg)
+
+ if backend == 'module://matplotlib_inline.backend_inline':
+ shell.events.register('post_execute', flush_figures)
+
+ # Save rcParams that will be overwrittern
+ shell._saved_rcParams = {}
+ for k in cfg.rc:
+ shell._saved_rcParams[k] = matplotlib.rcParams[k]
+ # load inline_rc
+ matplotlib.rcParams.update(cfg.rc)
+ new_backend_name = "inline"
+ else:
+ try:
+ shell.events.unregister('post_execute', flush_figures)
+ except ValueError:
+ pass
+ if hasattr(shell, '_saved_rcParams'):
+ matplotlib.rcParams.update(shell._saved_rcParams)
+ del shell._saved_rcParams
+ new_backend_name = "other"
+
+ # only enable the formats once -> don't change the enabled formats (which the user may
+ # has changed) when getting another "%matplotlib inline" call.
+ # See https://github.com/ipython/ipykernel/issues/29
+ cur_backend = getattr(configure_inline_support, "current_backend", "unset")
+ if new_backend_name != cur_backend:
+ # Setup the default figure format
+ select_figure_formats(shell, cfg.figure_formats, **cfg.print_figure_kwargs)
+ configure_inline_support.current_backend = new_backend_name
+
+
+def _enable_matplotlib_integration():
+ """Enable extra IPython matplotlib integration when we are loaded as the matplotlib backend."""
+ from matplotlib import get_backend
+ ip = get_ipython()
+ backend = get_backend()
+ if ip and backend == 'module://%s' % __name__:
+ from IPython.core.pylabtools import activate_matplotlib
+ try:
+ activate_matplotlib(backend)
+ configure_inline_support(ip, backend)
+ except (ImportError, AttributeError):
+ # bugs may cause a circular import on Python 2
+ def configure_once(*args):
+ activate_matplotlib(backend)
+ configure_inline_support(ip, backend)
+ ip.events.unregister('post_run_cell', configure_once)
+ ip.events.register('post_run_cell', configure_once)
+
+
+_enable_matplotlib_integration()
+
+
+def _fetch_figure_metadata(fig):
+ """Get some metadata to help with displaying a figure."""
+ # determine if a background is needed for legibility
+ if _is_transparent(fig.get_facecolor()):
+ # the background is transparent
+ ticksLight = _is_light([label.get_color()
+ for axes in fig.axes
+ for axis in (axes.xaxis, axes.yaxis)
+ for label in axis.get_ticklabels()])
+ if ticksLight.size and (ticksLight == ticksLight[0]).all():
+ # there are one or more tick labels, all with the same lightness
+ return {'needs_background': 'dark' if ticksLight[0] else 'light'}
+
+ return None
+
+
+def _is_light(color):
+ """Determines if a color (or each of a sequence of colors) is light (as
+ opposed to dark). Based on ITU BT.601 luminance formula (see
+ https://stackoverflow.com/a/596241)."""
+ rgbaArr = colors.to_rgba_array(color)
+ return rgbaArr[:, :3].dot((.299, .587, .114)) > .5
+
+
+def _is_transparent(color):
+ """Determine transparency from alpha."""
+ rgba = colors.to_rgba(color)
+ return rgba[3] < .5
+
+
+def set_matplotlib_formats(*formats, **kwargs):
+ """Select figure formats for the inline backend. Optionally pass quality for JPEG.
+
+ For example, this enables PNG and JPEG output with a JPEG quality of 90%::
+
+ In [1]: set_matplotlib_formats('png', 'jpeg', quality=90)
+
+ To set this in your config files use the following::
+
+ c.InlineBackend.figure_formats = {'png', 'jpeg'}
+ c.InlineBackend.print_figure_kwargs.update({'quality' : 90})
+
+ Parameters
+ ----------
+ *formats : strs
+ One or more figure formats to enable: 'png', 'retina', 'jpeg', 'svg', 'pdf'.
+ **kwargs
+ Keyword args will be relayed to ``figure.canvas.print_figure``.
+ """
+ # build kwargs, starting with InlineBackend config
+ cfg = InlineBackend.instance()
+ kw = {}
+ kw.update(cfg.print_figure_kwargs)
+ kw.update(**kwargs)
+ shell = InteractiveShell.instance()
+ select_figure_formats(shell, formats, **kw)
+
+
+def set_matplotlib_close(close=True):
+ """Set whether the inline backend closes all figures automatically or not.
+
+ By default, the inline backend used in the IPython Notebook will close all
+ matplotlib figures automatically after each cell is run. This means that
+ plots in different cells won't interfere. Sometimes, you may want to make
+ a plot in one cell and then refine it in later cells. This can be accomplished
+ by::
+
+ In [1]: set_matplotlib_close(False)
+
+ To set this in your config files use the following::
+
+ c.InlineBackend.close_figures = False
+
+ Parameters
+ ----------
+ close : bool
+ Should all matplotlib figures be automatically closed after each cell is
+ run?
+ """
+ cfg = InlineBackend.instance()
+ cfg.close_figures = close
diff --git a/contrib/python/matplotlib-inline/matplotlib_inline/config.py b/contrib/python/matplotlib-inline/matplotlib_inline/config.py
index 608015aa77..c0f398069e 100644
--- a/contrib/python/matplotlib-inline/matplotlib_inline/config.py
+++ b/contrib/python/matplotlib-inline/matplotlib_inline/config.py
@@ -1,107 +1,107 @@
-"""Configurable for configuring the IPython inline backend
-
-This module does not import anything from matplotlib.
-"""
-
-# Copyright (c) IPython Development Team.
-# Distributed under the terms of the BSD 3-Clause License.
-
-from traitlets.config.configurable import SingletonConfigurable
-from traitlets import (
- Dict, Instance, Set, Bool, TraitError, Unicode
-)
-
-
-# Configurable for inline backend options
-def pil_available():
- """Test if PIL/Pillow is available"""
- out = False
- try:
- from PIL import Image # noqa
- out = True
- except ImportError:
- pass
- return out
-
-
-# Inherit from InlineBackendConfig for deprecation purposes
-class InlineBackendConfig(SingletonConfigurable):
- pass
-
-
-class InlineBackend(InlineBackendConfig):
- """An object to store configuration of the inline backend."""
-
- # The typical default figure size is too large for inline use,
- # so we shrink the figure size to 6x4, and tweak fonts to
- # make that fit.
- rc = Dict(
- {
- 'figure.figsize': (6.0, 4.0),
- # play nicely with white background in the Qt and notebook frontend
- 'figure.facecolor': (1, 1, 1, 0),
- 'figure.edgecolor': (1, 1, 1, 0),
- # 12pt labels get cutoff on 6x4 logplots, so use 10pt.
- 'font.size': 10,
- # 72 dpi matches SVG/qtconsole
- # this only affects PNG export, as SVG has no dpi setting
- 'figure.dpi': 72,
- # 10pt still needs a little more room on the xlabel:
- 'figure.subplot.bottom': .125
- },
- help="""Subset of matplotlib rcParams that should be different for the
- inline backend."""
- ).tag(config=True)
-
- figure_formats = Set(
- {'png'},
- help="""A set of figure formats to enable: 'png',
- 'retina', 'jpeg', 'svg', 'pdf'.""").tag(config=True)
-
- def _update_figure_formatters(self):
- if self.shell is not None:
- from IPython.core.pylabtools import select_figure_formats
- select_figure_formats(self.shell, self.figure_formats, **self.print_figure_kwargs)
-
- def _figure_formats_changed(self, name, old, new):
- if 'jpg' in new or 'jpeg' in new:
- if not pil_available():
- raise TraitError("Requires PIL/Pillow for JPG figures")
- self._update_figure_formatters()
-
- figure_format = Unicode(help="""The figure format to enable (deprecated
- use `figure_formats` instead)""").tag(config=True)
-
- def _figure_format_changed(self, name, old, new):
- if new:
- self.figure_formats = {new}
-
- print_figure_kwargs = Dict(
- {'bbox_inches': 'tight'},
- help="""Extra kwargs to be passed to fig.canvas.print_figure.
-
- Logical examples include: bbox_inches, quality (for jpeg figures), etc.
- """
- ).tag(config=True)
- _print_figure_kwargs_changed = _update_figure_formatters
-
- close_figures = Bool(
- True,
- help="""Close all figures at the end of each cell.
-
- When True, ensures that each cell starts with no active figures, but it
- also means that one must keep track of references in order to edit or
- redraw figures in subsequent cells. This mode is ideal for the notebook,
- where residual plots from other cells might be surprising.
-
- When False, one must call figure() to create new figures. This means
- that gcf() and getfigs() can reference figures created in other cells,
- and the active figure can continue to be edited with pylab/pyplot
- methods that reference the current active figure. This mode facilitates
- iterative editing of figures, and behaves most consistently with
- other matplotlib backends, but figure barriers between cells must
- be explicit.
- """).tag(config=True)
-
- shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',
- allow_none=True)
+"""Configurable for configuring the IPython inline backend
+
+This module does not import anything from matplotlib.
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the BSD 3-Clause License.
+
+from traitlets.config.configurable import SingletonConfigurable
+from traitlets import (
+ Dict, Instance, Set, Bool, TraitError, Unicode
+)
+
+
+# Configurable for inline backend options
+def pil_available():
+ """Test if PIL/Pillow is available"""
+ out = False
+ try:
+ from PIL import Image # noqa
+ out = True
+ except ImportError:
+ pass
+ return out
+
+
+# Inherit from InlineBackendConfig for deprecation purposes
+class InlineBackendConfig(SingletonConfigurable):
+ pass
+
+
+class InlineBackend(InlineBackendConfig):
+ """An object to store configuration of the inline backend."""
+
+ # The typical default figure size is too large for inline use,
+ # so we shrink the figure size to 6x4, and tweak fonts to
+ # make that fit.
+ rc = Dict(
+ {
+ 'figure.figsize': (6.0, 4.0),
+ # play nicely with white background in the Qt and notebook frontend
+ 'figure.facecolor': (1, 1, 1, 0),
+ 'figure.edgecolor': (1, 1, 1, 0),
+ # 12pt labels get cutoff on 6x4 logplots, so use 10pt.
+ 'font.size': 10,
+ # 72 dpi matches SVG/qtconsole
+ # this only affects PNG export, as SVG has no dpi setting
+ 'figure.dpi': 72,
+ # 10pt still needs a little more room on the xlabel:
+ 'figure.subplot.bottom': .125
+ },
+ help="""Subset of matplotlib rcParams that should be different for the
+ inline backend."""
+ ).tag(config=True)
+
+ figure_formats = Set(
+ {'png'},
+ help="""A set of figure formats to enable: 'png',
+ 'retina', 'jpeg', 'svg', 'pdf'.""").tag(config=True)
+
+ def _update_figure_formatters(self):
+ if self.shell is not None:
+ from IPython.core.pylabtools import select_figure_formats
+ select_figure_formats(self.shell, self.figure_formats, **self.print_figure_kwargs)
+
+ def _figure_formats_changed(self, name, old, new):
+ if 'jpg' in new or 'jpeg' in new:
+ if not pil_available():
+ raise TraitError("Requires PIL/Pillow for JPG figures")
+ self._update_figure_formatters()
+
+ figure_format = Unicode(help="""The figure format to enable (deprecated
+ use `figure_formats` instead)""").tag(config=True)
+
+ def _figure_format_changed(self, name, old, new):
+ if new:
+ self.figure_formats = {new}
+
+ print_figure_kwargs = Dict(
+ {'bbox_inches': 'tight'},
+ help="""Extra kwargs to be passed to fig.canvas.print_figure.
+
+ Logical examples include: bbox_inches, quality (for jpeg figures), etc.
+ """
+ ).tag(config=True)
+ _print_figure_kwargs_changed = _update_figure_formatters
+
+ close_figures = Bool(
+ True,
+ help="""Close all figures at the end of each cell.
+
+ When True, ensures that each cell starts with no active figures, but it
+ also means that one must keep track of references in order to edit or
+ redraw figures in subsequent cells. This mode is ideal for the notebook,
+ where residual plots from other cells might be surprising.
+
+ When False, one must call figure() to create new figures. This means
+ that gcf() and getfigs() can reference figures created in other cells,
+ and the active figure can continue to be edited with pylab/pyplot
+ methods that reference the current active figure. This mode facilitates
+ iterative editing of figures, and behaves most consistently with
+ other matplotlib backends, but figure barriers between cells must
+ be explicit.
+ """).tag(config=True)
+
+ shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',
+ allow_none=True)
--
cgit v1.2.3