##// END OF EJS Templates
MNT: add 'widget' as alias for ipympl
Thomas A Caswell -
Show More
@@ -1,408 +1,409 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Pylab (matplotlib) support utilities."""
2 """Pylab (matplotlib) support utilities."""
3
3
4 # Copyright (c) IPython Development Team.
4 # Copyright (c) IPython Development Team.
5 # Distributed under the terms of the Modified BSD License.
5 # Distributed under the terms of the Modified BSD License.
6
6
7 from io import BytesIO
7 from io import BytesIO
8
8
9 from IPython.core.display import _pngxy
9 from IPython.core.display import _pngxy
10 from IPython.utils.decorators import flag_calls
10 from IPython.utils.decorators import flag_calls
11
11
12 # If user specifies a GUI, that dictates the backend, otherwise we read the
12 # If user specifies a GUI, that dictates the backend, otherwise we read the
13 # user's mpl default from the mpl rc structure
13 # user's mpl default from the mpl rc structure
14 backends = {'tk': 'TkAgg',
14 backends = {'tk': 'TkAgg',
15 'gtk': 'GTKAgg',
15 'gtk': 'GTKAgg',
16 'gtk3': 'GTK3Agg',
16 'gtk3': 'GTK3Agg',
17 'wx': 'WXAgg',
17 'wx': 'WXAgg',
18 'qt': 'Qt4Agg', # qt3 not supported
18 'qt': 'Qt4Agg', # qt3 not supported
19 'qt4': 'Qt4Agg',
19 'qt4': 'Qt4Agg',
20 'qt5': 'Qt5Agg',
20 'qt5': 'Qt5Agg',
21 'osx': 'MacOSX',
21 'osx': 'MacOSX',
22 'nbagg': 'nbAgg',
22 'nbagg': 'nbAgg',
23 'notebook': 'nbAgg',
23 'notebook': 'nbAgg',
24 'agg': 'agg',
24 'agg': 'agg',
25 'inline': 'module://ipykernel.pylab.backend_inline',
25 'inline': 'module://ipykernel.pylab.backend_inline',
26 'ipympl': 'module://ipympl.backend_nbagg',
26 'ipympl': 'module://ipympl.backend_nbagg',
27 'widget': 'module://ipympl.backend_nbagg',
27 }
28 }
28
29
29 # We also need a reverse backends2guis mapping that will properly choose which
30 # We also need a reverse backends2guis mapping that will properly choose which
30 # GUI support to activate based on the desired matplotlib backend. For the
31 # GUI support to activate based on the desired matplotlib backend. For the
31 # most part it's just a reverse of the above dict, but we also need to add a
32 # most part it's just a reverse of the above dict, but we also need to add a
32 # few others that map to the same GUI manually:
33 # few others that map to the same GUI manually:
33 backend2gui = dict(zip(backends.values(), backends.keys()))
34 backend2gui = dict(zip(backends.values(), backends.keys()))
34 # Our tests expect backend2gui to just return 'qt'
35 # Our tests expect backend2gui to just return 'qt'
35 backend2gui['Qt4Agg'] = 'qt'
36 backend2gui['Qt4Agg'] = 'qt'
36 # In the reverse mapping, there are a few extra valid matplotlib backends that
37 # In the reverse mapping, there are a few extra valid matplotlib backends that
37 # map to the same GUI support
38 # map to the same GUI support
38 backend2gui['GTK'] = backend2gui['GTKCairo'] = 'gtk'
39 backend2gui['GTK'] = backend2gui['GTKCairo'] = 'gtk'
39 backend2gui['GTK3Cairo'] = 'gtk3'
40 backend2gui['GTK3Cairo'] = 'gtk3'
40 backend2gui['WX'] = 'wx'
41 backend2gui['WX'] = 'wx'
41 backend2gui['CocoaAgg'] = 'osx'
42 backend2gui['CocoaAgg'] = 'osx'
42 # And some backends that don't need GUI integration
43 # And some backends that don't need GUI integration
43 del backend2gui['nbAgg']
44 del backend2gui['nbAgg']
44 del backend2gui['agg']
45 del backend2gui['agg']
45 del backend2gui['module://ipykernel.pylab.backend_inline']
46 del backend2gui['module://ipykernel.pylab.backend_inline']
46
47
47 #-----------------------------------------------------------------------------
48 #-----------------------------------------------------------------------------
48 # Matplotlib utilities
49 # Matplotlib utilities
49 #-----------------------------------------------------------------------------
50 #-----------------------------------------------------------------------------
50
51
51
52
52 def getfigs(*fig_nums):
53 def getfigs(*fig_nums):
53 """Get a list of matplotlib figures by figure numbers.
54 """Get a list of matplotlib figures by figure numbers.
54
55
55 If no arguments are given, all available figures are returned. If the
56 If no arguments are given, all available figures are returned. If the
56 argument list contains references to invalid figures, a warning is printed
57 argument list contains references to invalid figures, a warning is printed
57 but the function continues pasting further figures.
58 but the function continues pasting further figures.
58
59
59 Parameters
60 Parameters
60 ----------
61 ----------
61 figs : tuple
62 figs : tuple
62 A tuple of ints giving the figure numbers of the figures to return.
63 A tuple of ints giving the figure numbers of the figures to return.
63 """
64 """
64 from matplotlib._pylab_helpers import Gcf
65 from matplotlib._pylab_helpers import Gcf
65 if not fig_nums:
66 if not fig_nums:
66 fig_managers = Gcf.get_all_fig_managers()
67 fig_managers = Gcf.get_all_fig_managers()
67 return [fm.canvas.figure for fm in fig_managers]
68 return [fm.canvas.figure for fm in fig_managers]
68 else:
69 else:
69 figs = []
70 figs = []
70 for num in fig_nums:
71 for num in fig_nums:
71 f = Gcf.figs.get(num)
72 f = Gcf.figs.get(num)
72 if f is None:
73 if f is None:
73 print('Warning: figure %s not available.' % num)
74 print('Warning: figure %s not available.' % num)
74 else:
75 else:
75 figs.append(f.canvas.figure)
76 figs.append(f.canvas.figure)
76 return figs
77 return figs
77
78
78
79
79 def figsize(sizex, sizey):
80 def figsize(sizex, sizey):
80 """Set the default figure size to be [sizex, sizey].
81 """Set the default figure size to be [sizex, sizey].
81
82
82 This is just an easy to remember, convenience wrapper that sets::
83 This is just an easy to remember, convenience wrapper that sets::
83
84
84 matplotlib.rcParams['figure.figsize'] = [sizex, sizey]
85 matplotlib.rcParams['figure.figsize'] = [sizex, sizey]
85 """
86 """
86 import matplotlib
87 import matplotlib
87 matplotlib.rcParams['figure.figsize'] = [sizex, sizey]
88 matplotlib.rcParams['figure.figsize'] = [sizex, sizey]
88
89
89
90
90 def print_figure(fig, fmt='png', bbox_inches='tight', **kwargs):
91 def print_figure(fig, fmt='png', bbox_inches='tight', **kwargs):
91 """Print a figure to an image, and return the resulting file data
92 """Print a figure to an image, and return the resulting file data
92
93
93 Returned data will be bytes unless ``fmt='svg'``,
94 Returned data will be bytes unless ``fmt='svg'``,
94 in which case it will be unicode.
95 in which case it will be unicode.
95
96
96 Any keyword args are passed to fig.canvas.print_figure,
97 Any keyword args are passed to fig.canvas.print_figure,
97 such as ``quality`` or ``bbox_inches``.
98 such as ``quality`` or ``bbox_inches``.
98 """
99 """
99 # When there's an empty figure, we shouldn't return anything, otherwise we
100 # When there's an empty figure, we shouldn't return anything, otherwise we
100 # get big blank areas in the qt console.
101 # get big blank areas in the qt console.
101 if not fig.axes and not fig.lines:
102 if not fig.axes and not fig.lines:
102 return
103 return
103
104
104 dpi = fig.dpi
105 dpi = fig.dpi
105 if fmt == 'retina':
106 if fmt == 'retina':
106 dpi = dpi * 2
107 dpi = dpi * 2
107 fmt = 'png'
108 fmt = 'png'
108
109
109 # build keyword args
110 # build keyword args
110 kw = {
111 kw = {
111 "format":fmt,
112 "format":fmt,
112 "facecolor":fig.get_facecolor(),
113 "facecolor":fig.get_facecolor(),
113 "edgecolor":fig.get_edgecolor(),
114 "edgecolor":fig.get_edgecolor(),
114 "dpi":dpi,
115 "dpi":dpi,
115 "bbox_inches":bbox_inches,
116 "bbox_inches":bbox_inches,
116 }
117 }
117 # **kwargs get higher priority
118 # **kwargs get higher priority
118 kw.update(kwargs)
119 kw.update(kwargs)
119
120
120 bytes_io = BytesIO()
121 bytes_io = BytesIO()
121 fig.canvas.print_figure(bytes_io, **kw)
122 fig.canvas.print_figure(bytes_io, **kw)
122 data = bytes_io.getvalue()
123 data = bytes_io.getvalue()
123 if fmt == 'svg':
124 if fmt == 'svg':
124 data = data.decode('utf-8')
125 data = data.decode('utf-8')
125 return data
126 return data
126
127
127 def retina_figure(fig, **kwargs):
128 def retina_figure(fig, **kwargs):
128 """format a figure as a pixel-doubled (retina) PNG"""
129 """format a figure as a pixel-doubled (retina) PNG"""
129 pngdata = print_figure(fig, fmt='retina', **kwargs)
130 pngdata = print_figure(fig, fmt='retina', **kwargs)
130 # Make sure that retina_figure acts just like print_figure and returns
131 # Make sure that retina_figure acts just like print_figure and returns
131 # None when the figure is empty.
132 # None when the figure is empty.
132 if pngdata is None:
133 if pngdata is None:
133 return
134 return
134 w, h = _pngxy(pngdata)
135 w, h = _pngxy(pngdata)
135 metadata = {"width": w//2, "height":h//2}
136 metadata = {"width": w//2, "height":h//2}
136 return pngdata, metadata
137 return pngdata, metadata
137
138
138 # We need a little factory function here to create the closure where
139 # We need a little factory function here to create the closure where
139 # safe_execfile can live.
140 # safe_execfile can live.
140 def mpl_runner(safe_execfile):
141 def mpl_runner(safe_execfile):
141 """Factory to return a matplotlib-enabled runner for %run.
142 """Factory to return a matplotlib-enabled runner for %run.
142
143
143 Parameters
144 Parameters
144 ----------
145 ----------
145 safe_execfile : function
146 safe_execfile : function
146 This must be a function with the same interface as the
147 This must be a function with the same interface as the
147 :meth:`safe_execfile` method of IPython.
148 :meth:`safe_execfile` method of IPython.
148
149
149 Returns
150 Returns
150 -------
151 -------
151 A function suitable for use as the ``runner`` argument of the %run magic
152 A function suitable for use as the ``runner`` argument of the %run magic
152 function.
153 function.
153 """
154 """
154
155
155 def mpl_execfile(fname,*where,**kw):
156 def mpl_execfile(fname,*where,**kw):
156 """matplotlib-aware wrapper around safe_execfile.
157 """matplotlib-aware wrapper around safe_execfile.
157
158
158 Its interface is identical to that of the :func:`execfile` builtin.
159 Its interface is identical to that of the :func:`execfile` builtin.
159
160
160 This is ultimately a call to execfile(), but wrapped in safeties to
161 This is ultimately a call to execfile(), but wrapped in safeties to
161 properly handle interactive rendering."""
162 properly handle interactive rendering."""
162
163
163 import matplotlib
164 import matplotlib
164 import matplotlib.pyplot as plt
165 import matplotlib.pyplot as plt
165
166
166 #print '*** Matplotlib runner ***' # dbg
167 #print '*** Matplotlib runner ***' # dbg
167 # turn off rendering until end of script
168 # turn off rendering until end of script
168 is_interactive = matplotlib.rcParams['interactive']
169 is_interactive = matplotlib.rcParams['interactive']
169 matplotlib.interactive(False)
170 matplotlib.interactive(False)
170 safe_execfile(fname,*where,**kw)
171 safe_execfile(fname,*where,**kw)
171 matplotlib.interactive(is_interactive)
172 matplotlib.interactive(is_interactive)
172 # make rendering call now, if the user tried to do it
173 # make rendering call now, if the user tried to do it
173 if plt.draw_if_interactive.called:
174 if plt.draw_if_interactive.called:
174 plt.draw()
175 plt.draw()
175 plt.draw_if_interactive.called = False
176 plt.draw_if_interactive.called = False
176
177
177 # re-draw everything that is stale
178 # re-draw everything that is stale
178 try:
179 try:
179 da = plt.draw_all
180 da = plt.draw_all
180 except AttributeError:
181 except AttributeError:
181 pass
182 pass
182 else:
183 else:
183 da()
184 da()
184
185
185 return mpl_execfile
186 return mpl_execfile
186
187
187
188
188 def _reshow_nbagg_figure(fig):
189 def _reshow_nbagg_figure(fig):
189 """reshow an nbagg figure"""
190 """reshow an nbagg figure"""
190 try:
191 try:
191 reshow = fig.canvas.manager.reshow
192 reshow = fig.canvas.manager.reshow
192 except AttributeError:
193 except AttributeError:
193 raise NotImplementedError()
194 raise NotImplementedError()
194 else:
195 else:
195 reshow()
196 reshow()
196
197
197
198
198 def select_figure_formats(shell, formats, **kwargs):
199 def select_figure_formats(shell, formats, **kwargs):
199 """Select figure formats for the inline backend.
200 """Select figure formats for the inline backend.
200
201
201 Parameters
202 Parameters
202 ==========
203 ==========
203 shell : InteractiveShell
204 shell : InteractiveShell
204 The main IPython instance.
205 The main IPython instance.
205 formats : str or set
206 formats : str or set
206 One or a set of figure formats to enable: 'png', 'retina', 'jpeg', 'svg', 'pdf'.
207 One or a set of figure formats to enable: 'png', 'retina', 'jpeg', 'svg', 'pdf'.
207 **kwargs : any
208 **kwargs : any
208 Extra keyword arguments to be passed to fig.canvas.print_figure.
209 Extra keyword arguments to be passed to fig.canvas.print_figure.
209 """
210 """
210 import matplotlib
211 import matplotlib
211 from matplotlib.figure import Figure
212 from matplotlib.figure import Figure
212
213
213 svg_formatter = shell.display_formatter.formatters['image/svg+xml']
214 svg_formatter = shell.display_formatter.formatters['image/svg+xml']
214 png_formatter = shell.display_formatter.formatters['image/png']
215 png_formatter = shell.display_formatter.formatters['image/png']
215 jpg_formatter = shell.display_formatter.formatters['image/jpeg']
216 jpg_formatter = shell.display_formatter.formatters['image/jpeg']
216 pdf_formatter = shell.display_formatter.formatters['application/pdf']
217 pdf_formatter = shell.display_formatter.formatters['application/pdf']
217
218
218 if isinstance(formats, str):
219 if isinstance(formats, str):
219 formats = {formats}
220 formats = {formats}
220 # cast in case of list / tuple
221 # cast in case of list / tuple
221 formats = set(formats)
222 formats = set(formats)
222
223
223 [ f.pop(Figure, None) for f in shell.display_formatter.formatters.values() ]
224 [ f.pop(Figure, None) for f in shell.display_formatter.formatters.values() ]
224 mplbackend = matplotlib.get_backend().lower()
225 mplbackend = matplotlib.get_backend().lower()
225 if mplbackend == 'nbagg' or mplbackend == 'module://ipympl.backend_nbagg':
226 if mplbackend == 'nbagg' or mplbackend == 'module://ipympl.backend_nbagg':
226 formatter = shell.display_formatter.ipython_display_formatter
227 formatter = shell.display_formatter.ipython_display_formatter
227 formatter.for_type(Figure, _reshow_nbagg_figure)
228 formatter.for_type(Figure, _reshow_nbagg_figure)
228
229
229 supported = {'png', 'png2x', 'retina', 'jpg', 'jpeg', 'svg', 'pdf'}
230 supported = {'png', 'png2x', 'retina', 'jpg', 'jpeg', 'svg', 'pdf'}
230 bad = formats.difference(supported)
231 bad = formats.difference(supported)
231 if bad:
232 if bad:
232 bs = "%s" % ','.join([repr(f) for f in bad])
233 bs = "%s" % ','.join([repr(f) for f in bad])
233 gs = "%s" % ','.join([repr(f) for f in supported])
234 gs = "%s" % ','.join([repr(f) for f in supported])
234 raise ValueError("supported formats are: %s not %s" % (gs, bs))
235 raise ValueError("supported formats are: %s not %s" % (gs, bs))
235
236
236 if 'png' in formats:
237 if 'png' in formats:
237 png_formatter.for_type(Figure, lambda fig: print_figure(fig, 'png', **kwargs))
238 png_formatter.for_type(Figure, lambda fig: print_figure(fig, 'png', **kwargs))
238 if 'retina' in formats or 'png2x' in formats:
239 if 'retina' in formats or 'png2x' in formats:
239 png_formatter.for_type(Figure, lambda fig: retina_figure(fig, **kwargs))
240 png_formatter.for_type(Figure, lambda fig: retina_figure(fig, **kwargs))
240 if 'jpg' in formats or 'jpeg' in formats:
241 if 'jpg' in formats or 'jpeg' in formats:
241 jpg_formatter.for_type(Figure, lambda fig: print_figure(fig, 'jpg', **kwargs))
242 jpg_formatter.for_type(Figure, lambda fig: print_figure(fig, 'jpg', **kwargs))
242 if 'svg' in formats:
243 if 'svg' in formats:
243 svg_formatter.for_type(Figure, lambda fig: print_figure(fig, 'svg', **kwargs))
244 svg_formatter.for_type(Figure, lambda fig: print_figure(fig, 'svg', **kwargs))
244 if 'pdf' in formats:
245 if 'pdf' in formats:
245 pdf_formatter.for_type(Figure, lambda fig: print_figure(fig, 'pdf', **kwargs))
246 pdf_formatter.for_type(Figure, lambda fig: print_figure(fig, 'pdf', **kwargs))
246
247
247 #-----------------------------------------------------------------------------
248 #-----------------------------------------------------------------------------
248 # Code for initializing matplotlib and importing pylab
249 # Code for initializing matplotlib and importing pylab
249 #-----------------------------------------------------------------------------
250 #-----------------------------------------------------------------------------
250
251
251
252
252 def find_gui_and_backend(gui=None, gui_select=None):
253 def find_gui_and_backend(gui=None, gui_select=None):
253 """Given a gui string return the gui and mpl backend.
254 """Given a gui string return the gui and mpl backend.
254
255
255 Parameters
256 Parameters
256 ----------
257 ----------
257 gui : str
258 gui : str
258 Can be one of ('tk','gtk','wx','qt','qt4','inline','agg').
259 Can be one of ('tk','gtk','wx','qt','qt4','inline','agg').
259 gui_select : str
260 gui_select : str
260 Can be one of ('tk','gtk','wx','qt','qt4','inline').
261 Can be one of ('tk','gtk','wx','qt','qt4','inline').
261 This is any gui already selected by the shell.
262 This is any gui already selected by the shell.
262
263
263 Returns
264 Returns
264 -------
265 -------
265 A tuple of (gui, backend) where backend is one of ('TkAgg','GTKAgg',
266 A tuple of (gui, backend) where backend is one of ('TkAgg','GTKAgg',
266 'WXAgg','Qt4Agg','module://ipykernel.pylab.backend_inline','agg').
267 'WXAgg','Qt4Agg','module://ipykernel.pylab.backend_inline','agg').
267 """
268 """
268
269
269 import matplotlib
270 import matplotlib
270
271
271 if gui and gui != 'auto':
272 if gui and gui != 'auto':
272 # select backend based on requested gui
273 # select backend based on requested gui
273 backend = backends[gui]
274 backend = backends[gui]
274 if gui == 'agg':
275 if gui == 'agg':
275 gui = None
276 gui = None
276 else:
277 else:
277 # We need to read the backend from the original data structure, *not*
278 # We need to read the backend from the original data structure, *not*
278 # from mpl.rcParams, since a prior invocation of %matplotlib may have
279 # from mpl.rcParams, since a prior invocation of %matplotlib may have
279 # overwritten that.
280 # overwritten that.
280 # WARNING: this assumes matplotlib 1.1 or newer!!
281 # WARNING: this assumes matplotlib 1.1 or newer!!
281 backend = matplotlib.rcParamsOrig['backend']
282 backend = matplotlib.rcParamsOrig['backend']
282 # In this case, we need to find what the appropriate gui selection call
283 # In this case, we need to find what the appropriate gui selection call
283 # should be for IPython, so we can activate inputhook accordingly
284 # should be for IPython, so we can activate inputhook accordingly
284 gui = backend2gui.get(backend, None)
285 gui = backend2gui.get(backend, None)
285
286
286 # If we have already had a gui active, we need it and inline are the
287 # If we have already had a gui active, we need it and inline are the
287 # ones allowed.
288 # ones allowed.
288 if gui_select and gui != gui_select:
289 if gui_select and gui != gui_select:
289 gui = gui_select
290 gui = gui_select
290 backend = backends[gui]
291 backend = backends[gui]
291
292
292 return gui, backend
293 return gui, backend
293
294
294
295
295 def activate_matplotlib(backend):
296 def activate_matplotlib(backend):
296 """Activate the given backend and set interactive to True."""
297 """Activate the given backend and set interactive to True."""
297
298
298 import matplotlib
299 import matplotlib
299 matplotlib.interactive(True)
300 matplotlib.interactive(True)
300
301
301 # Matplotlib had a bug where even switch_backend could not force
302 # Matplotlib had a bug where even switch_backend could not force
302 # the rcParam to update. This needs to be set *before* the module
303 # the rcParam to update. This needs to be set *before* the module
303 # magic of switch_backend().
304 # magic of switch_backend().
304 matplotlib.rcParams['backend'] = backend
305 matplotlib.rcParams['backend'] = backend
305
306
306 import matplotlib.pyplot
307 import matplotlib.pyplot
307 matplotlib.pyplot.switch_backend(backend)
308 matplotlib.pyplot.switch_backend(backend)
308
309
309 # This must be imported last in the matplotlib series, after
310 # This must be imported last in the matplotlib series, after
310 # backend/interactivity choices have been made
311 # backend/interactivity choices have been made
311 import matplotlib.pyplot as plt
312 import matplotlib.pyplot as plt
312
313
313 plt.show._needmain = False
314 plt.show._needmain = False
314 # We need to detect at runtime whether show() is called by the user.
315 # We need to detect at runtime whether show() is called by the user.
315 # For this, we wrap it into a decorator which adds a 'called' flag.
316 # For this, we wrap it into a decorator which adds a 'called' flag.
316 plt.draw_if_interactive = flag_calls(plt.draw_if_interactive)
317 plt.draw_if_interactive = flag_calls(plt.draw_if_interactive)
317
318
318
319
319 def import_pylab(user_ns, import_all=True):
320 def import_pylab(user_ns, import_all=True):
320 """Populate the namespace with pylab-related values.
321 """Populate the namespace with pylab-related values.
321
322
322 Imports matplotlib, pylab, numpy, and everything from pylab and numpy.
323 Imports matplotlib, pylab, numpy, and everything from pylab and numpy.
323
324
324 Also imports a few names from IPython (figsize, display, getfigs)
325 Also imports a few names from IPython (figsize, display, getfigs)
325
326
326 """
327 """
327
328
328 # Import numpy as np/pyplot as plt are conventions we're trying to
329 # Import numpy as np/pyplot as plt are conventions we're trying to
329 # somewhat standardize on. Making them available to users by default
330 # somewhat standardize on. Making them available to users by default
330 # will greatly help this.
331 # will greatly help this.
331 s = ("import numpy\n"
332 s = ("import numpy\n"
332 "import matplotlib\n"
333 "import matplotlib\n"
333 "from matplotlib import pylab, mlab, pyplot\n"
334 "from matplotlib import pylab, mlab, pyplot\n"
334 "np = numpy\n"
335 "np = numpy\n"
335 "plt = pyplot\n"
336 "plt = pyplot\n"
336 )
337 )
337 exec(s, user_ns)
338 exec(s, user_ns)
338
339
339 if import_all:
340 if import_all:
340 s = ("from matplotlib.pylab import *\n"
341 s = ("from matplotlib.pylab import *\n"
341 "from numpy import *\n")
342 "from numpy import *\n")
342 exec(s, user_ns)
343 exec(s, user_ns)
343
344
344 # IPython symbols to add
345 # IPython symbols to add
345 user_ns['figsize'] = figsize
346 user_ns['figsize'] = figsize
346 from IPython.core.display import display
347 from IPython.core.display import display
347 # Add display and getfigs to the user's namespace
348 # Add display and getfigs to the user's namespace
348 user_ns['display'] = display
349 user_ns['display'] = display
349 user_ns['getfigs'] = getfigs
350 user_ns['getfigs'] = getfigs
350
351
351
352
352 def configure_inline_support(shell, backend):
353 def configure_inline_support(shell, backend):
353 """Configure an IPython shell object for matplotlib use.
354 """Configure an IPython shell object for matplotlib use.
354
355
355 Parameters
356 Parameters
356 ----------
357 ----------
357 shell : InteractiveShell instance
358 shell : InteractiveShell instance
358
359
359 backend : matplotlib backend
360 backend : matplotlib backend
360 """
361 """
361 # If using our svg payload backend, register the post-execution
362 # If using our svg payload backend, register the post-execution
362 # function that will pick up the results for display. This can only be
363 # function that will pick up the results for display. This can only be
363 # done with access to the real shell object.
364 # done with access to the real shell object.
364
365
365 # Note: if we can't load the inline backend, then there's no point
366 # Note: if we can't load the inline backend, then there's no point
366 # continuing (such as in terminal-only shells in environments without
367 # continuing (such as in terminal-only shells in environments without
367 # zeromq available).
368 # zeromq available).
368 try:
369 try:
369 from ipykernel.pylab.backend_inline import InlineBackend
370 from ipykernel.pylab.backend_inline import InlineBackend
370 except ImportError:
371 except ImportError:
371 return
372 return
372 import matplotlib
373 import matplotlib
373
374
374 cfg = InlineBackend.instance(parent=shell)
375 cfg = InlineBackend.instance(parent=shell)
375 cfg.shell = shell
376 cfg.shell = shell
376 if cfg not in shell.configurables:
377 if cfg not in shell.configurables:
377 shell.configurables.append(cfg)
378 shell.configurables.append(cfg)
378
379
379 if backend == backends['inline']:
380 if backend == backends['inline']:
380 from ipykernel.pylab.backend_inline import flush_figures
381 from ipykernel.pylab.backend_inline import flush_figures
381 shell.events.register('post_execute', flush_figures)
382 shell.events.register('post_execute', flush_figures)
382
383
383 # Save rcParams that will be overwrittern
384 # Save rcParams that will be overwrittern
384 shell._saved_rcParams = {}
385 shell._saved_rcParams = {}
385 for k in cfg.rc:
386 for k in cfg.rc:
386 shell._saved_rcParams[k] = matplotlib.rcParams[k]
387 shell._saved_rcParams[k] = matplotlib.rcParams[k]
387 # load inline_rc
388 # load inline_rc
388 matplotlib.rcParams.update(cfg.rc)
389 matplotlib.rcParams.update(cfg.rc)
389 new_backend_name = "inline"
390 new_backend_name = "inline"
390 else:
391 else:
391 from ipykernel.pylab.backend_inline import flush_figures
392 from ipykernel.pylab.backend_inline import flush_figures
392 try:
393 try:
393 shell.events.unregister('post_execute', flush_figures)
394 shell.events.unregister('post_execute', flush_figures)
394 except ValueError:
395 except ValueError:
395 pass
396 pass
396 if hasattr(shell, '_saved_rcParams'):
397 if hasattr(shell, '_saved_rcParams'):
397 matplotlib.rcParams.update(shell._saved_rcParams)
398 matplotlib.rcParams.update(shell._saved_rcParams)
398 del shell._saved_rcParams
399 del shell._saved_rcParams
399 new_backend_name = "other"
400 new_backend_name = "other"
400
401
401 # only enable the formats once -> don't change the enabled formats (which the user may
402 # only enable the formats once -> don't change the enabled formats (which the user may
402 # has changed) when getting another "%matplotlib inline" call.
403 # has changed) when getting another "%matplotlib inline" call.
403 # See https://github.com/ipython/ipykernel/issues/29
404 # See https://github.com/ipython/ipykernel/issues/29
404 cur_backend = getattr(configure_inline_support, "current_backend", "unset")
405 cur_backend = getattr(configure_inline_support, "current_backend", "unset")
405 if new_backend_name != cur_backend:
406 if new_backend_name != cur_backend:
406 # Setup the default figure format
407 # Setup the default figure format
407 select_figure_formats(shell, cfg.figure_formats, **cfg.print_figure_kwargs)
408 select_figure_formats(shell, cfg.figure_formats, **cfg.print_figure_kwargs)
408 configure_inline_support.current_backend = new_backend_name
409 configure_inline_support.current_backend = new_backend_name
General Comments 0
You need to be logged in to leave comments. Login now