##// END OF EJS Templates
Merge pull request #12925 from Carreau/auto-backport-of-pr-12817-on-7.x...
Matthias Bussonnier -
r26503:a8955db6 merge
parent child Browse files
Show More
@@ -1,1534 +1,1556 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Top-level display functions for displaying object in different formats."""
2 """Top-level display functions for displaying object in different formats."""
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
7
8 from binascii import b2a_hex, b2a_base64, hexlify
8 from binascii import b2a_hex, b2a_base64, hexlify
9 import json
9 import json
10 import mimetypes
10 import mimetypes
11 import os
11 import os
12 import struct
12 import struct
13 import sys
13 import sys
14 import warnings
14 import warnings
15 from copy import deepcopy
15 from copy import deepcopy
16 from os.path import splitext
16 from os.path import splitext
17 from pathlib import Path, PurePath
17 from pathlib import Path, PurePath
18
18
19 from IPython.utils.py3compat import cast_unicode
19 from IPython.utils.py3compat import cast_unicode
20 from IPython.testing.skipdoctest import skip_doctest
20 from IPython.testing.skipdoctest import skip_doctest
21
21
22 __all__ = ['display', 'display_pretty', 'display_html', 'display_markdown',
22 __all__ = ['display', 'display_pretty', 'display_html', 'display_markdown',
23 'display_svg', 'display_png', 'display_jpeg', 'display_latex', 'display_json',
23 'display_svg', 'display_png', 'display_jpeg', 'display_latex', 'display_json',
24 'display_javascript', 'display_pdf', 'DisplayObject', 'TextDisplayObject',
24 'display_javascript', 'display_pdf', 'DisplayObject', 'TextDisplayObject',
25 'Pretty', 'HTML', 'Markdown', 'Math', 'Latex', 'SVG', 'ProgressBar', 'JSON',
25 'Pretty', 'HTML', 'Markdown', 'Math', 'Latex', 'SVG', 'ProgressBar', 'JSON',
26 'GeoJSON', 'Javascript', 'Image', 'clear_output', 'set_matplotlib_formats',
26 'GeoJSON', 'Javascript', 'Image', 'clear_output', 'set_matplotlib_formats',
27 'set_matplotlib_close', 'publish_display_data', 'update_display', 'DisplayHandle',
27 'set_matplotlib_close', 'publish_display_data', 'update_display', 'DisplayHandle',
28 'Video']
28 'Video']
29
29
30 #-----------------------------------------------------------------------------
30 #-----------------------------------------------------------------------------
31 # utility functions
31 # utility functions
32 #-----------------------------------------------------------------------------
32 #-----------------------------------------------------------------------------
33
33
34 def _safe_exists(path):
34 def _safe_exists(path):
35 """Check path, but don't let exceptions raise"""
35 """Check path, but don't let exceptions raise"""
36 try:
36 try:
37 return os.path.exists(path)
37 return os.path.exists(path)
38 except Exception:
38 except Exception:
39 return False
39 return False
40
40
41 def _merge(d1, d2):
41 def _merge(d1, d2):
42 """Like update, but merges sub-dicts instead of clobbering at the top level.
42 """Like update, but merges sub-dicts instead of clobbering at the top level.
43
43
44 Updates d1 in-place
44 Updates d1 in-place
45 """
45 """
46
46
47 if not isinstance(d2, dict) or not isinstance(d1, dict):
47 if not isinstance(d2, dict) or not isinstance(d1, dict):
48 return d2
48 return d2
49 for key, value in d2.items():
49 for key, value in d2.items():
50 d1[key] = _merge(d1.get(key), value)
50 d1[key] = _merge(d1.get(key), value)
51 return d1
51 return d1
52
52
53 def _display_mimetype(mimetype, objs, raw=False, metadata=None):
53 def _display_mimetype(mimetype, objs, raw=False, metadata=None):
54 """internal implementation of all display_foo methods
54 """internal implementation of all display_foo methods
55
55
56 Parameters
56 Parameters
57 ----------
57 ----------
58 mimetype : str
58 mimetype : str
59 The mimetype to be published (e.g. 'image/png')
59 The mimetype to be published (e.g. 'image/png')
60 objs : tuple of objects
60 objs : tuple of objects
61 The Python objects to display, or if raw=True raw text data to
61 The Python objects to display, or if raw=True raw text data to
62 display.
62 display.
63 raw : bool
63 raw : bool
64 Are the data objects raw data or Python objects that need to be
64 Are the data objects raw data or Python objects that need to be
65 formatted before display? [default: False]
65 formatted before display? [default: False]
66 metadata : dict (optional)
66 metadata : dict (optional)
67 Metadata to be associated with the specific mimetype output.
67 Metadata to be associated with the specific mimetype output.
68 """
68 """
69 if metadata:
69 if metadata:
70 metadata = {mimetype: metadata}
70 metadata = {mimetype: metadata}
71 if raw:
71 if raw:
72 # turn list of pngdata into list of { 'image/png': pngdata }
72 # turn list of pngdata into list of { 'image/png': pngdata }
73 objs = [ {mimetype: obj} for obj in objs ]
73 objs = [ {mimetype: obj} for obj in objs ]
74 display(*objs, raw=raw, metadata=metadata, include=[mimetype])
74 display(*objs, raw=raw, metadata=metadata, include=[mimetype])
75
75
76 #-----------------------------------------------------------------------------
76 #-----------------------------------------------------------------------------
77 # Main functions
77 # Main functions
78 #-----------------------------------------------------------------------------
78 #-----------------------------------------------------------------------------
79
79
80 # use * to indicate transient is keyword-only
80 # use * to indicate transient is keyword-only
81 def publish_display_data(data, metadata=None, source=None, *, transient=None, **kwargs):
81 def publish_display_data(data, metadata=None, source=None, *, transient=None, **kwargs):
82 """Publish data and metadata to all frontends.
82 """Publish data and metadata to all frontends.
83
83
84 See the ``display_data`` message in the messaging documentation for
84 See the ``display_data`` message in the messaging documentation for
85 more details about this message type.
85 more details about this message type.
86
86
87 Keys of data and metadata can be any mime-type.
87 Keys of data and metadata can be any mime-type.
88
88
89 Parameters
89 Parameters
90 ----------
90 ----------
91 data : dict
91 data : dict
92 A dictionary having keys that are valid MIME types (like
92 A dictionary having keys that are valid MIME types (like
93 'text/plain' or 'image/svg+xml') and values that are the data for
93 'text/plain' or 'image/svg+xml') and values that are the data for
94 that MIME type. The data itself must be a JSON'able data
94 that MIME type. The data itself must be a JSON'able data
95 structure. Minimally all data should have the 'text/plain' data,
95 structure. Minimally all data should have the 'text/plain' data,
96 which can be displayed by all frontends. If more than the plain
96 which can be displayed by all frontends. If more than the plain
97 text is given, it is up to the frontend to decide which
97 text is given, it is up to the frontend to decide which
98 representation to use.
98 representation to use.
99 metadata : dict
99 metadata : dict
100 A dictionary for metadata related to the data. This can contain
100 A dictionary for metadata related to the data. This can contain
101 arbitrary key, value pairs that frontends can use to interpret
101 arbitrary key, value pairs that frontends can use to interpret
102 the data. mime-type keys matching those in data can be used
102 the data. mime-type keys matching those in data can be used
103 to specify metadata about particular representations.
103 to specify metadata about particular representations.
104 source : str, deprecated
104 source : str, deprecated
105 Unused.
105 Unused.
106 transient : dict, keyword-only
106 transient : dict, keyword-only
107 A dictionary of transient data, such as display_id.
107 A dictionary of transient data, such as display_id.
108 """
108 """
109 from IPython.core.interactiveshell import InteractiveShell
109 from IPython.core.interactiveshell import InteractiveShell
110
110
111 display_pub = InteractiveShell.instance().display_pub
111 display_pub = InteractiveShell.instance().display_pub
112
112
113 # only pass transient if supplied,
113 # only pass transient if supplied,
114 # to avoid errors with older ipykernel.
114 # to avoid errors with older ipykernel.
115 # TODO: We could check for ipykernel version and provide a detailed upgrade message.
115 # TODO: We could check for ipykernel version and provide a detailed upgrade message.
116 if transient:
116 if transient:
117 kwargs['transient'] = transient
117 kwargs['transient'] = transient
118
118
119 display_pub.publish(
119 display_pub.publish(
120 data=data,
120 data=data,
121 metadata=metadata,
121 metadata=metadata,
122 **kwargs
122 **kwargs
123 )
123 )
124
124
125
125
126 def _new_id():
126 def _new_id():
127 """Generate a new random text id with urandom"""
127 """Generate a new random text id with urandom"""
128 return b2a_hex(os.urandom(16)).decode('ascii')
128 return b2a_hex(os.urandom(16)).decode('ascii')
129
129
130
130
131 def display(*objs, include=None, exclude=None, metadata=None, transient=None, display_id=None, **kwargs):
131 def display(*objs, include=None, exclude=None, metadata=None, transient=None, display_id=None, **kwargs):
132 """Display a Python object in all frontends.
132 """Display a Python object in all frontends.
133
133
134 By default all representations will be computed and sent to the frontends.
134 By default all representations will be computed and sent to the frontends.
135 Frontends can decide which representation is used and how.
135 Frontends can decide which representation is used and how.
136
136
137 In terminal IPython this will be similar to using :func:`print`, for use in richer
137 In terminal IPython this will be similar to using :func:`print`, for use in richer
138 frontends see Jupyter notebook examples with rich display logic.
138 frontends see Jupyter notebook examples with rich display logic.
139
139
140 Parameters
140 Parameters
141 ----------
141 ----------
142 objs : tuple of objects
142 objs : tuple of objects
143 The Python objects to display.
143 The Python objects to display.
144 raw : bool, optional
144 raw : bool, optional
145 Are the objects to be displayed already mimetype-keyed dicts of raw display data,
145 Are the objects to be displayed already mimetype-keyed dicts of raw display data,
146 or Python objects that need to be formatted before display? [default: False]
146 or Python objects that need to be formatted before display? [default: False]
147 include : list, tuple or set, optional
147 include : list, tuple or set, optional
148 A list of format type strings (MIME types) to include in the
148 A list of format type strings (MIME types) to include in the
149 format data dict. If this is set *only* the format types included
149 format data dict. If this is set *only* the format types included
150 in this list will be computed.
150 in this list will be computed.
151 exclude : list, tuple or set, optional
151 exclude : list, tuple or set, optional
152 A list of format type strings (MIME types) to exclude in the format
152 A list of format type strings (MIME types) to exclude in the format
153 data dict. If this is set all format types will be computed,
153 data dict. If this is set all format types will be computed,
154 except for those included in this argument.
154 except for those included in this argument.
155 metadata : dict, optional
155 metadata : dict, optional
156 A dictionary of metadata to associate with the output.
156 A dictionary of metadata to associate with the output.
157 mime-type keys in this dictionary will be associated with the individual
157 mime-type keys in this dictionary will be associated with the individual
158 representation formats, if they exist.
158 representation formats, if they exist.
159 transient : dict, optional
159 transient : dict, optional
160 A dictionary of transient data to associate with the output.
160 A dictionary of transient data to associate with the output.
161 Data in this dict should not be persisted to files (e.g. notebooks).
161 Data in this dict should not be persisted to files (e.g. notebooks).
162 display_id : str, bool optional
162 display_id : str, bool optional
163 Set an id for the display.
163 Set an id for the display.
164 This id can be used for updating this display area later via update_display.
164 This id can be used for updating this display area later via update_display.
165 If given as `True`, generate a new `display_id`
165 If given as `True`, generate a new `display_id`
166 clear : bool, optional
166 clear : bool, optional
167 Should the output area be cleared before displaying anything? If True,
167 Should the output area be cleared before displaying anything? If True,
168 this will wait for additional output before clearing. [default: False]
168 this will wait for additional output before clearing. [default: False]
169 kwargs: additional keyword-args, optional
169 kwargs: additional keyword-args, optional
170 Additional keyword-arguments are passed through to the display publisher.
170 Additional keyword-arguments are passed through to the display publisher.
171
171
172 Returns
172 Returns
173 -------
173 -------
174
174
175 handle: DisplayHandle
175 handle: DisplayHandle
176 Returns a handle on updatable displays for use with :func:`update_display`,
176 Returns a handle on updatable displays for use with :func:`update_display`,
177 if `display_id` is given. Returns :any:`None` if no `display_id` is given
177 if `display_id` is given. Returns :any:`None` if no `display_id` is given
178 (default).
178 (default).
179
179
180 Examples
180 Examples
181 --------
181 --------
182
182
183 >>> class Json(object):
183 >>> class Json(object):
184 ... def __init__(self, json):
184 ... def __init__(self, json):
185 ... self.json = json
185 ... self.json = json
186 ... def _repr_pretty_(self, pp, cycle):
186 ... def _repr_pretty_(self, pp, cycle):
187 ... import json
187 ... import json
188 ... pp.text(json.dumps(self.json, indent=2))
188 ... pp.text(json.dumps(self.json, indent=2))
189 ... def __repr__(self):
189 ... def __repr__(self):
190 ... return str(self.json)
190 ... return str(self.json)
191 ...
191 ...
192
192
193 >>> d = Json({1:2, 3: {4:5}})
193 >>> d = Json({1:2, 3: {4:5}})
194
194
195 >>> print(d)
195 >>> print(d)
196 {1: 2, 3: {4: 5}}
196 {1: 2, 3: {4: 5}}
197
197
198 >>> display(d)
198 >>> display(d)
199 {
199 {
200 "1": 2,
200 "1": 2,
201 "3": {
201 "3": {
202 "4": 5
202 "4": 5
203 }
203 }
204 }
204 }
205
205
206 >>> def int_formatter(integer, pp, cycle):
206 >>> def int_formatter(integer, pp, cycle):
207 ... pp.text('I'*integer)
207 ... pp.text('I'*integer)
208
208
209 >>> plain = get_ipython().display_formatter.formatters['text/plain']
209 >>> plain = get_ipython().display_formatter.formatters['text/plain']
210 >>> plain.for_type(int, int_formatter)
210 >>> plain.for_type(int, int_formatter)
211 <function _repr_pprint at 0x...>
211 <function _repr_pprint at 0x...>
212 >>> display(7-5)
212 >>> display(7-5)
213 II
213 II
214
214
215 >>> del plain.type_printers[int]
215 >>> del plain.type_printers[int]
216 >>> display(7-5)
216 >>> display(7-5)
217 2
217 2
218
218
219 See Also
219 See Also
220 --------
220 --------
221
221
222 :func:`update_display`
222 :func:`update_display`
223
223
224 Notes
224 Notes
225 -----
225 -----
226
226
227 In Python, objects can declare their textual representation using the
227 In Python, objects can declare their textual representation using the
228 `__repr__` method. IPython expands on this idea and allows objects to declare
228 `__repr__` method. IPython expands on this idea and allows objects to declare
229 other, rich representations including:
229 other, rich representations including:
230
230
231 - HTML
231 - HTML
232 - JSON
232 - JSON
233 - PNG
233 - PNG
234 - JPEG
234 - JPEG
235 - SVG
235 - SVG
236 - LaTeX
236 - LaTeX
237
237
238 A single object can declare some or all of these representations; all are
238 A single object can declare some or all of these representations; all are
239 handled by IPython's display system.
239 handled by IPython's display system.
240
240
241 The main idea of the first approach is that you have to implement special
241 The main idea of the first approach is that you have to implement special
242 display methods when you define your class, one for each representation you
242 display methods when you define your class, one for each representation you
243 want to use. Here is a list of the names of the special methods and the
243 want to use. Here is a list of the names of the special methods and the
244 values they must return:
244 values they must return:
245
245
246 - `_repr_html_`: return raw HTML as a string, or a tuple (see below).
246 - `_repr_html_`: return raw HTML as a string, or a tuple (see below).
247 - `_repr_json_`: return a JSONable dict, or a tuple (see below).
247 - `_repr_json_`: return a JSONable dict, or a tuple (see below).
248 - `_repr_jpeg_`: return raw JPEG data, or a tuple (see below).
248 - `_repr_jpeg_`: return raw JPEG data, or a tuple (see below).
249 - `_repr_png_`: return raw PNG data, or a tuple (see below).
249 - `_repr_png_`: return raw PNG data, or a tuple (see below).
250 - `_repr_svg_`: return raw SVG data as a string, or a tuple (see below).
250 - `_repr_svg_`: return raw SVG data as a string, or a tuple (see below).
251 - `_repr_latex_`: return LaTeX commands in a string surrounded by "$",
251 - `_repr_latex_`: return LaTeX commands in a string surrounded by "$",
252 or a tuple (see below).
252 or a tuple (see below).
253 - `_repr_mimebundle_`: return a full mimebundle containing the mapping
253 - `_repr_mimebundle_`: return a full mimebundle containing the mapping
254 from all mimetypes to data.
254 from all mimetypes to data.
255 Use this for any mime-type not listed above.
255 Use this for any mime-type not listed above.
256
256
257 The above functions may also return the object's metadata alonside the
257 The above functions may also return the object's metadata alonside the
258 data. If the metadata is available, the functions will return a tuple
258 data. If the metadata is available, the functions will return a tuple
259 containing the data and metadata, in that order. If there is no metadata
259 containing the data and metadata, in that order. If there is no metadata
260 available, then the functions will return the data only.
260 available, then the functions will return the data only.
261
261
262 When you are directly writing your own classes, you can adapt them for
262 When you are directly writing your own classes, you can adapt them for
263 display in IPython by following the above approach. But in practice, you
263 display in IPython by following the above approach. But in practice, you
264 often need to work with existing classes that you can't easily modify.
264 often need to work with existing classes that you can't easily modify.
265
265
266 You can refer to the documentation on integrating with the display system in
266 You can refer to the documentation on integrating with the display system in
267 order to register custom formatters for already existing types
267 order to register custom formatters for already existing types
268 (:ref:`integrating_rich_display`).
268 (:ref:`integrating_rich_display`).
269
269
270 .. versionadded:: 5.4 display available without import
270 .. versionadded:: 5.4 display available without import
271 .. versionadded:: 6.1 display available without import
271 .. versionadded:: 6.1 display available without import
272
272
273 Since IPython 5.4 and 6.1 :func:`display` is automatically made available to
273 Since IPython 5.4 and 6.1 :func:`display` is automatically made available to
274 the user without import. If you are using display in a document that might
274 the user without import. If you are using display in a document that might
275 be used in a pure python context or with older version of IPython, use the
275 be used in a pure python context or with older version of IPython, use the
276 following import at the top of your file::
276 following import at the top of your file::
277
277
278 from IPython.display import display
278 from IPython.display import display
279
279
280 """
280 """
281 from IPython.core.interactiveshell import InteractiveShell
281 from IPython.core.interactiveshell import InteractiveShell
282
282
283 if not InteractiveShell.initialized():
283 if not InteractiveShell.initialized():
284 # Directly print objects.
284 # Directly print objects.
285 print(*objs)
285 print(*objs)
286 return
286 return
287
287
288 raw = kwargs.pop("raw", False)
288 raw = kwargs.pop("raw", False)
289 clear = kwargs.pop("clear", False)
289 clear = kwargs.pop("clear", False)
290 if transient is None:
290 if transient is None:
291 transient = {}
291 transient = {}
292 if metadata is None:
292 if metadata is None:
293 metadata={}
293 metadata={}
294 if display_id:
294 if display_id:
295 if display_id is True:
295 if display_id is True:
296 display_id = _new_id()
296 display_id = _new_id()
297 transient['display_id'] = display_id
297 transient['display_id'] = display_id
298 if kwargs.get('update') and 'display_id' not in transient:
298 if kwargs.get('update') and 'display_id' not in transient:
299 raise TypeError('display_id required for update_display')
299 raise TypeError('display_id required for update_display')
300 if transient:
300 if transient:
301 kwargs['transient'] = transient
301 kwargs['transient'] = transient
302
302
303 if not objs and display_id:
303 if not objs and display_id:
304 # if given no objects, but still a request for a display_id,
304 # if given no objects, but still a request for a display_id,
305 # we assume the user wants to insert an empty output that
305 # we assume the user wants to insert an empty output that
306 # can be updated later
306 # can be updated later
307 objs = [{}]
307 objs = [{}]
308 raw = True
308 raw = True
309
309
310 if not raw:
310 if not raw:
311 format = InteractiveShell.instance().display_formatter.format
311 format = InteractiveShell.instance().display_formatter.format
312
312
313 if clear:
313 if clear:
314 clear_output(wait=True)
314 clear_output(wait=True)
315
315
316 for obj in objs:
316 for obj in objs:
317 if raw:
317 if raw:
318 publish_display_data(data=obj, metadata=metadata, **kwargs)
318 publish_display_data(data=obj, metadata=metadata, **kwargs)
319 else:
319 else:
320 format_dict, md_dict = format(obj, include=include, exclude=exclude)
320 format_dict, md_dict = format(obj, include=include, exclude=exclude)
321 if not format_dict:
321 if not format_dict:
322 # nothing to display (e.g. _ipython_display_ took over)
322 # nothing to display (e.g. _ipython_display_ took over)
323 continue
323 continue
324 if metadata:
324 if metadata:
325 # kwarg-specified metadata gets precedence
325 # kwarg-specified metadata gets precedence
326 _merge(md_dict, metadata)
326 _merge(md_dict, metadata)
327 publish_display_data(data=format_dict, metadata=md_dict, **kwargs)
327 publish_display_data(data=format_dict, metadata=md_dict, **kwargs)
328 if display_id:
328 if display_id:
329 return DisplayHandle(display_id)
329 return DisplayHandle(display_id)
330
330
331
331
332 # use * for keyword-only display_id arg
332 # use * for keyword-only display_id arg
333 def update_display(obj, *, display_id, **kwargs):
333 def update_display(obj, *, display_id, **kwargs):
334 """Update an existing display by id
334 """Update an existing display by id
335
335
336 Parameters
336 Parameters
337 ----------
337 ----------
338
338
339 obj:
339 obj:
340 The object with which to update the display
340 The object with which to update the display
341 display_id: keyword-only
341 display_id: keyword-only
342 The id of the display to update
342 The id of the display to update
343
343
344 See Also
344 See Also
345 --------
345 --------
346
346
347 :func:`display`
347 :func:`display`
348 """
348 """
349 kwargs['update'] = True
349 kwargs['update'] = True
350 display(obj, display_id=display_id, **kwargs)
350 display(obj, display_id=display_id, **kwargs)
351
351
352
352
353 class DisplayHandle(object):
353 class DisplayHandle(object):
354 """A handle on an updatable display
354 """A handle on an updatable display
355
355
356 Call `.update(obj)` to display a new object.
356 Call `.update(obj)` to display a new object.
357
357
358 Call `.display(obj`) to add a new instance of this display,
358 Call `.display(obj`) to add a new instance of this display,
359 and update existing instances.
359 and update existing instances.
360
360
361 See Also
361 See Also
362 --------
362 --------
363
363
364 :func:`display`, :func:`update_display`
364 :func:`display`, :func:`update_display`
365
365
366 """
366 """
367
367
368 def __init__(self, display_id=None):
368 def __init__(self, display_id=None):
369 if display_id is None:
369 if display_id is None:
370 display_id = _new_id()
370 display_id = _new_id()
371 self.display_id = display_id
371 self.display_id = display_id
372
372
373 def __repr__(self):
373 def __repr__(self):
374 return "<%s display_id=%s>" % (self.__class__.__name__, self.display_id)
374 return "<%s display_id=%s>" % (self.__class__.__name__, self.display_id)
375
375
376 def display(self, obj, **kwargs):
376 def display(self, obj, **kwargs):
377 """Make a new display with my id, updating existing instances.
377 """Make a new display with my id, updating existing instances.
378
378
379 Parameters
379 Parameters
380 ----------
380 ----------
381
381
382 obj:
382 obj:
383 object to display
383 object to display
384 **kwargs:
384 **kwargs:
385 additional keyword arguments passed to display
385 additional keyword arguments passed to display
386 """
386 """
387 display(obj, display_id=self.display_id, **kwargs)
387 display(obj, display_id=self.display_id, **kwargs)
388
388
389 def update(self, obj, **kwargs):
389 def update(self, obj, **kwargs):
390 """Update existing displays with my id
390 """Update existing displays with my id
391
391
392 Parameters
392 Parameters
393 ----------
393 ----------
394
394
395 obj:
395 obj:
396 object to display
396 object to display
397 **kwargs:
397 **kwargs:
398 additional keyword arguments passed to update_display
398 additional keyword arguments passed to update_display
399 """
399 """
400 update_display(obj, display_id=self.display_id, **kwargs)
400 update_display(obj, display_id=self.display_id, **kwargs)
401
401
402
402
403 def display_pretty(*objs, **kwargs):
403 def display_pretty(*objs, **kwargs):
404 """Display the pretty (default) representation of an object.
404 """Display the pretty (default) representation of an object.
405
405
406 Parameters
406 Parameters
407 ----------
407 ----------
408 objs : tuple of objects
408 objs : tuple of objects
409 The Python objects to display, or if raw=True raw text data to
409 The Python objects to display, or if raw=True raw text data to
410 display.
410 display.
411 raw : bool
411 raw : bool
412 Are the data objects raw data or Python objects that need to be
412 Are the data objects raw data or Python objects that need to be
413 formatted before display? [default: False]
413 formatted before display? [default: False]
414 metadata : dict (optional)
414 metadata : dict (optional)
415 Metadata to be associated with the specific mimetype output.
415 Metadata to be associated with the specific mimetype output.
416 """
416 """
417 _display_mimetype('text/plain', objs, **kwargs)
417 _display_mimetype('text/plain', objs, **kwargs)
418
418
419
419
420 def display_html(*objs, **kwargs):
420 def display_html(*objs, **kwargs):
421 """Display the HTML representation of an object.
421 """Display the HTML representation of an object.
422
422
423 Note: If raw=False and the object does not have a HTML
423 Note: If raw=False and the object does not have a HTML
424 representation, no HTML will be shown.
424 representation, no HTML will be shown.
425
425
426 Parameters
426 Parameters
427 ----------
427 ----------
428 objs : tuple of objects
428 objs : tuple of objects
429 The Python objects to display, or if raw=True raw HTML data to
429 The Python objects to display, or if raw=True raw HTML data to
430 display.
430 display.
431 raw : bool
431 raw : bool
432 Are the data objects raw data or Python objects that need to be
432 Are the data objects raw data or Python objects that need to be
433 formatted before display? [default: False]
433 formatted before display? [default: False]
434 metadata : dict (optional)
434 metadata : dict (optional)
435 Metadata to be associated with the specific mimetype output.
435 Metadata to be associated with the specific mimetype output.
436 """
436 """
437 _display_mimetype('text/html', objs, **kwargs)
437 _display_mimetype('text/html', objs, **kwargs)
438
438
439
439
440 def display_markdown(*objs, **kwargs):
440 def display_markdown(*objs, **kwargs):
441 """Displays the Markdown representation of an object.
441 """Displays the Markdown representation of an object.
442
442
443 Parameters
443 Parameters
444 ----------
444 ----------
445 objs : tuple of objects
445 objs : tuple of objects
446 The Python objects to display, or if raw=True raw markdown data to
446 The Python objects to display, or if raw=True raw markdown data to
447 display.
447 display.
448 raw : bool
448 raw : bool
449 Are the data objects raw data or Python objects that need to be
449 Are the data objects raw data or Python objects that need to be
450 formatted before display? [default: False]
450 formatted before display? [default: False]
451 metadata : dict (optional)
451 metadata : dict (optional)
452 Metadata to be associated with the specific mimetype output.
452 Metadata to be associated with the specific mimetype output.
453 """
453 """
454
454
455 _display_mimetype('text/markdown', objs, **kwargs)
455 _display_mimetype('text/markdown', objs, **kwargs)
456
456
457
457
458 def display_svg(*objs, **kwargs):
458 def display_svg(*objs, **kwargs):
459 """Display the SVG representation of an object.
459 """Display the SVG representation of an object.
460
460
461 Parameters
461 Parameters
462 ----------
462 ----------
463 objs : tuple of objects
463 objs : tuple of objects
464 The Python objects to display, or if raw=True raw svg data to
464 The Python objects to display, or if raw=True raw svg data to
465 display.
465 display.
466 raw : bool
466 raw : bool
467 Are the data objects raw data or Python objects that need to be
467 Are the data objects raw data or Python objects that need to be
468 formatted before display? [default: False]
468 formatted before display? [default: False]
469 metadata : dict (optional)
469 metadata : dict (optional)
470 Metadata to be associated with the specific mimetype output.
470 Metadata to be associated with the specific mimetype output.
471 """
471 """
472 _display_mimetype('image/svg+xml', objs, **kwargs)
472 _display_mimetype('image/svg+xml', objs, **kwargs)
473
473
474
474
475 def display_png(*objs, **kwargs):
475 def display_png(*objs, **kwargs):
476 """Display the PNG representation of an object.
476 """Display the PNG representation of an object.
477
477
478 Parameters
478 Parameters
479 ----------
479 ----------
480 objs : tuple of objects
480 objs : tuple of objects
481 The Python objects to display, or if raw=True raw png data to
481 The Python objects to display, or if raw=True raw png data to
482 display.
482 display.
483 raw : bool
483 raw : bool
484 Are the data objects raw data or Python objects that need to be
484 Are the data objects raw data or Python objects that need to be
485 formatted before display? [default: False]
485 formatted before display? [default: False]
486 metadata : dict (optional)
486 metadata : dict (optional)
487 Metadata to be associated with the specific mimetype output.
487 Metadata to be associated with the specific mimetype output.
488 """
488 """
489 _display_mimetype('image/png', objs, **kwargs)
489 _display_mimetype('image/png', objs, **kwargs)
490
490
491
491
492 def display_jpeg(*objs, **kwargs):
492 def display_jpeg(*objs, **kwargs):
493 """Display the JPEG representation of an object.
493 """Display the JPEG representation of an object.
494
494
495 Parameters
495 Parameters
496 ----------
496 ----------
497 objs : tuple of objects
497 objs : tuple of objects
498 The Python objects to display, or if raw=True raw JPEG data to
498 The Python objects to display, or if raw=True raw JPEG data to
499 display.
499 display.
500 raw : bool
500 raw : bool
501 Are the data objects raw data or Python objects that need to be
501 Are the data objects raw data or Python objects that need to be
502 formatted before display? [default: False]
502 formatted before display? [default: False]
503 metadata : dict (optional)
503 metadata : dict (optional)
504 Metadata to be associated with the specific mimetype output.
504 Metadata to be associated with the specific mimetype output.
505 """
505 """
506 _display_mimetype('image/jpeg', objs, **kwargs)
506 _display_mimetype('image/jpeg', objs, **kwargs)
507
507
508
508
509 def display_latex(*objs, **kwargs):
509 def display_latex(*objs, **kwargs):
510 """Display the LaTeX representation of an object.
510 """Display the LaTeX representation of an object.
511
511
512 Parameters
512 Parameters
513 ----------
513 ----------
514 objs : tuple of objects
514 objs : tuple of objects
515 The Python objects to display, or if raw=True raw latex data to
515 The Python objects to display, or if raw=True raw latex data to
516 display.
516 display.
517 raw : bool
517 raw : bool
518 Are the data objects raw data or Python objects that need to be
518 Are the data objects raw data or Python objects that need to be
519 formatted before display? [default: False]
519 formatted before display? [default: False]
520 metadata : dict (optional)
520 metadata : dict (optional)
521 Metadata to be associated with the specific mimetype output.
521 Metadata to be associated with the specific mimetype output.
522 """
522 """
523 _display_mimetype('text/latex', objs, **kwargs)
523 _display_mimetype('text/latex', objs, **kwargs)
524
524
525
525
526 def display_json(*objs, **kwargs):
526 def display_json(*objs, **kwargs):
527 """Display the JSON representation of an object.
527 """Display the JSON representation of an object.
528
528
529 Note that not many frontends support displaying JSON.
529 Note that not many frontends support displaying JSON.
530
530
531 Parameters
531 Parameters
532 ----------
532 ----------
533 objs : tuple of objects
533 objs : tuple of objects
534 The Python objects to display, or if raw=True raw json data to
534 The Python objects to display, or if raw=True raw json data to
535 display.
535 display.
536 raw : bool
536 raw : bool
537 Are the data objects raw data or Python objects that need to be
537 Are the data objects raw data or Python objects that need to be
538 formatted before display? [default: False]
538 formatted before display? [default: False]
539 metadata : dict (optional)
539 metadata : dict (optional)
540 Metadata to be associated with the specific mimetype output.
540 Metadata to be associated with the specific mimetype output.
541 """
541 """
542 _display_mimetype('application/json', objs, **kwargs)
542 _display_mimetype('application/json', objs, **kwargs)
543
543
544
544
545 def display_javascript(*objs, **kwargs):
545 def display_javascript(*objs, **kwargs):
546 """Display the Javascript representation of an object.
546 """Display the Javascript representation of an object.
547
547
548 Parameters
548 Parameters
549 ----------
549 ----------
550 objs : tuple of objects
550 objs : tuple of objects
551 The Python objects to display, or if raw=True raw javascript data to
551 The Python objects to display, or if raw=True raw javascript data to
552 display.
552 display.
553 raw : bool
553 raw : bool
554 Are the data objects raw data or Python objects that need to be
554 Are the data objects raw data or Python objects that need to be
555 formatted before display? [default: False]
555 formatted before display? [default: False]
556 metadata : dict (optional)
556 metadata : dict (optional)
557 Metadata to be associated with the specific mimetype output.
557 Metadata to be associated with the specific mimetype output.
558 """
558 """
559 _display_mimetype('application/javascript', objs, **kwargs)
559 _display_mimetype('application/javascript', objs, **kwargs)
560
560
561
561
562 def display_pdf(*objs, **kwargs):
562 def display_pdf(*objs, **kwargs):
563 """Display the PDF representation of an object.
563 """Display the PDF representation of an object.
564
564
565 Parameters
565 Parameters
566 ----------
566 ----------
567 objs : tuple of objects
567 objs : tuple of objects
568 The Python objects to display, or if raw=True raw javascript data to
568 The Python objects to display, or if raw=True raw javascript data to
569 display.
569 display.
570 raw : bool
570 raw : bool
571 Are the data objects raw data or Python objects that need to be
571 Are the data objects raw data or Python objects that need to be
572 formatted before display? [default: False]
572 formatted before display? [default: False]
573 metadata : dict (optional)
573 metadata : dict (optional)
574 Metadata to be associated with the specific mimetype output.
574 Metadata to be associated with the specific mimetype output.
575 """
575 """
576 _display_mimetype('application/pdf', objs, **kwargs)
576 _display_mimetype('application/pdf', objs, **kwargs)
577
577
578
578
579 #-----------------------------------------------------------------------------
579 #-----------------------------------------------------------------------------
580 # Smart classes
580 # Smart classes
581 #-----------------------------------------------------------------------------
581 #-----------------------------------------------------------------------------
582
582
583
583
584 class DisplayObject(object):
584 class DisplayObject(object):
585 """An object that wraps data to be displayed."""
585 """An object that wraps data to be displayed."""
586
586
587 _read_flags = 'r'
587 _read_flags = 'r'
588 _show_mem_addr = False
588 _show_mem_addr = False
589 metadata = None
589 metadata = None
590
590
591 def __init__(self, data=None, url=None, filename=None, metadata=None):
591 def __init__(self, data=None, url=None, filename=None, metadata=None):
592 """Create a display object given raw data.
592 """Create a display object given raw data.
593
593
594 When this object is returned by an expression or passed to the
594 When this object is returned by an expression or passed to the
595 display function, it will result in the data being displayed
595 display function, it will result in the data being displayed
596 in the frontend. The MIME type of the data should match the
596 in the frontend. The MIME type of the data should match the
597 subclasses used, so the Png subclass should be used for 'image/png'
597 subclasses used, so the Png subclass should be used for 'image/png'
598 data. If the data is a URL, the data will first be downloaded
598 data. If the data is a URL, the data will first be downloaded
599 and then displayed. If
599 and then displayed. If
600
600
601 Parameters
601 Parameters
602 ----------
602 ----------
603 data : unicode, str or bytes
603 data : unicode, str or bytes
604 The raw data or a URL or file to load the data from
604 The raw data or a URL or file to load the data from
605 url : unicode
605 url : unicode
606 A URL to download the data from.
606 A URL to download the data from.
607 filename : unicode
607 filename : unicode
608 Path to a local file to load the data from.
608 Path to a local file to load the data from.
609 metadata : dict
609 metadata : dict
610 Dict of metadata associated to be the object when displayed
610 Dict of metadata associated to be the object when displayed
611 """
611 """
612 if isinstance(data, (Path, PurePath)):
612 if isinstance(data, (Path, PurePath)):
613 data = str(data)
613 data = str(data)
614
614
615 if data is not None and isinstance(data, str):
615 if data is not None and isinstance(data, str):
616 if data.startswith('http') and url is None:
616 if data.startswith('http') and url is None:
617 url = data
617 url = data
618 filename = None
618 filename = None
619 data = None
619 data = None
620 elif _safe_exists(data) and filename is None:
620 elif _safe_exists(data) and filename is None:
621 url = None
621 url = None
622 filename = data
622 filename = data
623 data = None
623 data = None
624
624
625 self.url = url
625 self.url = url
626 self.filename = filename
626 self.filename = filename
627 # because of @data.setter methods in
627 # because of @data.setter methods in
628 # subclasses ensure url and filename are set
628 # subclasses ensure url and filename are set
629 # before assigning to self.data
629 # before assigning to self.data
630 self.data = data
630 self.data = data
631
631
632 if metadata is not None:
632 if metadata is not None:
633 self.metadata = metadata
633 self.metadata = metadata
634 elif self.metadata is None:
634 elif self.metadata is None:
635 self.metadata = {}
635 self.metadata = {}
636
636
637 self.reload()
637 self.reload()
638 self._check_data()
638 self._check_data()
639
639
640 def __repr__(self):
640 def __repr__(self):
641 if not self._show_mem_addr:
641 if not self._show_mem_addr:
642 cls = self.__class__
642 cls = self.__class__
643 r = "<%s.%s object>" % (cls.__module__, cls.__name__)
643 r = "<%s.%s object>" % (cls.__module__, cls.__name__)
644 else:
644 else:
645 r = super(DisplayObject, self).__repr__()
645 r = super(DisplayObject, self).__repr__()
646 return r
646 return r
647
647
648 def _check_data(self):
648 def _check_data(self):
649 """Override in subclasses if there's something to check."""
649 """Override in subclasses if there's something to check."""
650 pass
650 pass
651
651
652 def _data_and_metadata(self):
652 def _data_and_metadata(self):
653 """shortcut for returning metadata with shape information, if defined"""
653 """shortcut for returning metadata with shape information, if defined"""
654 if self.metadata:
654 if self.metadata:
655 return self.data, deepcopy(self.metadata)
655 return self.data, deepcopy(self.metadata)
656 else:
656 else:
657 return self.data
657 return self.data
658
658
659 def reload(self):
659 def reload(self):
660 """Reload the raw data from file or URL."""
660 """Reload the raw data from file or URL."""
661 if self.filename is not None:
661 if self.filename is not None:
662 with open(self.filename, self._read_flags) as f:
662 with open(self.filename, self._read_flags) as f:
663 self.data = f.read()
663 self.data = f.read()
664 elif self.url is not None:
664 elif self.url is not None:
665 # Deferred import
665 # Deferred import
666 from urllib.request import urlopen
666 from urllib.request import urlopen
667 response = urlopen(self.url)
667 response = urlopen(self.url)
668 data = response.read()
668 data = response.read()
669 # extract encoding from header, if there is one:
669 # extract encoding from header, if there is one:
670 encoding = None
670 encoding = None
671 if 'content-type' in response.headers:
671 if 'content-type' in response.headers:
672 for sub in response.headers['content-type'].split(';'):
672 for sub in response.headers['content-type'].split(';'):
673 sub = sub.strip()
673 sub = sub.strip()
674 if sub.startswith('charset'):
674 if sub.startswith('charset'):
675 encoding = sub.split('=')[-1].strip()
675 encoding = sub.split('=')[-1].strip()
676 break
676 break
677 if 'content-encoding' in response.headers:
677 if 'content-encoding' in response.headers:
678 # TODO: do deflate?
678 # TODO: do deflate?
679 if 'gzip' in response.headers['content-encoding']:
679 if 'gzip' in response.headers['content-encoding']:
680 import gzip
680 import gzip
681 from io import BytesIO
681 from io import BytesIO
682 with gzip.open(BytesIO(data), 'rt', encoding=encoding) as fp:
682 with gzip.open(BytesIO(data), 'rt', encoding=encoding) as fp:
683 encoding = None
683 encoding = None
684 data = fp.read()
684 data = fp.read()
685
685
686 # decode data, if an encoding was specified
686 # decode data, if an encoding was specified
687 # We only touch self.data once since
687 # We only touch self.data once since
688 # subclasses such as SVG have @data.setter methods
688 # subclasses such as SVG have @data.setter methods
689 # that transform self.data into ... well svg.
689 # that transform self.data into ... well svg.
690 if encoding:
690 if encoding:
691 self.data = data.decode(encoding, 'replace')
691 self.data = data.decode(encoding, 'replace')
692 else:
692 else:
693 self.data = data
693 self.data = data
694
694
695
695
696 class TextDisplayObject(DisplayObject):
696 class TextDisplayObject(DisplayObject):
697 """Validate that display data is text"""
697 """Validate that display data is text"""
698 def _check_data(self):
698 def _check_data(self):
699 if self.data is not None and not isinstance(self.data, str):
699 if self.data is not None and not isinstance(self.data, str):
700 raise TypeError("%s expects text, not %r" % (self.__class__.__name__, self.data))
700 raise TypeError("%s expects text, not %r" % (self.__class__.__name__, self.data))
701
701
702 class Pretty(TextDisplayObject):
702 class Pretty(TextDisplayObject):
703
703
704 def _repr_pretty_(self, pp, cycle):
704 def _repr_pretty_(self, pp, cycle):
705 return pp.text(self.data)
705 return pp.text(self.data)
706
706
707
707
708 class HTML(TextDisplayObject):
708 class HTML(TextDisplayObject):
709
709
710 def __init__(self, data=None, url=None, filename=None, metadata=None):
710 def __init__(self, data=None, url=None, filename=None, metadata=None):
711 def warn():
711 def warn():
712 if not data:
712 if not data:
713 return False
713 return False
714
714
715 #
715 #
716 # Avoid calling lower() on the entire data, because it could be a
716 # Avoid calling lower() on the entire data, because it could be a
717 # long string and we're only interested in its beginning and end.
717 # long string and we're only interested in its beginning and end.
718 #
718 #
719 prefix = data[:10].lower()
719 prefix = data[:10].lower()
720 suffix = data[-10:].lower()
720 suffix = data[-10:].lower()
721 return prefix.startswith("<iframe ") and suffix.endswith("</iframe>")
721 return prefix.startswith("<iframe ") and suffix.endswith("</iframe>")
722
722
723 if warn():
723 if warn():
724 warnings.warn("Consider using IPython.display.IFrame instead")
724 warnings.warn("Consider using IPython.display.IFrame instead")
725 super(HTML, self).__init__(data=data, url=url, filename=filename, metadata=metadata)
725 super(HTML, self).__init__(data=data, url=url, filename=filename, metadata=metadata)
726
726
727 def _repr_html_(self):
727 def _repr_html_(self):
728 return self._data_and_metadata()
728 return self._data_and_metadata()
729
729
730 def __html__(self):
730 def __html__(self):
731 """
731 """
732 This method exists to inform other HTML-using modules (e.g. Markupsafe,
732 This method exists to inform other HTML-using modules (e.g. Markupsafe,
733 htmltag, etc) that this object is HTML and does not need things like
733 htmltag, etc) that this object is HTML and does not need things like
734 special characters (<>&) escaped.
734 special characters (<>&) escaped.
735 """
735 """
736 return self._repr_html_()
736 return self._repr_html_()
737
737
738
738
739 class Markdown(TextDisplayObject):
739 class Markdown(TextDisplayObject):
740
740
741 def _repr_markdown_(self):
741 def _repr_markdown_(self):
742 return self._data_and_metadata()
742 return self._data_and_metadata()
743
743
744
744
745 class Math(TextDisplayObject):
745 class Math(TextDisplayObject):
746
746
747 def _repr_latex_(self):
747 def _repr_latex_(self):
748 s = r"$\displaystyle %s$" % self.data.strip('$')
748 s = r"$\displaystyle %s$" % self.data.strip('$')
749 if self.metadata:
749 if self.metadata:
750 return s, deepcopy(self.metadata)
750 return s, deepcopy(self.metadata)
751 else:
751 else:
752 return s
752 return s
753
753
754
754
755 class Latex(TextDisplayObject):
755 class Latex(TextDisplayObject):
756
756
757 def _repr_latex_(self):
757 def _repr_latex_(self):
758 return self._data_and_metadata()
758 return self._data_and_metadata()
759
759
760
760
761 class SVG(DisplayObject):
761 class SVG(DisplayObject):
762 """Embed an SVG into the display.
762 """Embed an SVG into the display.
763
763
764 Note if you just want to view a svg image via a URL use `:class:Image` with
764 Note if you just want to view a svg image via a URL use `:class:Image` with
765 a url=URL keyword argument.
765 a url=URL keyword argument.
766 """
766 """
767
767
768 _read_flags = 'rb'
768 _read_flags = 'rb'
769 # wrap data in a property, which extracts the <svg> tag, discarding
769 # wrap data in a property, which extracts the <svg> tag, discarding
770 # document headers
770 # document headers
771 _data = None
771 _data = None
772
772
773 @property
773 @property
774 def data(self):
774 def data(self):
775 return self._data
775 return self._data
776
776
777 @data.setter
777 @data.setter
778 def data(self, svg):
778 def data(self, svg):
779 if svg is None:
779 if svg is None:
780 self._data = None
780 self._data = None
781 return
781 return
782 # parse into dom object
782 # parse into dom object
783 from xml.dom import minidom
783 from xml.dom import minidom
784 x = minidom.parseString(svg)
784 x = minidom.parseString(svg)
785 # get svg tag (should be 1)
785 # get svg tag (should be 1)
786 found_svg = x.getElementsByTagName('svg')
786 found_svg = x.getElementsByTagName('svg')
787 if found_svg:
787 if found_svg:
788 svg = found_svg[0].toxml()
788 svg = found_svg[0].toxml()
789 else:
789 else:
790 # fallback on the input, trust the user
790 # fallback on the input, trust the user
791 # but this is probably an error.
791 # but this is probably an error.
792 pass
792 pass
793 svg = cast_unicode(svg)
793 svg = cast_unicode(svg)
794 self._data = svg
794 self._data = svg
795
795
796 def _repr_svg_(self):
796 def _repr_svg_(self):
797 return self._data_and_metadata()
797 return self._data_and_metadata()
798
798
799 class ProgressBar(DisplayObject):
799 class ProgressBar(DisplayObject):
800 """Progressbar supports displaying a progressbar like element
800 """Progressbar supports displaying a progressbar like element
801 """
801 """
802 def __init__(self, total):
802 def __init__(self, total):
803 """Creates a new progressbar
803 """Creates a new progressbar
804
804
805 Parameters
805 Parameters
806 ----------
806 ----------
807 total : int
807 total : int
808 maximum size of the progressbar
808 maximum size of the progressbar
809 """
809 """
810 self.total = total
810 self.total = total
811 self._progress = 0
811 self._progress = 0
812 self.html_width = '60ex'
812 self.html_width = '60ex'
813 self.text_width = 60
813 self.text_width = 60
814 self._display_id = hexlify(os.urandom(8)).decode('ascii')
814 self._display_id = hexlify(os.urandom(8)).decode('ascii')
815
815
816 def __repr__(self):
816 def __repr__(self):
817 fraction = self.progress / self.total
817 fraction = self.progress / self.total
818 filled = '=' * int(fraction * self.text_width)
818 filled = '=' * int(fraction * self.text_width)
819 rest = ' ' * (self.text_width - len(filled))
819 rest = ' ' * (self.text_width - len(filled))
820 return '[{}{}] {}/{}'.format(
820 return '[{}{}] {}/{}'.format(
821 filled, rest,
821 filled, rest,
822 self.progress, self.total,
822 self.progress, self.total,
823 )
823 )
824
824
825 def _repr_html_(self):
825 def _repr_html_(self):
826 return "<progress style='width:{}' max='{}' value='{}'></progress>".format(
826 return "<progress style='width:{}' max='{}' value='{}'></progress>".format(
827 self.html_width, self.total, self.progress)
827 self.html_width, self.total, self.progress)
828
828
829 def display(self):
829 def display(self):
830 display(self, display_id=self._display_id)
830 display(self, display_id=self._display_id)
831
831
832 def update(self):
832 def update(self):
833 display(self, display_id=self._display_id, update=True)
833 display(self, display_id=self._display_id, update=True)
834
834
835 @property
835 @property
836 def progress(self):
836 def progress(self):
837 return self._progress
837 return self._progress
838
838
839 @progress.setter
839 @progress.setter
840 def progress(self, value):
840 def progress(self, value):
841 self._progress = value
841 self._progress = value
842 self.update()
842 self.update()
843
843
844 def __iter__(self):
844 def __iter__(self):
845 self.display()
845 self.display()
846 self._progress = -1 # First iteration is 0
846 self._progress = -1 # First iteration is 0
847 return self
847 return self
848
848
849 def __next__(self):
849 def __next__(self):
850 """Returns current value and increments display by one."""
850 """Returns current value and increments display by one."""
851 self.progress += 1
851 self.progress += 1
852 if self.progress < self.total:
852 if self.progress < self.total:
853 return self.progress
853 return self.progress
854 else:
854 else:
855 raise StopIteration()
855 raise StopIteration()
856
856
857 class JSON(DisplayObject):
857 class JSON(DisplayObject):
858 """JSON expects a JSON-able dict or list
858 """JSON expects a JSON-able dict or list
859
859
860 not an already-serialized JSON string.
860 not an already-serialized JSON string.
861
861
862 Scalar types (None, number, string) are not allowed, only dict or list containers.
862 Scalar types (None, number, string) are not allowed, only dict or list containers.
863 """
863 """
864 # wrap data in a property, which warns about passing already-serialized JSON
864 # wrap data in a property, which warns about passing already-serialized JSON
865 _data = None
865 _data = None
866 def __init__(self, data=None, url=None, filename=None, expanded=False, metadata=None, root='root', **kwargs):
866 def __init__(self, data=None, url=None, filename=None, expanded=False, metadata=None, root='root', **kwargs):
867 """Create a JSON display object given raw data.
867 """Create a JSON display object given raw data.
868
868
869 Parameters
869 Parameters
870 ----------
870 ----------
871 data : dict or list
871 data : dict or list
872 JSON data to display. Not an already-serialized JSON string.
872 JSON data to display. Not an already-serialized JSON string.
873 Scalar types (None, number, string) are not allowed, only dict
873 Scalar types (None, number, string) are not allowed, only dict
874 or list containers.
874 or list containers.
875 url : unicode
875 url : unicode
876 A URL to download the data from.
876 A URL to download the data from.
877 filename : unicode
877 filename : unicode
878 Path to a local file to load the data from.
878 Path to a local file to load the data from.
879 expanded : boolean
879 expanded : boolean
880 Metadata to control whether a JSON display component is expanded.
880 Metadata to control whether a JSON display component is expanded.
881 metadata: dict
881 metadata: dict
882 Specify extra metadata to attach to the json display object.
882 Specify extra metadata to attach to the json display object.
883 root : str
883 root : str
884 The name of the root element of the JSON tree
884 The name of the root element of the JSON tree
885 """
885 """
886 self.metadata = {
886 self.metadata = {
887 'expanded': expanded,
887 'expanded': expanded,
888 'root': root,
888 'root': root,
889 }
889 }
890 if metadata:
890 if metadata:
891 self.metadata.update(metadata)
891 self.metadata.update(metadata)
892 if kwargs:
892 if kwargs:
893 self.metadata.update(kwargs)
893 self.metadata.update(kwargs)
894 super(JSON, self).__init__(data=data, url=url, filename=filename)
894 super(JSON, self).__init__(data=data, url=url, filename=filename)
895
895
896 def _check_data(self):
896 def _check_data(self):
897 if self.data is not None and not isinstance(self.data, (dict, list)):
897 if self.data is not None and not isinstance(self.data, (dict, list)):
898 raise TypeError("%s expects JSONable dict or list, not %r" % (self.__class__.__name__, self.data))
898 raise TypeError("%s expects JSONable dict or list, not %r" % (self.__class__.__name__, self.data))
899
899
900 @property
900 @property
901 def data(self):
901 def data(self):
902 return self._data
902 return self._data
903
903
904 @data.setter
904 @data.setter
905 def data(self, data):
905 def data(self, data):
906 if isinstance(data, (Path, PurePath)):
906 if isinstance(data, (Path, PurePath)):
907 data = str(data)
907 data = str(data)
908
908
909 if isinstance(data, str):
909 if isinstance(data, str):
910 if self.filename is None and self.url is None:
910 if self.filename is None and self.url is None:
911 warnings.warn("JSON expects JSONable dict or list, not JSON strings")
911 warnings.warn("JSON expects JSONable dict or list, not JSON strings")
912 data = json.loads(data)
912 data = json.loads(data)
913 self._data = data
913 self._data = data
914
914
915 def _data_and_metadata(self):
915 def _data_and_metadata(self):
916 return self.data, self.metadata
916 return self.data, self.metadata
917
917
918 def _repr_json_(self):
918 def _repr_json_(self):
919 return self._data_and_metadata()
919 return self._data_and_metadata()
920
920
921 _css_t = """var link = document.createElement("link");
921 _css_t = """var link = document.createElement("link");
922 link.ref = "stylesheet";
922 link.ref = "stylesheet";
923 link.type = "text/css";
923 link.type = "text/css";
924 link.href = "%s";
924 link.href = "%s";
925 document.head.appendChild(link);
925 document.head.appendChild(link);
926 """
926 """
927
927
928 _lib_t1 = """new Promise(function(resolve, reject) {
928 _lib_t1 = """new Promise(function(resolve, reject) {
929 var script = document.createElement("script");
929 var script = document.createElement("script");
930 script.onload = resolve;
930 script.onload = resolve;
931 script.onerror = reject;
931 script.onerror = reject;
932 script.src = "%s";
932 script.src = "%s";
933 document.head.appendChild(script);
933 document.head.appendChild(script);
934 }).then(() => {
934 }).then(() => {
935 """
935 """
936
936
937 _lib_t2 = """
937 _lib_t2 = """
938 });"""
938 });"""
939
939
940 class GeoJSON(JSON):
940 class GeoJSON(JSON):
941 """GeoJSON expects JSON-able dict
941 """GeoJSON expects JSON-able dict
942
942
943 not an already-serialized JSON string.
943 not an already-serialized JSON string.
944
944
945 Scalar types (None, number, string) are not allowed, only dict containers.
945 Scalar types (None, number, string) are not allowed, only dict containers.
946 """
946 """
947
947
948 def __init__(self, *args, **kwargs):
948 def __init__(self, *args, **kwargs):
949 """Create a GeoJSON display object given raw data.
949 """Create a GeoJSON display object given raw data.
950
950
951 Parameters
951 Parameters
952 ----------
952 ----------
953 data : dict or list
953 data : dict or list
954 VegaLite data. Not an already-serialized JSON string.
954 VegaLite data. Not an already-serialized JSON string.
955 Scalar types (None, number, string) are not allowed, only dict
955 Scalar types (None, number, string) are not allowed, only dict
956 or list containers.
956 or list containers.
957 url_template : string
957 url_template : string
958 Leaflet TileLayer URL template: http://leafletjs.com/reference.html#url-template
958 Leaflet TileLayer URL template: http://leafletjs.com/reference.html#url-template
959 layer_options : dict
959 layer_options : dict
960 Leaflet TileLayer options: http://leafletjs.com/reference.html#tilelayer-options
960 Leaflet TileLayer options: http://leafletjs.com/reference.html#tilelayer-options
961 url : unicode
961 url : unicode
962 A URL to download the data from.
962 A URL to download the data from.
963 filename : unicode
963 filename : unicode
964 Path to a local file to load the data from.
964 Path to a local file to load the data from.
965 metadata: dict
965 metadata: dict
966 Specify extra metadata to attach to the json display object.
966 Specify extra metadata to attach to the json display object.
967
967
968 Examples
968 Examples
969 --------
969 --------
970
970
971 The following will display an interactive map of Mars with a point of
971 The following will display an interactive map of Mars with a point of
972 interest on frontend that do support GeoJSON display.
972 interest on frontend that do support GeoJSON display.
973
973
974 >>> from IPython.display import GeoJSON
974 >>> from IPython.display import GeoJSON
975
975
976 >>> GeoJSON(data={
976 >>> GeoJSON(data={
977 ... "type": "Feature",
977 ... "type": "Feature",
978 ... "geometry": {
978 ... "geometry": {
979 ... "type": "Point",
979 ... "type": "Point",
980 ... "coordinates": [-81.327, 296.038]
980 ... "coordinates": [-81.327, 296.038]
981 ... }
981 ... }
982 ... },
982 ... },
983 ... url_template="http://s3-eu-west-1.amazonaws.com/whereonmars.cartodb.net/{basemap_id}/{z}/{x}/{y}.png",
983 ... url_template="http://s3-eu-west-1.amazonaws.com/whereonmars.cartodb.net/{basemap_id}/{z}/{x}/{y}.png",
984 ... layer_options={
984 ... layer_options={
985 ... "basemap_id": "celestia_mars-shaded-16k_global",
985 ... "basemap_id": "celestia_mars-shaded-16k_global",
986 ... "attribution" : "Celestia/praesepe",
986 ... "attribution" : "Celestia/praesepe",
987 ... "minZoom" : 0,
987 ... "minZoom" : 0,
988 ... "maxZoom" : 18,
988 ... "maxZoom" : 18,
989 ... })
989 ... })
990 <IPython.core.display.GeoJSON object>
990 <IPython.core.display.GeoJSON object>
991
991
992 In the terminal IPython, you will only see the text representation of
992 In the terminal IPython, you will only see the text representation of
993 the GeoJSON object.
993 the GeoJSON object.
994
994
995 """
995 """
996
996
997 super(GeoJSON, self).__init__(*args, **kwargs)
997 super(GeoJSON, self).__init__(*args, **kwargs)
998
998
999
999
1000 def _ipython_display_(self):
1000 def _ipython_display_(self):
1001 bundle = {
1001 bundle = {
1002 'application/geo+json': self.data,
1002 'application/geo+json': self.data,
1003 'text/plain': '<IPython.display.GeoJSON object>'
1003 'text/plain': '<IPython.display.GeoJSON object>'
1004 }
1004 }
1005 metadata = {
1005 metadata = {
1006 'application/geo+json': self.metadata
1006 'application/geo+json': self.metadata
1007 }
1007 }
1008 display(bundle, metadata=metadata, raw=True)
1008 display(bundle, metadata=metadata, raw=True)
1009
1009
1010 class Javascript(TextDisplayObject):
1010 class Javascript(TextDisplayObject):
1011
1011
1012 def __init__(self, data=None, url=None, filename=None, lib=None, css=None):
1012 def __init__(self, data=None, url=None, filename=None, lib=None, css=None):
1013 """Create a Javascript display object given raw data.
1013 """Create a Javascript display object given raw data.
1014
1014
1015 When this object is returned by an expression or passed to the
1015 When this object is returned by an expression or passed to the
1016 display function, it will result in the data being displayed
1016 display function, it will result in the data being displayed
1017 in the frontend. If the data is a URL, the data will first be
1017 in the frontend. If the data is a URL, the data will first be
1018 downloaded and then displayed.
1018 downloaded and then displayed.
1019
1019
1020 In the Notebook, the containing element will be available as `element`,
1020 In the Notebook, the containing element will be available as `element`,
1021 and jQuery will be available. Content appended to `element` will be
1021 and jQuery will be available. Content appended to `element` will be
1022 visible in the output area.
1022 visible in the output area.
1023
1023
1024 Parameters
1024 Parameters
1025 ----------
1025 ----------
1026 data : unicode, str or bytes
1026 data : unicode, str or bytes
1027 The Javascript source code or a URL to download it from.
1027 The Javascript source code or a URL to download it from.
1028 url : unicode
1028 url : unicode
1029 A URL to download the data from.
1029 A URL to download the data from.
1030 filename : unicode
1030 filename : unicode
1031 Path to a local file to load the data from.
1031 Path to a local file to load the data from.
1032 lib : list or str
1032 lib : list or str
1033 A sequence of Javascript library URLs to load asynchronously before
1033 A sequence of Javascript library URLs to load asynchronously before
1034 running the source code. The full URLs of the libraries should
1034 running the source code. The full URLs of the libraries should
1035 be given. A single Javascript library URL can also be given as a
1035 be given. A single Javascript library URL can also be given as a
1036 string.
1036 string.
1037 css: : list or str
1037 css: : list or str
1038 A sequence of css files to load before running the source code.
1038 A sequence of css files to load before running the source code.
1039 The full URLs of the css files should be given. A single css URL
1039 The full URLs of the css files should be given. A single css URL
1040 can also be given as a string.
1040 can also be given as a string.
1041 """
1041 """
1042 if isinstance(lib, str):
1042 if isinstance(lib, str):
1043 lib = [lib]
1043 lib = [lib]
1044 elif lib is None:
1044 elif lib is None:
1045 lib = []
1045 lib = []
1046 if isinstance(css, str):
1046 if isinstance(css, str):
1047 css = [css]
1047 css = [css]
1048 elif css is None:
1048 elif css is None:
1049 css = []
1049 css = []
1050 if not isinstance(lib, (list,tuple)):
1050 if not isinstance(lib, (list,tuple)):
1051 raise TypeError('expected sequence, got: %r' % lib)
1051 raise TypeError('expected sequence, got: %r' % lib)
1052 if not isinstance(css, (list,tuple)):
1052 if not isinstance(css, (list,tuple)):
1053 raise TypeError('expected sequence, got: %r' % css)
1053 raise TypeError('expected sequence, got: %r' % css)
1054 self.lib = lib
1054 self.lib = lib
1055 self.css = css
1055 self.css = css
1056 super(Javascript, self).__init__(data=data, url=url, filename=filename)
1056 super(Javascript, self).__init__(data=data, url=url, filename=filename)
1057
1057
1058 def _repr_javascript_(self):
1058 def _repr_javascript_(self):
1059 r = ''
1059 r = ''
1060 for c in self.css:
1060 for c in self.css:
1061 r += _css_t % c
1061 r += _css_t % c
1062 for l in self.lib:
1062 for l in self.lib:
1063 r += _lib_t1 % l
1063 r += _lib_t1 % l
1064 r += self.data
1064 r += self.data
1065 r += _lib_t2*len(self.lib)
1065 r += _lib_t2*len(self.lib)
1066 return r
1066 return r
1067
1067
1068 # constants for identifying png/jpeg data
1068 # constants for identifying png/jpeg data
1069 _PNG = b'\x89PNG\r\n\x1a\n'
1069 _PNG = b'\x89PNG\r\n\x1a\n'
1070 _JPEG = b'\xff\xd8'
1070 _JPEG = b'\xff\xd8'
1071
1071
1072 def _pngxy(data):
1072 def _pngxy(data):
1073 """read the (width, height) from a PNG header"""
1073 """read the (width, height) from a PNG header"""
1074 ihdr = data.index(b'IHDR')
1074 ihdr = data.index(b'IHDR')
1075 # next 8 bytes are width/height
1075 # next 8 bytes are width/height
1076 return struct.unpack('>ii', data[ihdr+4:ihdr+12])
1076 return struct.unpack('>ii', data[ihdr+4:ihdr+12])
1077
1077
1078 def _jpegxy(data):
1078 def _jpegxy(data):
1079 """read the (width, height) from a JPEG header"""
1079 """read the (width, height) from a JPEG header"""
1080 # adapted from http://www.64lines.com/jpeg-width-height
1080 # adapted from http://www.64lines.com/jpeg-width-height
1081
1081
1082 idx = 4
1082 idx = 4
1083 while True:
1083 while True:
1084 block_size = struct.unpack('>H', data[idx:idx+2])[0]
1084 block_size = struct.unpack('>H', data[idx:idx+2])[0]
1085 idx = idx + block_size
1085 idx = idx + block_size
1086 if data[idx:idx+2] == b'\xFF\xC0':
1086 if data[idx:idx+2] == b'\xFF\xC0':
1087 # found Start of Frame
1087 # found Start of Frame
1088 iSOF = idx
1088 iSOF = idx
1089 break
1089 break
1090 else:
1090 else:
1091 # read another block
1091 # read another block
1092 idx += 2
1092 idx += 2
1093
1093
1094 h, w = struct.unpack('>HH', data[iSOF+5:iSOF+9])
1094 h, w = struct.unpack('>HH', data[iSOF+5:iSOF+9])
1095 return w, h
1095 return w, h
1096
1096
1097 def _gifxy(data):
1097 def _gifxy(data):
1098 """read the (width, height) from a GIF header"""
1098 """read the (width, height) from a GIF header"""
1099 return struct.unpack('<HH', data[6:10])
1099 return struct.unpack('<HH', data[6:10])
1100
1100
1101
1101
1102 class Image(DisplayObject):
1102 class Image(DisplayObject):
1103
1103
1104 _read_flags = 'rb'
1104 _read_flags = 'rb'
1105 _FMT_JPEG = u'jpeg'
1105 _FMT_JPEG = u'jpeg'
1106 _FMT_PNG = u'png'
1106 _FMT_PNG = u'png'
1107 _FMT_GIF = u'gif'
1107 _FMT_GIF = u'gif'
1108 _ACCEPTABLE_EMBEDDINGS = [_FMT_JPEG, _FMT_PNG, _FMT_GIF]
1108 _ACCEPTABLE_EMBEDDINGS = [_FMT_JPEG, _FMT_PNG, _FMT_GIF]
1109 _MIMETYPES = {
1109 _MIMETYPES = {
1110 _FMT_PNG: 'image/png',
1110 _FMT_PNG: 'image/png',
1111 _FMT_JPEG: 'image/jpeg',
1111 _FMT_JPEG: 'image/jpeg',
1112 _FMT_GIF: 'image/gif',
1112 _FMT_GIF: 'image/gif',
1113 }
1113 }
1114
1114
1115 def __init__(self, data=None, url=None, filename=None, format=None,
1115 def __init__(self, data=None, url=None, filename=None, format=None,
1116 embed=None, width=None, height=None, retina=False,
1116 embed=None, width=None, height=None, retina=False,
1117 unconfined=False, metadata=None):
1117 unconfined=False, metadata=None):
1118 """Create a PNG/JPEG/GIF image object given raw data.
1118 """Create a PNG/JPEG/GIF image object given raw data.
1119
1119
1120 When this object is returned by an input cell or passed to the
1120 When this object is returned by an input cell or passed to the
1121 display function, it will result in the image being displayed
1121 display function, it will result in the image being displayed
1122 in the frontend.
1122 in the frontend.
1123
1123
1124 Parameters
1124 Parameters
1125 ----------
1125 ----------
1126 data : unicode, str or bytes
1126 data : unicode, str or bytes
1127 The raw image data or a URL or filename to load the data from.
1127 The raw image data or a URL or filename to load the data from.
1128 This always results in embedded image data.
1128 This always results in embedded image data.
1129 url : unicode
1129 url : unicode
1130 A URL to download the data from. If you specify `url=`,
1130 A URL to download the data from. If you specify `url=`,
1131 the image data will not be embedded unless you also specify `embed=True`.
1131 the image data will not be embedded unless you also specify `embed=True`.
1132 filename : unicode
1132 filename : unicode
1133 Path to a local file to load the data from.
1133 Path to a local file to load the data from.
1134 Images from a file are always embedded.
1134 Images from a file are always embedded.
1135 format : unicode
1135 format : unicode
1136 The format of the image data (png/jpeg/jpg/gif). If a filename or URL is given
1136 The format of the image data (png/jpeg/jpg/gif). If a filename or URL is given
1137 for format will be inferred from the filename extension.
1137 for format will be inferred from the filename extension.
1138 embed : bool
1138 embed : bool
1139 Should the image data be embedded using a data URI (True) or be
1139 Should the image data be embedded using a data URI (True) or be
1140 loaded using an <img> tag. Set this to True if you want the image
1140 loaded using an <img> tag. Set this to True if you want the image
1141 to be viewable later with no internet connection in the notebook.
1141 to be viewable later with no internet connection in the notebook.
1142
1142
1143 Default is `True`, unless the keyword argument `url` is set, then
1143 Default is `True`, unless the keyword argument `url` is set, then
1144 default value is `False`.
1144 default value is `False`.
1145
1145
1146 Note that QtConsole is not able to display images if `embed` is set to `False`
1146 Note that QtConsole is not able to display images if `embed` is set to `False`
1147 width : int
1147 width : int
1148 Width in pixels to which to constrain the image in html
1148 Width in pixels to which to constrain the image in html
1149 height : int
1149 height : int
1150 Height in pixels to which to constrain the image in html
1150 Height in pixels to which to constrain the image in html
1151 retina : bool
1151 retina : bool
1152 Automatically set the width and height to half of the measured
1152 Automatically set the width and height to half of the measured
1153 width and height.
1153 width and height.
1154 This only works for embedded images because it reads the width/height
1154 This only works for embedded images because it reads the width/height
1155 from image data.
1155 from image data.
1156 For non-embedded images, you can just set the desired display width
1156 For non-embedded images, you can just set the desired display width
1157 and height directly.
1157 and height directly.
1158 unconfined: bool
1158 unconfined: bool
1159 Set unconfined=True to disable max-width confinement of the image.
1159 Set unconfined=True to disable max-width confinement of the image.
1160 metadata: dict
1160 metadata: dict
1161 Specify extra metadata to attach to the image.
1161 Specify extra metadata to attach to the image.
1162
1162
1163 Examples
1163 Examples
1164 --------
1164 --------
1165 # embedded image data, works in qtconsole and notebook
1165 # embedded image data, works in qtconsole and notebook
1166 # when passed positionally, the first arg can be any of raw image data,
1166 # when passed positionally, the first arg can be any of raw image data,
1167 # a URL, or a filename from which to load image data.
1167 # a URL, or a filename from which to load image data.
1168 # The result is always embedding image data for inline images.
1168 # The result is always embedding image data for inline images.
1169 Image('http://www.google.fr/images/srpr/logo3w.png')
1169 Image('http://www.google.fr/images/srpr/logo3w.png')
1170 Image('/path/to/image.jpg')
1170 Image('/path/to/image.jpg')
1171 Image(b'RAW_PNG_DATA...')
1171 Image(b'RAW_PNG_DATA...')
1172
1172
1173 # Specifying Image(url=...) does not embed the image data,
1173 # Specifying Image(url=...) does not embed the image data,
1174 # it only generates `<img>` tag with a link to the source.
1174 # it only generates `<img>` tag with a link to the source.
1175 # This will not work in the qtconsole or offline.
1175 # This will not work in the qtconsole or offline.
1176 Image(url='http://www.google.fr/images/srpr/logo3w.png')
1176 Image(url='http://www.google.fr/images/srpr/logo3w.png')
1177
1177
1178 """
1178 """
1179 if isinstance(data, (Path, PurePath)):
1179 if isinstance(data, (Path, PurePath)):
1180 data = str(data)
1180 data = str(data)
1181
1181
1182 if filename is not None:
1182 if filename is not None:
1183 ext = self._find_ext(filename)
1183 ext = self._find_ext(filename)
1184 elif url is not None:
1184 elif url is not None:
1185 ext = self._find_ext(url)
1185 ext = self._find_ext(url)
1186 elif data is None:
1186 elif data is None:
1187 raise ValueError("No image data found. Expecting filename, url, or data.")
1187 raise ValueError("No image data found. Expecting filename, url, or data.")
1188 elif isinstance(data, str) and (
1188 elif isinstance(data, str) and (
1189 data.startswith('http') or _safe_exists(data)
1189 data.startswith('http') or _safe_exists(data)
1190 ):
1190 ):
1191 ext = self._find_ext(data)
1191 ext = self._find_ext(data)
1192 else:
1192 else:
1193 ext = None
1193 ext = None
1194
1194
1195 if format is None:
1195 if format is None:
1196 if ext is not None:
1196 if ext is not None:
1197 if ext == u'jpg' or ext == u'jpeg':
1197 if ext == u'jpg' or ext == u'jpeg':
1198 format = self._FMT_JPEG
1198 format = self._FMT_JPEG
1199 elif ext == u'png':
1199 elif ext == u'png':
1200 format = self._FMT_PNG
1200 format = self._FMT_PNG
1201 elif ext == u'gif':
1201 elif ext == u'gif':
1202 format = self._FMT_GIF
1202 format = self._FMT_GIF
1203 else:
1203 else:
1204 format = ext.lower()
1204 format = ext.lower()
1205 elif isinstance(data, bytes):
1205 elif isinstance(data, bytes):
1206 # infer image type from image data header,
1206 # infer image type from image data header,
1207 # only if format has not been specified.
1207 # only if format has not been specified.
1208 if data[:2] == _JPEG:
1208 if data[:2] == _JPEG:
1209 format = self._FMT_JPEG
1209 format = self._FMT_JPEG
1210
1210
1211 # failed to detect format, default png
1211 # failed to detect format, default png
1212 if format is None:
1212 if format is None:
1213 format = self._FMT_PNG
1213 format = self._FMT_PNG
1214
1214
1215 if format.lower() == 'jpg':
1215 if format.lower() == 'jpg':
1216 # jpg->jpeg
1216 # jpg->jpeg
1217 format = self._FMT_JPEG
1217 format = self._FMT_JPEG
1218
1218
1219 self.format = format.lower()
1219 self.format = format.lower()
1220 self.embed = embed if embed is not None else (url is None)
1220 self.embed = embed if embed is not None else (url is None)
1221
1221
1222 if self.embed and self.format not in self._ACCEPTABLE_EMBEDDINGS:
1222 if self.embed and self.format not in self._ACCEPTABLE_EMBEDDINGS:
1223 raise ValueError("Cannot embed the '%s' image format" % (self.format))
1223 raise ValueError("Cannot embed the '%s' image format" % (self.format))
1224 if self.embed:
1224 if self.embed:
1225 self._mimetype = self._MIMETYPES.get(self.format)
1225 self._mimetype = self._MIMETYPES.get(self.format)
1226
1226
1227 self.width = width
1227 self.width = width
1228 self.height = height
1228 self.height = height
1229 self.retina = retina
1229 self.retina = retina
1230 self.unconfined = unconfined
1230 self.unconfined = unconfined
1231 super(Image, self).__init__(data=data, url=url, filename=filename,
1231 super(Image, self).__init__(data=data, url=url, filename=filename,
1232 metadata=metadata)
1232 metadata=metadata)
1233
1233
1234 if self.width is None and self.metadata.get('width', {}):
1234 if self.width is None and self.metadata.get('width', {}):
1235 self.width = metadata['width']
1235 self.width = metadata['width']
1236
1236
1237 if self.height is None and self.metadata.get('height', {}):
1237 if self.height is None and self.metadata.get('height', {}):
1238 self.height = metadata['height']
1238 self.height = metadata['height']
1239
1239
1240 if retina:
1240 if retina:
1241 self._retina_shape()
1241 self._retina_shape()
1242
1242
1243
1243
1244 def _retina_shape(self):
1244 def _retina_shape(self):
1245 """load pixel-doubled width and height from image data"""
1245 """load pixel-doubled width and height from image data"""
1246 if not self.embed:
1246 if not self.embed:
1247 return
1247 return
1248 if self.format == self._FMT_PNG:
1248 if self.format == self._FMT_PNG:
1249 w, h = _pngxy(self.data)
1249 w, h = _pngxy(self.data)
1250 elif self.format == self._FMT_JPEG:
1250 elif self.format == self._FMT_JPEG:
1251 w, h = _jpegxy(self.data)
1251 w, h = _jpegxy(self.data)
1252 elif self.format == self._FMT_GIF:
1252 elif self.format == self._FMT_GIF:
1253 w, h = _gifxy(self.data)
1253 w, h = _gifxy(self.data)
1254 else:
1254 else:
1255 # retina only supports png
1255 # retina only supports png
1256 return
1256 return
1257 self.width = w // 2
1257 self.width = w // 2
1258 self.height = h // 2
1258 self.height = h // 2
1259
1259
1260 def reload(self):
1260 def reload(self):
1261 """Reload the raw data from file or URL."""
1261 """Reload the raw data from file or URL."""
1262 if self.embed:
1262 if self.embed:
1263 super(Image,self).reload()
1263 super(Image,self).reload()
1264 if self.retina:
1264 if self.retina:
1265 self._retina_shape()
1265 self._retina_shape()
1266
1266
1267 def _repr_html_(self):
1267 def _repr_html_(self):
1268 if not self.embed:
1268 if not self.embed:
1269 width = height = klass = ''
1269 width = height = klass = ''
1270 if self.width:
1270 if self.width:
1271 width = ' width="%d"' % self.width
1271 width = ' width="%d"' % self.width
1272 if self.height:
1272 if self.height:
1273 height = ' height="%d"' % self.height
1273 height = ' height="%d"' % self.height
1274 if self.unconfined:
1274 if self.unconfined:
1275 klass = ' class="unconfined"'
1275 klass = ' class="unconfined"'
1276 return u'<img src="{url}"{width}{height}{klass}/>'.format(
1276 return u'<img src="{url}"{width}{height}{klass}/>'.format(
1277 url=self.url,
1277 url=self.url,
1278 width=width,
1278 width=width,
1279 height=height,
1279 height=height,
1280 klass=klass,
1280 klass=klass,
1281 )
1281 )
1282
1282
1283 def _repr_mimebundle_(self, include=None, exclude=None):
1283 def _repr_mimebundle_(self, include=None, exclude=None):
1284 """Return the image as a mimebundle
1284 """Return the image as a mimebundle
1285
1285
1286 Any new mimetype support should be implemented here.
1286 Any new mimetype support should be implemented here.
1287 """
1287 """
1288 if self.embed:
1288 if self.embed:
1289 mimetype = self._mimetype
1289 mimetype = self._mimetype
1290 data, metadata = self._data_and_metadata(always_both=True)
1290 data, metadata = self._data_and_metadata(always_both=True)
1291 if metadata:
1291 if metadata:
1292 metadata = {mimetype: metadata}
1292 metadata = {mimetype: metadata}
1293 return {mimetype: data}, metadata
1293 return {mimetype: data}, metadata
1294 else:
1294 else:
1295 return {'text/html': self._repr_html_()}
1295 return {'text/html': self._repr_html_()}
1296
1296
1297 def _data_and_metadata(self, always_both=False):
1297 def _data_and_metadata(self, always_both=False):
1298 """shortcut for returning metadata with shape information, if defined"""
1298 """shortcut for returning metadata with shape information, if defined"""
1299 try:
1299 try:
1300 b64_data = b2a_base64(self.data).decode('ascii')
1300 b64_data = b2a_base64(self.data).decode('ascii')
1301 except TypeError:
1301 except TypeError:
1302 raise FileNotFoundError(
1302 raise FileNotFoundError(
1303 "No such file or directory: '%s'" % (self.data))
1303 "No such file or directory: '%s'" % (self.data))
1304 md = {}
1304 md = {}
1305 if self.metadata:
1305 if self.metadata:
1306 md.update(self.metadata)
1306 md.update(self.metadata)
1307 if self.width:
1307 if self.width:
1308 md['width'] = self.width
1308 md['width'] = self.width
1309 if self.height:
1309 if self.height:
1310 md['height'] = self.height
1310 md['height'] = self.height
1311 if self.unconfined:
1311 if self.unconfined:
1312 md['unconfined'] = self.unconfined
1312 md['unconfined'] = self.unconfined
1313 if md or always_both:
1313 if md or always_both:
1314 return b64_data, md
1314 return b64_data, md
1315 else:
1315 else:
1316 return b64_data
1316 return b64_data
1317
1317
1318 def _repr_png_(self):
1318 def _repr_png_(self):
1319 if self.embed and self.format == self._FMT_PNG:
1319 if self.embed and self.format == self._FMT_PNG:
1320 return self._data_and_metadata()
1320 return self._data_and_metadata()
1321
1321
1322 def _repr_jpeg_(self):
1322 def _repr_jpeg_(self):
1323 if self.embed and self.format == self._FMT_JPEG:
1323 if self.embed and self.format == self._FMT_JPEG:
1324 return self._data_and_metadata()
1324 return self._data_and_metadata()
1325
1325
1326 def _find_ext(self, s):
1326 def _find_ext(self, s):
1327 base, ext = splitext(s)
1327 base, ext = splitext(s)
1328
1328
1329 if not ext:
1329 if not ext:
1330 return base
1330 return base
1331
1331
1332 # `splitext` includes leading period, so we skip it
1332 # `splitext` includes leading period, so we skip it
1333 return ext[1:].lower()
1333 return ext[1:].lower()
1334
1334
1335
1335
1336 class Video(DisplayObject):
1336 class Video(DisplayObject):
1337
1337
1338 def __init__(self, data=None, url=None, filename=None, embed=False,
1338 def __init__(self, data=None, url=None, filename=None, embed=False,
1339 mimetype=None, width=None, height=None, html_attributes="controls"):
1339 mimetype=None, width=None, height=None, html_attributes="controls"):
1340 """Create a video object given raw data or an URL.
1340 """Create a video object given raw data or an URL.
1341
1341
1342 When this object is returned by an input cell or passed to the
1342 When this object is returned by an input cell or passed to the
1343 display function, it will result in the video being displayed
1343 display function, it will result in the video being displayed
1344 in the frontend.
1344 in the frontend.
1345
1345
1346 Parameters
1346 Parameters
1347 ----------
1347 ----------
1348 data : unicode, str or bytes
1348 data : unicode, str or bytes
1349 The raw video data or a URL or filename to load the data from.
1349 The raw video data or a URL or filename to load the data from.
1350 Raw data will require passing ``embed=True``.
1350 Raw data will require passing ``embed=True``.
1351 url : unicode
1351 url : unicode
1352 A URL for the video. If you specify ``url=``,
1352 A URL for the video. If you specify ``url=``,
1353 the image data will not be embedded.
1353 the image data will not be embedded.
1354 filename : unicode
1354 filename : unicode
1355 Path to a local file containing the video.
1355 Path to a local file containing the video.
1356 Will be interpreted as a local URL unless ``embed=True``.
1356 Will be interpreted as a local URL unless ``embed=True``.
1357 embed : bool
1357 embed : bool
1358 Should the video be embedded using a data URI (True) or be
1358 Should the video be embedded using a data URI (True) or be
1359 loaded using a <video> tag (False).
1359 loaded using a <video> tag (False).
1360
1360
1361 Since videos are large, embedding them should be avoided, if possible.
1361 Since videos are large, embedding them should be avoided, if possible.
1362 You must confirm embedding as your intention by passing ``embed=True``.
1362 You must confirm embedding as your intention by passing ``embed=True``.
1363
1363
1364 Local files can be displayed with URLs without embedding the content, via::
1364 Local files can be displayed with URLs without embedding the content, via::
1365
1365
1366 Video('./video.mp4')
1366 Video('./video.mp4')
1367
1367
1368 mimetype: unicode
1368 mimetype: unicode
1369 Specify the mimetype for embedded videos.
1369 Specify the mimetype for embedded videos.
1370 Default will be guessed from file extension, if available.
1370 Default will be guessed from file extension, if available.
1371 width : int
1371 width : int
1372 Width in pixels to which to constrain the video in HTML.
1372 Width in pixels to which to constrain the video in HTML.
1373 If not supplied, defaults to the width of the video.
1373 If not supplied, defaults to the width of the video.
1374 height : int
1374 height : int
1375 Height in pixels to which to constrain the video in html.
1375 Height in pixels to which to constrain the video in html.
1376 If not supplied, defaults to the height of the video.
1376 If not supplied, defaults to the height of the video.
1377 html_attributes : str
1377 html_attributes : str
1378 Attributes for the HTML ``<video>`` block.
1378 Attributes for the HTML ``<video>`` block.
1379 Default: ``"controls"`` to get video controls.
1379 Default: ``"controls"`` to get video controls.
1380 Other examples: ``"controls muted"`` for muted video with controls,
1380 Other examples: ``"controls muted"`` for muted video with controls,
1381 ``"loop autoplay"`` for looping autoplaying video without controls.
1381 ``"loop autoplay"`` for looping autoplaying video without controls.
1382
1382
1383 Examples
1383 Examples
1384 --------
1384 --------
1385
1385
1386 ::
1386 ::
1387
1387
1388 Video('https://archive.org/download/Sita_Sings_the_Blues/Sita_Sings_the_Blues_small.mp4')
1388 Video('https://archive.org/download/Sita_Sings_the_Blues/Sita_Sings_the_Blues_small.mp4')
1389 Video('path/to/video.mp4')
1389 Video('path/to/video.mp4')
1390 Video('path/to/video.mp4', embed=True)
1390 Video('path/to/video.mp4', embed=True)
1391 Video('path/to/video.mp4', embed=True, html_attributes="controls muted autoplay")
1391 Video('path/to/video.mp4', embed=True, html_attributes="controls muted autoplay")
1392 Video(b'raw-videodata', embed=True)
1392 Video(b'raw-videodata', embed=True)
1393 """
1393 """
1394 if isinstance(data, (Path, PurePath)):
1394 if isinstance(data, (Path, PurePath)):
1395 data = str(data)
1395 data = str(data)
1396
1396
1397 if url is None and isinstance(data, str) and data.startswith(('http:', 'https:')):
1397 if url is None and isinstance(data, str) and data.startswith(('http:', 'https:')):
1398 url = data
1398 url = data
1399 data = None
1399 data = None
1400 elif os.path.exists(data):
1400 elif os.path.exists(data):
1401 filename = data
1401 filename = data
1402 data = None
1402 data = None
1403
1403
1404 if data and not embed:
1404 if data and not embed:
1405 msg = ''.join([
1405 msg = ''.join([
1406 "To embed videos, you must pass embed=True ",
1406 "To embed videos, you must pass embed=True ",
1407 "(this may make your notebook files huge)\n",
1407 "(this may make your notebook files huge)\n",
1408 "Consider passing Video(url='...')",
1408 "Consider passing Video(url='...')",
1409 ])
1409 ])
1410 raise ValueError(msg)
1410 raise ValueError(msg)
1411
1411
1412 self.mimetype = mimetype
1412 self.mimetype = mimetype
1413 self.embed = embed
1413 self.embed = embed
1414 self.width = width
1414 self.width = width
1415 self.height = height
1415 self.height = height
1416 self.html_attributes = html_attributes
1416 self.html_attributes = html_attributes
1417 super(Video, self).__init__(data=data, url=url, filename=filename)
1417 super(Video, self).__init__(data=data, url=url, filename=filename)
1418
1418
1419 def _repr_html_(self):
1419 def _repr_html_(self):
1420 width = height = ''
1420 width = height = ''
1421 if self.width:
1421 if self.width:
1422 width = ' width="%d"' % self.width
1422 width = ' width="%d"' % self.width
1423 if self.height:
1423 if self.height:
1424 height = ' height="%d"' % self.height
1424 height = ' height="%d"' % self.height
1425
1425
1426 # External URLs and potentially local files are not embedded into the
1426 # External URLs and potentially local files are not embedded into the
1427 # notebook output.
1427 # notebook output.
1428 if not self.embed:
1428 if not self.embed:
1429 url = self.url if self.url is not None else self.filename
1429 url = self.url if self.url is not None else self.filename
1430 output = """<video src="{0}" {1} {2} {3}>
1430 output = """<video src="{0}" {1} {2} {3}>
1431 Your browser does not support the <code>video</code> element.
1431 Your browser does not support the <code>video</code> element.
1432 </video>""".format(url, self.html_attributes, width, height)
1432 </video>""".format(url, self.html_attributes, width, height)
1433 return output
1433 return output
1434
1434
1435 # Embedded videos are base64-encoded.
1435 # Embedded videos are base64-encoded.
1436 mimetype = self.mimetype
1436 mimetype = self.mimetype
1437 if self.filename is not None:
1437 if self.filename is not None:
1438 if not mimetype:
1438 if not mimetype:
1439 mimetype, _ = mimetypes.guess_type(self.filename)
1439 mimetype, _ = mimetypes.guess_type(self.filename)
1440
1440
1441 with open(self.filename, 'rb') as f:
1441 with open(self.filename, 'rb') as f:
1442 video = f.read()
1442 video = f.read()
1443 else:
1443 else:
1444 video = self.data
1444 video = self.data
1445 if isinstance(video, str):
1445 if isinstance(video, str):
1446 # unicode input is already b64-encoded
1446 # unicode input is already b64-encoded
1447 b64_video = video
1447 b64_video = video
1448 else:
1448 else:
1449 b64_video = b2a_base64(video).decode('ascii').rstrip()
1449 b64_video = b2a_base64(video).decode('ascii').rstrip()
1450
1450
1451 output = """<video {0} {1} {2}>
1451 output = """<video {0} {1} {2}>
1452 <source src="data:{3};base64,{4}" type="{3}">
1452 <source src="data:{3};base64,{4}" type="{3}">
1453 Your browser does not support the video tag.
1453 Your browser does not support the video tag.
1454 </video>""".format(self.html_attributes, width, height, mimetype, b64_video)
1454 </video>""".format(self.html_attributes, width, height, mimetype, b64_video)
1455 return output
1455 return output
1456
1456
1457 def reload(self):
1457 def reload(self):
1458 # TODO
1458 # TODO
1459 pass
1459 pass
1460
1460
1461
1461
1462 def clear_output(wait=False):
1462 def clear_output(wait=False):
1463 """Clear the output of the current cell receiving output.
1463 """Clear the output of the current cell receiving output.
1464
1464
1465 Parameters
1465 Parameters
1466 ----------
1466 ----------
1467 wait : bool [default: false]
1467 wait : bool [default: false]
1468 Wait to clear the output until new output is available to replace it."""
1468 Wait to clear the output until new output is available to replace it."""
1469 from IPython.core.interactiveshell import InteractiveShell
1469 from IPython.core.interactiveshell import InteractiveShell
1470 if InteractiveShell.initialized():
1470 if InteractiveShell.initialized():
1471 InteractiveShell.instance().display_pub.clear_output(wait)
1471 InteractiveShell.instance().display_pub.clear_output(wait)
1472 else:
1472 else:
1473 print('\033[2K\r', end='')
1473 print('\033[2K\r', end='')
1474 sys.stdout.flush()
1474 sys.stdout.flush()
1475 print('\033[2K\r', end='')
1475 print('\033[2K\r', end='')
1476 sys.stderr.flush()
1476 sys.stderr.flush()
1477
1477
1478
1478
1479 @skip_doctest
1479 @skip_doctest
1480 def set_matplotlib_formats(*formats, **kwargs):
1480 def set_matplotlib_formats(*formats, **kwargs):
1481 """Select figure formats for the inline backend. Optionally pass quality for JPEG.
1481 """
1482 .. deprecated:: 7.23
1483
1484 use `matplotlib_inline.backend_inline.set_matplotlib_formats()`
1485
1486 Select figure formats for the inline backend. Optionally pass quality for JPEG.
1482
1487
1483 For example, this enables PNG and JPEG output with a JPEG quality of 90%::
1488 For example, this enables PNG and JPEG output with a JPEG quality of 90%::
1484
1489
1485 In [1]: set_matplotlib_formats('png', 'jpeg', quality=90)
1490 In [1]: set_matplotlib_formats('png', 'jpeg', quality=90)
1486
1491
1487 To set this in your config files use the following::
1492 To set this in your config files use the following::
1488
1493
1489 c.InlineBackend.figure_formats = {'png', 'jpeg'}
1494 c.InlineBackend.figure_formats = {'png', 'jpeg'}
1490 c.InlineBackend.print_figure_kwargs.update({'quality' : 90})
1495 c.InlineBackend.print_figure_kwargs.update({'quality' : 90})
1491
1496
1492 Parameters
1497 Parameters
1493 ----------
1498 ----------
1494 *formats : strs
1499 *formats : strs
1495 One or more figure formats to enable: 'png', 'retina', 'jpeg', 'svg', 'pdf'.
1500 One or more figure formats to enable: 'png', 'retina', 'jpeg', 'svg', 'pdf'.
1496 **kwargs :
1501 **kwargs :
1497 Keyword args will be relayed to ``figure.canvas.print_figure``.
1502 Keyword args will be relayed to ``figure.canvas.print_figure``.
1498 """
1503 """
1499 from IPython.core.interactiveshell import InteractiveShell
1504 warnings.warn(
1500 from IPython.core.pylabtools import select_figure_formats
1505 "`set_matplotlib_formats` is deprecated since IPython 7.23, directly "
1501 # build kwargs, starting with InlineBackend config
1506 "use `matplotlib_inline.backend_inline.set_matplotlib_formats()`",
1502 kw = {}
1507 DeprecationWarning,
1503 from ipykernel.pylab.config import InlineBackend
1508 stacklevel=2,
1504 cfg = InlineBackend.instance()
1509 )
1505 kw.update(cfg.print_figure_kwargs)
1510
1506 kw.update(**kwargs)
1511 from matplotlib_inline.backend_inline import (
1507 shell = InteractiveShell.instance()
1512 set_matplotlib_formats as set_matplotlib_formats_orig,
1508 select_figure_formats(shell, formats, **kw)
1513 )
1514
1515 set_matplotlib_formats_orig(*formats, **kwargs)
1509
1516
1510 @skip_doctest
1517 @skip_doctest
1511 def set_matplotlib_close(close=True):
1518 def set_matplotlib_close(close=True):
1512 """Set whether the inline backend closes all figures automatically or not.
1519 """
1520 .. deprecated:: 7.23
1521
1522 use `matplotlib_inline.backend_inline.set_matplotlib_close()`
1523
1524
1525 Set whether the inline backend closes all figures automatically or not.
1513
1526
1514 By default, the inline backend used in the IPython Notebook will close all
1527 By default, the inline backend used in the IPython Notebook will close all
1515 matplotlib figures automatically after each cell is run. This means that
1528 matplotlib figures automatically after each cell is run. This means that
1516 plots in different cells won't interfere. Sometimes, you may want to make
1529 plots in different cells won't interfere. Sometimes, you may want to make
1517 a plot in one cell and then refine it in later cells. This can be accomplished
1530 a plot in one cell and then refine it in later cells. This can be accomplished
1518 by::
1531 by::
1519
1532
1520 In [1]: set_matplotlib_close(False)
1533 In [1]: set_matplotlib_close(False)
1521
1534
1522 To set this in your config files use the following::
1535 To set this in your config files use the following::
1523
1536
1524 c.InlineBackend.close_figures = False
1537 c.InlineBackend.close_figures = False
1525
1538
1526 Parameters
1539 Parameters
1527 ----------
1540 ----------
1528 close : bool
1541 close : bool
1529 Should all matplotlib figures be automatically closed after each cell is
1542 Should all matplotlib figures be automatically closed after each cell is
1530 run?
1543 run?
1531 """
1544 """
1532 from ipykernel.pylab.config import InlineBackend
1545 warnings.warn(
1533 cfg = InlineBackend.instance()
1546 "`set_matplotlib_close` is deprecated since IPython 7.23, directly "
1534 cfg.close_figures = close
1547 "use `matplotlib_inline.backend_inline.set_matplotlib_close()`",
1548 DeprecationWarning,
1549 stacklevel=2,
1550 )
1551
1552 from matplotlib_inline.backend_inline import (
1553 set_matplotlib_close as set_matplotlib_close_orig,
1554 )
1555
1556 set_matplotlib_close_orig(close)
@@ -1,3823 +1,3824 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Main IPython class."""
2 """Main IPython class."""
3
3
4 #-----------------------------------------------------------------------------
4 #-----------------------------------------------------------------------------
5 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
5 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
6 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
6 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
7 # Copyright (C) 2008-2011 The IPython Development Team
7 # Copyright (C) 2008-2011 The IPython Development Team
8 #
8 #
9 # Distributed under the terms of the BSD License. The full license is in
9 # Distributed under the terms of the BSD License. The full license is in
10 # the file COPYING, distributed as part of this software.
10 # the file COPYING, distributed as part of this software.
11 #-----------------------------------------------------------------------------
11 #-----------------------------------------------------------------------------
12
12
13
13
14 import abc
14 import abc
15 import ast
15 import ast
16 import atexit
16 import atexit
17 import builtins as builtin_mod
17 import builtins as builtin_mod
18 import functools
18 import functools
19 import inspect
19 import inspect
20 import os
20 import os
21 import re
21 import re
22 import runpy
22 import runpy
23 import sys
23 import sys
24 import tempfile
24 import tempfile
25 import traceback
25 import traceback
26 import types
26 import types
27 import subprocess
27 import subprocess
28 import warnings
28 import warnings
29 from io import open as io_open
29 from io import open as io_open
30
30
31 from pickleshare import PickleShareDB
31 from pickleshare import PickleShareDB
32
32
33 from traitlets.config.configurable import SingletonConfigurable
33 from traitlets.config.configurable import SingletonConfigurable
34 from traitlets.utils.importstring import import_item
34 from traitlets.utils.importstring import import_item
35 from IPython.core import oinspect
35 from IPython.core import oinspect
36 from IPython.core import magic
36 from IPython.core import magic
37 from IPython.core import page
37 from IPython.core import page
38 from IPython.core import prefilter
38 from IPython.core import prefilter
39 from IPython.core import ultratb
39 from IPython.core import ultratb
40 from IPython.core.alias import Alias, AliasManager
40 from IPython.core.alias import Alias, AliasManager
41 from IPython.core.autocall import ExitAutocall
41 from IPython.core.autocall import ExitAutocall
42 from IPython.core.builtin_trap import BuiltinTrap
42 from IPython.core.builtin_trap import BuiltinTrap
43 from IPython.core.events import EventManager, available_events
43 from IPython.core.events import EventManager, available_events
44 from IPython.core.compilerop import CachingCompiler, check_linecache_ipython
44 from IPython.core.compilerop import CachingCompiler, check_linecache_ipython
45 from IPython.core.debugger import Pdb
45 from IPython.core.debugger import Pdb
46 from IPython.core.display_trap import DisplayTrap
46 from IPython.core.display_trap import DisplayTrap
47 from IPython.core.displayhook import DisplayHook
47 from IPython.core.displayhook import DisplayHook
48 from IPython.core.displaypub import DisplayPublisher
48 from IPython.core.displaypub import DisplayPublisher
49 from IPython.core.error import InputRejected, UsageError
49 from IPython.core.error import InputRejected, UsageError
50 from IPython.core.extensions import ExtensionManager
50 from IPython.core.extensions import ExtensionManager
51 from IPython.core.formatters import DisplayFormatter
51 from IPython.core.formatters import DisplayFormatter
52 from IPython.core.history import HistoryManager
52 from IPython.core.history import HistoryManager
53 from IPython.core.inputtransformer2 import ESC_MAGIC, ESC_MAGIC2
53 from IPython.core.inputtransformer2 import ESC_MAGIC, ESC_MAGIC2
54 from IPython.core.logger import Logger
54 from IPython.core.logger import Logger
55 from IPython.core.macro import Macro
55 from IPython.core.macro import Macro
56 from IPython.core.payload import PayloadManager
56 from IPython.core.payload import PayloadManager
57 from IPython.core.prefilter import PrefilterManager
57 from IPython.core.prefilter import PrefilterManager
58 from IPython.core.profiledir import ProfileDir
58 from IPython.core.profiledir import ProfileDir
59 from IPython.core.usage import default_banner
59 from IPython.core.usage import default_banner
60 from IPython.display import display
60 from IPython.display import display
61 from IPython.testing.skipdoctest import skip_doctest
61 from IPython.testing.skipdoctest import skip_doctest
62 from IPython.utils import PyColorize
62 from IPython.utils import PyColorize
63 from IPython.utils import io
63 from IPython.utils import io
64 from IPython.utils import py3compat
64 from IPython.utils import py3compat
65 from IPython.utils import openpy
65 from IPython.utils import openpy
66 from IPython.utils.decorators import undoc
66 from IPython.utils.decorators import undoc
67 from IPython.utils.io import ask_yes_no
67 from IPython.utils.io import ask_yes_no
68 from IPython.utils.ipstruct import Struct
68 from IPython.utils.ipstruct import Struct
69 from IPython.paths import get_ipython_dir
69 from IPython.paths import get_ipython_dir
70 from IPython.utils.path import get_home_dir, get_py_filename, ensure_dir_exists
70 from IPython.utils.path import get_home_dir, get_py_filename, ensure_dir_exists
71 from IPython.utils.process import system, getoutput
71 from IPython.utils.process import system, getoutput
72 from IPython.utils.strdispatch import StrDispatch
72 from IPython.utils.strdispatch import StrDispatch
73 from IPython.utils.syspathcontext import prepended_to_syspath
73 from IPython.utils.syspathcontext import prepended_to_syspath
74 from IPython.utils.text import format_screen, LSString, SList, DollarFormatter
74 from IPython.utils.text import format_screen, LSString, SList, DollarFormatter
75 from IPython.utils.tempdir import TemporaryDirectory
75 from IPython.utils.tempdir import TemporaryDirectory
76 from traitlets import (
76 from traitlets import (
77 Integer, Bool, CaselessStrEnum, Enum, List, Dict, Unicode, Instance, Type,
77 Integer, Bool, CaselessStrEnum, Enum, List, Dict, Unicode, Instance, Type,
78 observe, default, validate, Any
78 observe, default, validate, Any
79 )
79 )
80 from warnings import warn
80 from warnings import warn
81 from logging import error
81 from logging import error
82 import IPython.core.hooks
82 import IPython.core.hooks
83
83
84 from typing import List as ListType, Tuple, Optional
84 from typing import List as ListType, Tuple, Optional
85 from ast import AST
85 from ast import AST
86
86
87 # NoOpContext is deprecated, but ipykernel imports it from here.
87 # NoOpContext is deprecated, but ipykernel imports it from here.
88 # See https://github.com/ipython/ipykernel/issues/157
88 # See https://github.com/ipython/ipykernel/issues/157
89 # (2016, let's try to remove than in IPython 8.0)
89 # (2016, let's try to remove than in IPython 8.0)
90 from IPython.utils.contexts import NoOpContext
90 from IPython.utils.contexts import NoOpContext
91
91
92 try:
92 try:
93 import docrepr.sphinxify as sphx
93 import docrepr.sphinxify as sphx
94
94
95 def sphinxify(doc):
95 def sphinxify(doc):
96 with TemporaryDirectory() as dirname:
96 with TemporaryDirectory() as dirname:
97 return {
97 return {
98 'text/html': sphx.sphinxify(doc, dirname),
98 'text/html': sphx.sphinxify(doc, dirname),
99 'text/plain': doc
99 'text/plain': doc
100 }
100 }
101 except ImportError:
101 except ImportError:
102 sphinxify = None
102 sphinxify = None
103
103
104
104
105 class ProvisionalWarning(DeprecationWarning):
105 class ProvisionalWarning(DeprecationWarning):
106 """
106 """
107 Warning class for unstable features
107 Warning class for unstable features
108 """
108 """
109 pass
109 pass
110
110
111 if sys.version_info > (3,8):
111 if sys.version_info > (3,8):
112 from ast import Module
112 from ast import Module
113 else :
113 else :
114 # mock the new API, ignore second argument
114 # mock the new API, ignore second argument
115 # see https://github.com/ipython/ipython/issues/11590
115 # see https://github.com/ipython/ipython/issues/11590
116 from ast import Module as OriginalModule
116 from ast import Module as OriginalModule
117 Module = lambda nodelist, type_ignores: OriginalModule(nodelist)
117 Module = lambda nodelist, type_ignores: OriginalModule(nodelist)
118
118
119 if sys.version_info > (3,6):
119 if sys.version_info > (3,6):
120 _assign_nodes = (ast.AugAssign, ast.AnnAssign, ast.Assign)
120 _assign_nodes = (ast.AugAssign, ast.AnnAssign, ast.Assign)
121 _single_targets_nodes = (ast.AugAssign, ast.AnnAssign)
121 _single_targets_nodes = (ast.AugAssign, ast.AnnAssign)
122 else:
122 else:
123 _assign_nodes = (ast.AugAssign, ast.Assign )
123 _assign_nodes = (ast.AugAssign, ast.Assign )
124 _single_targets_nodes = (ast.AugAssign, )
124 _single_targets_nodes = (ast.AugAssign, )
125
125
126 #-----------------------------------------------------------------------------
126 #-----------------------------------------------------------------------------
127 # Await Helpers
127 # Await Helpers
128 #-----------------------------------------------------------------------------
128 #-----------------------------------------------------------------------------
129
129
130 def removed_co_newlocals(function:types.FunctionType) -> types.FunctionType:
130 def removed_co_newlocals(function:types.FunctionType) -> types.FunctionType:
131 """Return a function that do not create a new local scope.
131 """Return a function that do not create a new local scope.
132
132
133 Given a function, create a clone of this function where the co_newlocal flag
133 Given a function, create a clone of this function where the co_newlocal flag
134 has been removed, making this function code actually run in the sourounding
134 has been removed, making this function code actually run in the sourounding
135 scope.
135 scope.
136
136
137 We need this in order to run asynchronous code in user level namespace.
137 We need this in order to run asynchronous code in user level namespace.
138 """
138 """
139 from types import CodeType, FunctionType
139 from types import CodeType, FunctionType
140 CO_NEWLOCALS = 0x0002
140 CO_NEWLOCALS = 0x0002
141 code = function.__code__
141 code = function.__code__
142 new_co_flags = code.co_flags & ~CO_NEWLOCALS
142 new_co_flags = code.co_flags & ~CO_NEWLOCALS
143 if sys.version_info > (3, 8, 0, 'alpha', 3):
143 if sys.version_info > (3, 8, 0, 'alpha', 3):
144 new_code = code.replace(co_flags=new_co_flags)
144 new_code = code.replace(co_flags=new_co_flags)
145 else:
145 else:
146 new_code = CodeType(
146 new_code = CodeType(
147 code.co_argcount,
147 code.co_argcount,
148 code.co_kwonlyargcount,
148 code.co_kwonlyargcount,
149 code.co_nlocals,
149 code.co_nlocals,
150 code.co_stacksize,
150 code.co_stacksize,
151 new_co_flags,
151 new_co_flags,
152 code.co_code,
152 code.co_code,
153 code.co_consts,
153 code.co_consts,
154 code.co_names,
154 code.co_names,
155 code.co_varnames,
155 code.co_varnames,
156 code.co_filename,
156 code.co_filename,
157 code.co_name,
157 code.co_name,
158 code.co_firstlineno,
158 code.co_firstlineno,
159 code.co_lnotab,
159 code.co_lnotab,
160 code.co_freevars,
160 code.co_freevars,
161 code.co_cellvars
161 code.co_cellvars
162 )
162 )
163 return FunctionType(new_code, globals(), function.__name__, function.__defaults__)
163 return FunctionType(new_code, globals(), function.__name__, function.__defaults__)
164
164
165
165
166 # we still need to run things using the asyncio eventloop, but there is no
166 # we still need to run things using the asyncio eventloop, but there is no
167 # async integration
167 # async integration
168 from .async_helpers import (_asyncio_runner, _asyncify, _pseudo_sync_runner)
168 from .async_helpers import (_asyncio_runner, _asyncify, _pseudo_sync_runner)
169 from .async_helpers import _curio_runner, _trio_runner, _should_be_async
169 from .async_helpers import _curio_runner, _trio_runner, _should_be_async
170
170
171
171
172 def _ast_asyncify(cell:str, wrapper_name:str) -> ast.Module:
172 def _ast_asyncify(cell:str, wrapper_name:str) -> ast.Module:
173 """
173 """
174 Parse a cell with top-level await and modify the AST to be able to run it later.
174 Parse a cell with top-level await and modify the AST to be able to run it later.
175
175
176 Parameter
176 Parameter
177 ---------
177 ---------
178
178
179 cell: str
179 cell: str
180 The code cell to asyncronify
180 The code cell to asyncronify
181 wrapper_name: str
181 wrapper_name: str
182 The name of the function to be used to wrap the passed `cell`. It is
182 The name of the function to be used to wrap the passed `cell`. It is
183 advised to **not** use a python identifier in order to not pollute the
183 advised to **not** use a python identifier in order to not pollute the
184 global namespace in which the function will be ran.
184 global namespace in which the function will be ran.
185
185
186 Return
186 Return
187 ------
187 ------
188
188
189 A module object AST containing **one** function named `wrapper_name`.
189 A module object AST containing **one** function named `wrapper_name`.
190
190
191 The given code is wrapped in a async-def function, parsed into an AST, and
191 The given code is wrapped in a async-def function, parsed into an AST, and
192 the resulting function definition AST is modified to return the last
192 the resulting function definition AST is modified to return the last
193 expression.
193 expression.
194
194
195 The last expression or await node is moved into a return statement at the
195 The last expression or await node is moved into a return statement at the
196 end of the function, and removed from its original location. If the last
196 end of the function, and removed from its original location. If the last
197 node is not Expr or Await nothing is done.
197 node is not Expr or Await nothing is done.
198
198
199 The function `__code__` will need to be later modified (by
199 The function `__code__` will need to be later modified (by
200 ``removed_co_newlocals``) in a subsequent step to not create new `locals()`
200 ``removed_co_newlocals``) in a subsequent step to not create new `locals()`
201 meaning that the local and global scope are the same, ie as if the body of
201 meaning that the local and global scope are the same, ie as if the body of
202 the function was at module level.
202 the function was at module level.
203
203
204 Lastly a call to `locals()` is made just before the last expression of the
204 Lastly a call to `locals()` is made just before the last expression of the
205 function, or just after the last assignment or statement to make sure the
205 function, or just after the last assignment or statement to make sure the
206 global dict is updated as python function work with a local fast cache which
206 global dict is updated as python function work with a local fast cache which
207 is updated only on `local()` calls.
207 is updated only on `local()` calls.
208 """
208 """
209
209
210 from ast import Expr, Await, Return
210 from ast import Expr, Await, Return
211 if sys.version_info >= (3,8):
211 if sys.version_info >= (3,8):
212 return ast.parse(cell)
212 return ast.parse(cell)
213 tree = ast.parse(_asyncify(cell))
213 tree = ast.parse(_asyncify(cell))
214
214
215 function_def = tree.body[0]
215 function_def = tree.body[0]
216 function_def.name = wrapper_name
216 function_def.name = wrapper_name
217 try_block = function_def.body[0]
217 try_block = function_def.body[0]
218 lastexpr = try_block.body[-1]
218 lastexpr = try_block.body[-1]
219 if isinstance(lastexpr, (Expr, Await)):
219 if isinstance(lastexpr, (Expr, Await)):
220 try_block.body[-1] = Return(lastexpr.value)
220 try_block.body[-1] = Return(lastexpr.value)
221 ast.fix_missing_locations(tree)
221 ast.fix_missing_locations(tree)
222 return tree
222 return tree
223 #-----------------------------------------------------------------------------
223 #-----------------------------------------------------------------------------
224 # Globals
224 # Globals
225 #-----------------------------------------------------------------------------
225 #-----------------------------------------------------------------------------
226
226
227 # compiled regexps for autoindent management
227 # compiled regexps for autoindent management
228 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
228 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
229
229
230 #-----------------------------------------------------------------------------
230 #-----------------------------------------------------------------------------
231 # Utilities
231 # Utilities
232 #-----------------------------------------------------------------------------
232 #-----------------------------------------------------------------------------
233
233
234 @undoc
234 @undoc
235 def softspace(file, newvalue):
235 def softspace(file, newvalue):
236 """Copied from code.py, to remove the dependency"""
236 """Copied from code.py, to remove the dependency"""
237
237
238 oldvalue = 0
238 oldvalue = 0
239 try:
239 try:
240 oldvalue = file.softspace
240 oldvalue = file.softspace
241 except AttributeError:
241 except AttributeError:
242 pass
242 pass
243 try:
243 try:
244 file.softspace = newvalue
244 file.softspace = newvalue
245 except (AttributeError, TypeError):
245 except (AttributeError, TypeError):
246 # "attribute-less object" or "read-only attributes"
246 # "attribute-less object" or "read-only attributes"
247 pass
247 pass
248 return oldvalue
248 return oldvalue
249
249
250 @undoc
250 @undoc
251 def no_op(*a, **kw):
251 def no_op(*a, **kw):
252 pass
252 pass
253
253
254
254
255 class SpaceInInput(Exception): pass
255 class SpaceInInput(Exception): pass
256
256
257
257
258 def get_default_colors():
258 def get_default_colors():
259 "DEPRECATED"
259 "DEPRECATED"
260 warn('get_default_color is deprecated since IPython 5.0, and returns `Neutral` on all platforms.',
260 warn('get_default_color is deprecated since IPython 5.0, and returns `Neutral` on all platforms.',
261 DeprecationWarning, stacklevel=2)
261 DeprecationWarning, stacklevel=2)
262 return 'Neutral'
262 return 'Neutral'
263
263
264
264
265 class SeparateUnicode(Unicode):
265 class SeparateUnicode(Unicode):
266 r"""A Unicode subclass to validate separate_in, separate_out, etc.
266 r"""A Unicode subclass to validate separate_in, separate_out, etc.
267
267
268 This is a Unicode based trait that converts '0'->'' and ``'\\n'->'\n'``.
268 This is a Unicode based trait that converts '0'->'' and ``'\\n'->'\n'``.
269 """
269 """
270
270
271 def validate(self, obj, value):
271 def validate(self, obj, value):
272 if value == '0': value = ''
272 if value == '0': value = ''
273 value = value.replace('\\n','\n')
273 value = value.replace('\\n','\n')
274 return super(SeparateUnicode, self).validate(obj, value)
274 return super(SeparateUnicode, self).validate(obj, value)
275
275
276
276
277 @undoc
277 @undoc
278 class DummyMod(object):
278 class DummyMod(object):
279 """A dummy module used for IPython's interactive module when
279 """A dummy module used for IPython's interactive module when
280 a namespace must be assigned to the module's __dict__."""
280 a namespace must be assigned to the module's __dict__."""
281 __spec__ = None
281 __spec__ = None
282
282
283
283
284 class ExecutionInfo(object):
284 class ExecutionInfo(object):
285 """The arguments used for a call to :meth:`InteractiveShell.run_cell`
285 """The arguments used for a call to :meth:`InteractiveShell.run_cell`
286
286
287 Stores information about what is going to happen.
287 Stores information about what is going to happen.
288 """
288 """
289 raw_cell = None
289 raw_cell = None
290 store_history = False
290 store_history = False
291 silent = False
291 silent = False
292 shell_futures = True
292 shell_futures = True
293
293
294 def __init__(self, raw_cell, store_history, silent, shell_futures):
294 def __init__(self, raw_cell, store_history, silent, shell_futures):
295 self.raw_cell = raw_cell
295 self.raw_cell = raw_cell
296 self.store_history = store_history
296 self.store_history = store_history
297 self.silent = silent
297 self.silent = silent
298 self.shell_futures = shell_futures
298 self.shell_futures = shell_futures
299
299
300 def __repr__(self):
300 def __repr__(self):
301 name = self.__class__.__qualname__
301 name = self.__class__.__qualname__
302 raw_cell = ((self.raw_cell[:50] + '..')
302 raw_cell = ((self.raw_cell[:50] + '..')
303 if len(self.raw_cell) > 50 else self.raw_cell)
303 if len(self.raw_cell) > 50 else self.raw_cell)
304 return '<%s object at %x, raw_cell="%s" store_history=%s silent=%s shell_futures=%s>' %\
304 return '<%s object at %x, raw_cell="%s" store_history=%s silent=%s shell_futures=%s>' %\
305 (name, id(self), raw_cell, self.store_history, self.silent, self.shell_futures)
305 (name, id(self), raw_cell, self.store_history, self.silent, self.shell_futures)
306
306
307
307
308 class ExecutionResult(object):
308 class ExecutionResult(object):
309 """The result of a call to :meth:`InteractiveShell.run_cell`
309 """The result of a call to :meth:`InteractiveShell.run_cell`
310
310
311 Stores information about what took place.
311 Stores information about what took place.
312 """
312 """
313 execution_count = None
313 execution_count = None
314 error_before_exec = None
314 error_before_exec = None
315 error_in_exec = None
315 error_in_exec = None
316 info = None
316 info = None
317 result = None
317 result = None
318
318
319 def __init__(self, info):
319 def __init__(self, info):
320 self.info = info
320 self.info = info
321
321
322 @property
322 @property
323 def success(self):
323 def success(self):
324 return (self.error_before_exec is None) and (self.error_in_exec is None)
324 return (self.error_before_exec is None) and (self.error_in_exec is None)
325
325
326 def raise_error(self):
326 def raise_error(self):
327 """Reraises error if `success` is `False`, otherwise does nothing"""
327 """Reraises error if `success` is `False`, otherwise does nothing"""
328 if self.error_before_exec is not None:
328 if self.error_before_exec is not None:
329 raise self.error_before_exec
329 raise self.error_before_exec
330 if self.error_in_exec is not None:
330 if self.error_in_exec is not None:
331 raise self.error_in_exec
331 raise self.error_in_exec
332
332
333 def __repr__(self):
333 def __repr__(self):
334 name = self.__class__.__qualname__
334 name = self.__class__.__qualname__
335 return '<%s object at %x, execution_count=%s error_before_exec=%s error_in_exec=%s info=%s result=%s>' %\
335 return '<%s object at %x, execution_count=%s error_before_exec=%s error_in_exec=%s info=%s result=%s>' %\
336 (name, id(self), self.execution_count, self.error_before_exec, self.error_in_exec, repr(self.info), repr(self.result))
336 (name, id(self), self.execution_count, self.error_before_exec, self.error_in_exec, repr(self.info), repr(self.result))
337
337
338
338
339 class InteractiveShell(SingletonConfigurable):
339 class InteractiveShell(SingletonConfigurable):
340 """An enhanced, interactive shell for Python."""
340 """An enhanced, interactive shell for Python."""
341
341
342 _instance = None
342 _instance = None
343
343
344 ast_transformers = List([], help=
344 ast_transformers = List([], help=
345 """
345 """
346 A list of ast.NodeTransformer subclass instances, which will be applied
346 A list of ast.NodeTransformer subclass instances, which will be applied
347 to user input before code is run.
347 to user input before code is run.
348 """
348 """
349 ).tag(config=True)
349 ).tag(config=True)
350
350
351 autocall = Enum((0,1,2), default_value=0, help=
351 autocall = Enum((0,1,2), default_value=0, help=
352 """
352 """
353 Make IPython automatically call any callable object even if you didn't
353 Make IPython automatically call any callable object even if you didn't
354 type explicit parentheses. For example, 'str 43' becomes 'str(43)'
354 type explicit parentheses. For example, 'str 43' becomes 'str(43)'
355 automatically. The value can be '0' to disable the feature, '1' for
355 automatically. The value can be '0' to disable the feature, '1' for
356 'smart' autocall, where it is not applied if there are no more
356 'smart' autocall, where it is not applied if there are no more
357 arguments on the line, and '2' for 'full' autocall, where all callable
357 arguments on the line, and '2' for 'full' autocall, where all callable
358 objects are automatically called (even if no arguments are present).
358 objects are automatically called (even if no arguments are present).
359 """
359 """
360 ).tag(config=True)
360 ).tag(config=True)
361
361
362 autoindent = Bool(True, help=
362 autoindent = Bool(True, help=
363 """
363 """
364 Autoindent IPython code entered interactively.
364 Autoindent IPython code entered interactively.
365 """
365 """
366 ).tag(config=True)
366 ).tag(config=True)
367
367
368 autoawait = Bool(True, help=
368 autoawait = Bool(True, help=
369 """
369 """
370 Automatically run await statement in the top level repl.
370 Automatically run await statement in the top level repl.
371 """
371 """
372 ).tag(config=True)
372 ).tag(config=True)
373
373
374 loop_runner_map ={
374 loop_runner_map ={
375 'asyncio':(_asyncio_runner, True),
375 'asyncio':(_asyncio_runner, True),
376 'curio':(_curio_runner, True),
376 'curio':(_curio_runner, True),
377 'trio':(_trio_runner, True),
377 'trio':(_trio_runner, True),
378 'sync': (_pseudo_sync_runner, False)
378 'sync': (_pseudo_sync_runner, False)
379 }
379 }
380
380
381 loop_runner = Any(default_value="IPython.core.interactiveshell._asyncio_runner",
381 loop_runner = Any(default_value="IPython.core.interactiveshell._asyncio_runner",
382 allow_none=True,
382 allow_none=True,
383 help="""Select the loop runner that will be used to execute top-level asynchronous code"""
383 help="""Select the loop runner that will be used to execute top-level asynchronous code"""
384 ).tag(config=True)
384 ).tag(config=True)
385
385
386 @default('loop_runner')
386 @default('loop_runner')
387 def _default_loop_runner(self):
387 def _default_loop_runner(self):
388 return import_item("IPython.core.interactiveshell._asyncio_runner")
388 return import_item("IPython.core.interactiveshell._asyncio_runner")
389
389
390 @validate('loop_runner')
390 @validate('loop_runner')
391 def _import_runner(self, proposal):
391 def _import_runner(self, proposal):
392 if isinstance(proposal.value, str):
392 if isinstance(proposal.value, str):
393 if proposal.value in self.loop_runner_map:
393 if proposal.value in self.loop_runner_map:
394 runner, autoawait = self.loop_runner_map[proposal.value]
394 runner, autoawait = self.loop_runner_map[proposal.value]
395 self.autoawait = autoawait
395 self.autoawait = autoawait
396 return runner
396 return runner
397 runner = import_item(proposal.value)
397 runner = import_item(proposal.value)
398 if not callable(runner):
398 if not callable(runner):
399 raise ValueError('loop_runner must be callable')
399 raise ValueError('loop_runner must be callable')
400 return runner
400 return runner
401 if not callable(proposal.value):
401 if not callable(proposal.value):
402 raise ValueError('loop_runner must be callable')
402 raise ValueError('loop_runner must be callable')
403 return proposal.value
403 return proposal.value
404
404
405 automagic = Bool(True, help=
405 automagic = Bool(True, help=
406 """
406 """
407 Enable magic commands to be called without the leading %.
407 Enable magic commands to be called without the leading %.
408 """
408 """
409 ).tag(config=True)
409 ).tag(config=True)
410
410
411 banner1 = Unicode(default_banner,
411 banner1 = Unicode(default_banner,
412 help="""The part of the banner to be printed before the profile"""
412 help="""The part of the banner to be printed before the profile"""
413 ).tag(config=True)
413 ).tag(config=True)
414 banner2 = Unicode('',
414 banner2 = Unicode('',
415 help="""The part of the banner to be printed after the profile"""
415 help="""The part of the banner to be printed after the profile"""
416 ).tag(config=True)
416 ).tag(config=True)
417
417
418 cache_size = Integer(1000, help=
418 cache_size = Integer(1000, help=
419 """
419 """
420 Set the size of the output cache. The default is 1000, you can
420 Set the size of the output cache. The default is 1000, you can
421 change it permanently in your config file. Setting it to 0 completely
421 change it permanently in your config file. Setting it to 0 completely
422 disables the caching system, and the minimum value accepted is 3 (if
422 disables the caching system, and the minimum value accepted is 3 (if
423 you provide a value less than 3, it is reset to 0 and a warning is
423 you provide a value less than 3, it is reset to 0 and a warning is
424 issued). This limit is defined because otherwise you'll spend more
424 issued). This limit is defined because otherwise you'll spend more
425 time re-flushing a too small cache than working
425 time re-flushing a too small cache than working
426 """
426 """
427 ).tag(config=True)
427 ).tag(config=True)
428 color_info = Bool(True, help=
428 color_info = Bool(True, help=
429 """
429 """
430 Use colors for displaying information about objects. Because this
430 Use colors for displaying information about objects. Because this
431 information is passed through a pager (like 'less'), and some pagers
431 information is passed through a pager (like 'less'), and some pagers
432 get confused with color codes, this capability can be turned off.
432 get confused with color codes, this capability can be turned off.
433 """
433 """
434 ).tag(config=True)
434 ).tag(config=True)
435 colors = CaselessStrEnum(('Neutral', 'NoColor','LightBG','Linux'),
435 colors = CaselessStrEnum(('Neutral', 'NoColor','LightBG','Linux'),
436 default_value='Neutral',
436 default_value='Neutral',
437 help="Set the color scheme (NoColor, Neutral, Linux, or LightBG)."
437 help="Set the color scheme (NoColor, Neutral, Linux, or LightBG)."
438 ).tag(config=True)
438 ).tag(config=True)
439 debug = Bool(False).tag(config=True)
439 debug = Bool(False).tag(config=True)
440 disable_failing_post_execute = Bool(False,
440 disable_failing_post_execute = Bool(False,
441 help="Don't call post-execute functions that have failed in the past."
441 help="Don't call post-execute functions that have failed in the past."
442 ).tag(config=True)
442 ).tag(config=True)
443 display_formatter = Instance(DisplayFormatter, allow_none=True)
443 display_formatter = Instance(DisplayFormatter, allow_none=True)
444 displayhook_class = Type(DisplayHook)
444 displayhook_class = Type(DisplayHook)
445 display_pub_class = Type(DisplayPublisher)
445 display_pub_class = Type(DisplayPublisher)
446 compiler_class = Type(CachingCompiler)
446 compiler_class = Type(CachingCompiler)
447
447
448 sphinxify_docstring = Bool(False, help=
448 sphinxify_docstring = Bool(False, help=
449 """
449 """
450 Enables rich html representation of docstrings. (This requires the
450 Enables rich html representation of docstrings. (This requires the
451 docrepr module).
451 docrepr module).
452 """).tag(config=True)
452 """).tag(config=True)
453
453
454 @observe("sphinxify_docstring")
454 @observe("sphinxify_docstring")
455 def _sphinxify_docstring_changed(self, change):
455 def _sphinxify_docstring_changed(self, change):
456 if change['new']:
456 if change['new']:
457 warn("`sphinxify_docstring` is provisional since IPython 5.0 and might change in future versions." , ProvisionalWarning)
457 warn("`sphinxify_docstring` is provisional since IPython 5.0 and might change in future versions." , ProvisionalWarning)
458
458
459 enable_html_pager = Bool(False, help=
459 enable_html_pager = Bool(False, help=
460 """
460 """
461 (Provisional API) enables html representation in mime bundles sent
461 (Provisional API) enables html representation in mime bundles sent
462 to pagers.
462 to pagers.
463 """).tag(config=True)
463 """).tag(config=True)
464
464
465 @observe("enable_html_pager")
465 @observe("enable_html_pager")
466 def _enable_html_pager_changed(self, change):
466 def _enable_html_pager_changed(self, change):
467 if change['new']:
467 if change['new']:
468 warn("`enable_html_pager` is provisional since IPython 5.0 and might change in future versions.", ProvisionalWarning)
468 warn("`enable_html_pager` is provisional since IPython 5.0 and might change in future versions.", ProvisionalWarning)
469
469
470 data_pub_class = None
470 data_pub_class = None
471
471
472 exit_now = Bool(False)
472 exit_now = Bool(False)
473 exiter = Instance(ExitAutocall)
473 exiter = Instance(ExitAutocall)
474 @default('exiter')
474 @default('exiter')
475 def _exiter_default(self):
475 def _exiter_default(self):
476 return ExitAutocall(self)
476 return ExitAutocall(self)
477 # Monotonically increasing execution counter
477 # Monotonically increasing execution counter
478 execution_count = Integer(1)
478 execution_count = Integer(1)
479 filename = Unicode("<ipython console>")
479 filename = Unicode("<ipython console>")
480 ipython_dir= Unicode('').tag(config=True) # Set to get_ipython_dir() in __init__
480 ipython_dir= Unicode('').tag(config=True) # Set to get_ipython_dir() in __init__
481
481
482 # Used to transform cells before running them, and check whether code is complete
482 # Used to transform cells before running them, and check whether code is complete
483 input_transformer_manager = Instance('IPython.core.inputtransformer2.TransformerManager',
483 input_transformer_manager = Instance('IPython.core.inputtransformer2.TransformerManager',
484 ())
484 ())
485
485
486 @property
486 @property
487 def input_transformers_cleanup(self):
487 def input_transformers_cleanup(self):
488 return self.input_transformer_manager.cleanup_transforms
488 return self.input_transformer_manager.cleanup_transforms
489
489
490 input_transformers_post = List([],
490 input_transformers_post = List([],
491 help="A list of string input transformers, to be applied after IPython's "
491 help="A list of string input transformers, to be applied after IPython's "
492 "own input transformations."
492 "own input transformations."
493 )
493 )
494
494
495 @property
495 @property
496 def input_splitter(self):
496 def input_splitter(self):
497 """Make this available for backward compatibility (pre-7.0 release) with existing code.
497 """Make this available for backward compatibility (pre-7.0 release) with existing code.
498
498
499 For example, ipykernel ipykernel currently uses
499 For example, ipykernel ipykernel currently uses
500 `shell.input_splitter.check_complete`
500 `shell.input_splitter.check_complete`
501 """
501 """
502 from warnings import warn
502 from warnings import warn
503 warn("`input_splitter` is deprecated since IPython 7.0, prefer `input_transformer_manager`.",
503 warn("`input_splitter` is deprecated since IPython 7.0, prefer `input_transformer_manager`.",
504 DeprecationWarning, stacklevel=2
504 DeprecationWarning, stacklevel=2
505 )
505 )
506 return self.input_transformer_manager
506 return self.input_transformer_manager
507
507
508 logstart = Bool(False, help=
508 logstart = Bool(False, help=
509 """
509 """
510 Start logging to the default log file in overwrite mode.
510 Start logging to the default log file in overwrite mode.
511 Use `logappend` to specify a log file to **append** logs to.
511 Use `logappend` to specify a log file to **append** logs to.
512 """
512 """
513 ).tag(config=True)
513 ).tag(config=True)
514 logfile = Unicode('', help=
514 logfile = Unicode('', help=
515 """
515 """
516 The name of the logfile to use.
516 The name of the logfile to use.
517 """
517 """
518 ).tag(config=True)
518 ).tag(config=True)
519 logappend = Unicode('', help=
519 logappend = Unicode('', help=
520 """
520 """
521 Start logging to the given file in append mode.
521 Start logging to the given file in append mode.
522 Use `logfile` to specify a log file to **overwrite** logs to.
522 Use `logfile` to specify a log file to **overwrite** logs to.
523 """
523 """
524 ).tag(config=True)
524 ).tag(config=True)
525 object_info_string_level = Enum((0,1,2), default_value=0,
525 object_info_string_level = Enum((0,1,2), default_value=0,
526 ).tag(config=True)
526 ).tag(config=True)
527 pdb = Bool(False, help=
527 pdb = Bool(False, help=
528 """
528 """
529 Automatically call the pdb debugger after every exception.
529 Automatically call the pdb debugger after every exception.
530 """
530 """
531 ).tag(config=True)
531 ).tag(config=True)
532 display_page = Bool(False,
532 display_page = Bool(False,
533 help="""If True, anything that would be passed to the pager
533 help="""If True, anything that would be passed to the pager
534 will be displayed as regular output instead."""
534 will be displayed as regular output instead."""
535 ).tag(config=True)
535 ).tag(config=True)
536
536
537 # deprecated prompt traits:
537 # deprecated prompt traits:
538
538
539 prompt_in1 = Unicode('In [\\#]: ',
539 prompt_in1 = Unicode('In [\\#]: ',
540 help="Deprecated since IPython 4.0 and ignored since 5.0, set TerminalInteractiveShell.prompts object directly."
540 help="Deprecated since IPython 4.0 and ignored since 5.0, set TerminalInteractiveShell.prompts object directly."
541 ).tag(config=True)
541 ).tag(config=True)
542 prompt_in2 = Unicode(' .\\D.: ',
542 prompt_in2 = Unicode(' .\\D.: ',
543 help="Deprecated since IPython 4.0 and ignored since 5.0, set TerminalInteractiveShell.prompts object directly."
543 help="Deprecated since IPython 4.0 and ignored since 5.0, set TerminalInteractiveShell.prompts object directly."
544 ).tag(config=True)
544 ).tag(config=True)
545 prompt_out = Unicode('Out[\\#]: ',
545 prompt_out = Unicode('Out[\\#]: ',
546 help="Deprecated since IPython 4.0 and ignored since 5.0, set TerminalInteractiveShell.prompts object directly."
546 help="Deprecated since IPython 4.0 and ignored since 5.0, set TerminalInteractiveShell.prompts object directly."
547 ).tag(config=True)
547 ).tag(config=True)
548 prompts_pad_left = Bool(True,
548 prompts_pad_left = Bool(True,
549 help="Deprecated since IPython 4.0 and ignored since 5.0, set TerminalInteractiveShell.prompts object directly."
549 help="Deprecated since IPython 4.0 and ignored since 5.0, set TerminalInteractiveShell.prompts object directly."
550 ).tag(config=True)
550 ).tag(config=True)
551
551
552 @observe('prompt_in1', 'prompt_in2', 'prompt_out', 'prompt_pad_left')
552 @observe('prompt_in1', 'prompt_in2', 'prompt_out', 'prompt_pad_left')
553 def _prompt_trait_changed(self, change):
553 def _prompt_trait_changed(self, change):
554 name = change['name']
554 name = change['name']
555 warn("InteractiveShell.{name} is deprecated since IPython 4.0"
555 warn("InteractiveShell.{name} is deprecated since IPython 4.0"
556 " and ignored since 5.0, set TerminalInteractiveShell.prompts"
556 " and ignored since 5.0, set TerminalInteractiveShell.prompts"
557 " object directly.".format(name=name))
557 " object directly.".format(name=name))
558
558
559 # protect against weird cases where self.config may not exist:
559 # protect against weird cases where self.config may not exist:
560
560
561 show_rewritten_input = Bool(True,
561 show_rewritten_input = Bool(True,
562 help="Show rewritten input, e.g. for autocall."
562 help="Show rewritten input, e.g. for autocall."
563 ).tag(config=True)
563 ).tag(config=True)
564
564
565 quiet = Bool(False).tag(config=True)
565 quiet = Bool(False).tag(config=True)
566
566
567 history_length = Integer(10000,
567 history_length = Integer(10000,
568 help='Total length of command history'
568 help='Total length of command history'
569 ).tag(config=True)
569 ).tag(config=True)
570
570
571 history_load_length = Integer(1000, help=
571 history_load_length = Integer(1000, help=
572 """
572 """
573 The number of saved history entries to be loaded
573 The number of saved history entries to be loaded
574 into the history buffer at startup.
574 into the history buffer at startup.
575 """
575 """
576 ).tag(config=True)
576 ).tag(config=True)
577
577
578 ast_node_interactivity = Enum(['all', 'last', 'last_expr', 'none', 'last_expr_or_assign'],
578 ast_node_interactivity = Enum(['all', 'last', 'last_expr', 'none', 'last_expr_or_assign'],
579 default_value='last_expr',
579 default_value='last_expr',
580 help="""
580 help="""
581 'all', 'last', 'last_expr' or 'none', 'last_expr_or_assign' specifying
581 'all', 'last', 'last_expr' or 'none', 'last_expr_or_assign' specifying
582 which nodes should be run interactively (displaying output from expressions).
582 which nodes should be run interactively (displaying output from expressions).
583 """
583 """
584 ).tag(config=True)
584 ).tag(config=True)
585
585
586 # TODO: this part of prompt management should be moved to the frontends.
586 # TODO: this part of prompt management should be moved to the frontends.
587 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
587 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
588 separate_in = SeparateUnicode('\n').tag(config=True)
588 separate_in = SeparateUnicode('\n').tag(config=True)
589 separate_out = SeparateUnicode('').tag(config=True)
589 separate_out = SeparateUnicode('').tag(config=True)
590 separate_out2 = SeparateUnicode('').tag(config=True)
590 separate_out2 = SeparateUnicode('').tag(config=True)
591 wildcards_case_sensitive = Bool(True).tag(config=True)
591 wildcards_case_sensitive = Bool(True).tag(config=True)
592 xmode = CaselessStrEnum(('Context', 'Plain', 'Verbose', 'Minimal'),
592 xmode = CaselessStrEnum(('Context', 'Plain', 'Verbose', 'Minimal'),
593 default_value='Context',
593 default_value='Context',
594 help="Switch modes for the IPython exception handlers."
594 help="Switch modes for the IPython exception handlers."
595 ).tag(config=True)
595 ).tag(config=True)
596
596
597 # Subcomponents of InteractiveShell
597 # Subcomponents of InteractiveShell
598 alias_manager = Instance('IPython.core.alias.AliasManager', allow_none=True)
598 alias_manager = Instance('IPython.core.alias.AliasManager', allow_none=True)
599 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager', allow_none=True)
599 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager', allow_none=True)
600 builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap', allow_none=True)
600 builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap', allow_none=True)
601 display_trap = Instance('IPython.core.display_trap.DisplayTrap', allow_none=True)
601 display_trap = Instance('IPython.core.display_trap.DisplayTrap', allow_none=True)
602 extension_manager = Instance('IPython.core.extensions.ExtensionManager', allow_none=True)
602 extension_manager = Instance('IPython.core.extensions.ExtensionManager', allow_none=True)
603 payload_manager = Instance('IPython.core.payload.PayloadManager', allow_none=True)
603 payload_manager = Instance('IPython.core.payload.PayloadManager', allow_none=True)
604 history_manager = Instance('IPython.core.history.HistoryAccessorBase', allow_none=True)
604 history_manager = Instance('IPython.core.history.HistoryAccessorBase', allow_none=True)
605 magics_manager = Instance('IPython.core.magic.MagicsManager', allow_none=True)
605 magics_manager = Instance('IPython.core.magic.MagicsManager', allow_none=True)
606
606
607 profile_dir = Instance('IPython.core.application.ProfileDir', allow_none=True)
607 profile_dir = Instance('IPython.core.application.ProfileDir', allow_none=True)
608 @property
608 @property
609 def profile(self):
609 def profile(self):
610 if self.profile_dir is not None:
610 if self.profile_dir is not None:
611 name = os.path.basename(self.profile_dir.location)
611 name = os.path.basename(self.profile_dir.location)
612 return name.replace('profile_','')
612 return name.replace('profile_','')
613
613
614
614
615 # Private interface
615 # Private interface
616 _post_execute = Dict()
616 _post_execute = Dict()
617
617
618 # Tracks any GUI loop loaded for pylab
618 # Tracks any GUI loop loaded for pylab
619 pylab_gui_select = None
619 pylab_gui_select = None
620
620
621 last_execution_succeeded = Bool(True, help='Did last executed command succeeded')
621 last_execution_succeeded = Bool(True, help='Did last executed command succeeded')
622
622
623 last_execution_result = Instance('IPython.core.interactiveshell.ExecutionResult', help='Result of executing the last command', allow_none=True)
623 last_execution_result = Instance('IPython.core.interactiveshell.ExecutionResult', help='Result of executing the last command', allow_none=True)
624
624
625 def __init__(self, ipython_dir=None, profile_dir=None,
625 def __init__(self, ipython_dir=None, profile_dir=None,
626 user_module=None, user_ns=None,
626 user_module=None, user_ns=None,
627 custom_exceptions=((), None), **kwargs):
627 custom_exceptions=((), None), **kwargs):
628
628
629 # This is where traits with a config_key argument are updated
629 # This is where traits with a config_key argument are updated
630 # from the values on config.
630 # from the values on config.
631 super(InteractiveShell, self).__init__(**kwargs)
631 super(InteractiveShell, self).__init__(**kwargs)
632 if 'PromptManager' in self.config:
632 if 'PromptManager' in self.config:
633 warn('As of IPython 5.0 `PromptManager` config will have no effect'
633 warn('As of IPython 5.0 `PromptManager` config will have no effect'
634 ' and has been replaced by TerminalInteractiveShell.prompts_class')
634 ' and has been replaced by TerminalInteractiveShell.prompts_class')
635 self.configurables = [self]
635 self.configurables = [self]
636
636
637 # These are relatively independent and stateless
637 # These are relatively independent and stateless
638 self.init_ipython_dir(ipython_dir)
638 self.init_ipython_dir(ipython_dir)
639 self.init_profile_dir(profile_dir)
639 self.init_profile_dir(profile_dir)
640 self.init_instance_attrs()
640 self.init_instance_attrs()
641 self.init_environment()
641 self.init_environment()
642
642
643 # Check if we're in a virtualenv, and set up sys.path.
643 # Check if we're in a virtualenv, and set up sys.path.
644 self.init_virtualenv()
644 self.init_virtualenv()
645
645
646 # Create namespaces (user_ns, user_global_ns, etc.)
646 # Create namespaces (user_ns, user_global_ns, etc.)
647 self.init_create_namespaces(user_module, user_ns)
647 self.init_create_namespaces(user_module, user_ns)
648 # This has to be done after init_create_namespaces because it uses
648 # This has to be done after init_create_namespaces because it uses
649 # something in self.user_ns, but before init_sys_modules, which
649 # something in self.user_ns, but before init_sys_modules, which
650 # is the first thing to modify sys.
650 # is the first thing to modify sys.
651 # TODO: When we override sys.stdout and sys.stderr before this class
651 # TODO: When we override sys.stdout and sys.stderr before this class
652 # is created, we are saving the overridden ones here. Not sure if this
652 # is created, we are saving the overridden ones here. Not sure if this
653 # is what we want to do.
653 # is what we want to do.
654 self.save_sys_module_state()
654 self.save_sys_module_state()
655 self.init_sys_modules()
655 self.init_sys_modules()
656
656
657 # While we're trying to have each part of the code directly access what
657 # While we're trying to have each part of the code directly access what
658 # it needs without keeping redundant references to objects, we have too
658 # it needs without keeping redundant references to objects, we have too
659 # much legacy code that expects ip.db to exist.
659 # much legacy code that expects ip.db to exist.
660 self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))
660 self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))
661
661
662 self.init_history()
662 self.init_history()
663 self.init_encoding()
663 self.init_encoding()
664 self.init_prefilter()
664 self.init_prefilter()
665
665
666 self.init_syntax_highlighting()
666 self.init_syntax_highlighting()
667 self.init_hooks()
667 self.init_hooks()
668 self.init_events()
668 self.init_events()
669 self.init_pushd_popd_magic()
669 self.init_pushd_popd_magic()
670 self.init_user_ns()
670 self.init_user_ns()
671 self.init_logger()
671 self.init_logger()
672 self.init_builtins()
672 self.init_builtins()
673
673
674 # The following was in post_config_initialization
674 # The following was in post_config_initialization
675 self.init_inspector()
675 self.init_inspector()
676 self.raw_input_original = input
676 self.raw_input_original = input
677 self.init_completer()
677 self.init_completer()
678 # TODO: init_io() needs to happen before init_traceback handlers
678 # TODO: init_io() needs to happen before init_traceback handlers
679 # because the traceback handlers hardcode the stdout/stderr streams.
679 # because the traceback handlers hardcode the stdout/stderr streams.
680 # This logic in in debugger.Pdb and should eventually be changed.
680 # This logic in in debugger.Pdb and should eventually be changed.
681 self.init_io()
681 self.init_io()
682 self.init_traceback_handlers(custom_exceptions)
682 self.init_traceback_handlers(custom_exceptions)
683 self.init_prompts()
683 self.init_prompts()
684 self.init_display_formatter()
684 self.init_display_formatter()
685 self.init_display_pub()
685 self.init_display_pub()
686 self.init_data_pub()
686 self.init_data_pub()
687 self.init_displayhook()
687 self.init_displayhook()
688 self.init_magics()
688 self.init_magics()
689 self.init_alias()
689 self.init_alias()
690 self.init_logstart()
690 self.init_logstart()
691 self.init_pdb()
691 self.init_pdb()
692 self.init_extension_manager()
692 self.init_extension_manager()
693 self.init_payload()
693 self.init_payload()
694 self.init_deprecation_warnings()
694 self.init_deprecation_warnings()
695 self.hooks.late_startup_hook()
695 self.hooks.late_startup_hook()
696 self.events.trigger('shell_initialized', self)
696 self.events.trigger('shell_initialized', self)
697 atexit.register(self.atexit_operations)
697 atexit.register(self.atexit_operations)
698
698
699 # The trio runner is used for running Trio in the foreground thread. It
699 # The trio runner is used for running Trio in the foreground thread. It
700 # is different from `_trio_runner(async_fn)` in `async_helpers.py`
700 # is different from `_trio_runner(async_fn)` in `async_helpers.py`
701 # which calls `trio.run()` for every cell. This runner runs all cells
701 # which calls `trio.run()` for every cell. This runner runs all cells
702 # inside a single Trio event loop. If used, it is set from
702 # inside a single Trio event loop. If used, it is set from
703 # `ipykernel.kernelapp`.
703 # `ipykernel.kernelapp`.
704 self.trio_runner = None
704 self.trio_runner = None
705
705
706 def get_ipython(self):
706 def get_ipython(self):
707 """Return the currently running IPython instance."""
707 """Return the currently running IPython instance."""
708 return self
708 return self
709
709
710 #-------------------------------------------------------------------------
710 #-------------------------------------------------------------------------
711 # Trait changed handlers
711 # Trait changed handlers
712 #-------------------------------------------------------------------------
712 #-------------------------------------------------------------------------
713 @observe('ipython_dir')
713 @observe('ipython_dir')
714 def _ipython_dir_changed(self, change):
714 def _ipython_dir_changed(self, change):
715 ensure_dir_exists(change['new'])
715 ensure_dir_exists(change['new'])
716
716
717 def set_autoindent(self,value=None):
717 def set_autoindent(self,value=None):
718 """Set the autoindent flag.
718 """Set the autoindent flag.
719
719
720 If called with no arguments, it acts as a toggle."""
720 If called with no arguments, it acts as a toggle."""
721 if value is None:
721 if value is None:
722 self.autoindent = not self.autoindent
722 self.autoindent = not self.autoindent
723 else:
723 else:
724 self.autoindent = value
724 self.autoindent = value
725
725
726 def set_trio_runner(self, tr):
726 def set_trio_runner(self, tr):
727 self.trio_runner = tr
727 self.trio_runner = tr
728
728
729 #-------------------------------------------------------------------------
729 #-------------------------------------------------------------------------
730 # init_* methods called by __init__
730 # init_* methods called by __init__
731 #-------------------------------------------------------------------------
731 #-------------------------------------------------------------------------
732
732
733 def init_ipython_dir(self, ipython_dir):
733 def init_ipython_dir(self, ipython_dir):
734 if ipython_dir is not None:
734 if ipython_dir is not None:
735 self.ipython_dir = ipython_dir
735 self.ipython_dir = ipython_dir
736 return
736 return
737
737
738 self.ipython_dir = get_ipython_dir()
738 self.ipython_dir = get_ipython_dir()
739
739
740 def init_profile_dir(self, profile_dir):
740 def init_profile_dir(self, profile_dir):
741 if profile_dir is not None:
741 if profile_dir is not None:
742 self.profile_dir = profile_dir
742 self.profile_dir = profile_dir
743 return
743 return
744 self.profile_dir = ProfileDir.create_profile_dir_by_name(
744 self.profile_dir = ProfileDir.create_profile_dir_by_name(
745 self.ipython_dir, "default"
745 self.ipython_dir, "default"
746 )
746 )
747
747
748 def init_instance_attrs(self):
748 def init_instance_attrs(self):
749 self.more = False
749 self.more = False
750
750
751 # command compiler
751 # command compiler
752 self.compile = self.compiler_class()
752 self.compile = self.compiler_class()
753
753
754 # Make an empty namespace, which extension writers can rely on both
754 # Make an empty namespace, which extension writers can rely on both
755 # existing and NEVER being used by ipython itself. This gives them a
755 # existing and NEVER being used by ipython itself. This gives them a
756 # convenient location for storing additional information and state
756 # convenient location for storing additional information and state
757 # their extensions may require, without fear of collisions with other
757 # their extensions may require, without fear of collisions with other
758 # ipython names that may develop later.
758 # ipython names that may develop later.
759 self.meta = Struct()
759 self.meta = Struct()
760
760
761 # Temporary files used for various purposes. Deleted at exit.
761 # Temporary files used for various purposes. Deleted at exit.
762 self.tempfiles = []
762 self.tempfiles = []
763 self.tempdirs = []
763 self.tempdirs = []
764
764
765 # keep track of where we started running (mainly for crash post-mortem)
765 # keep track of where we started running (mainly for crash post-mortem)
766 # This is not being used anywhere currently.
766 # This is not being used anywhere currently.
767 self.starting_dir = os.getcwd()
767 self.starting_dir = os.getcwd()
768
768
769 # Indentation management
769 # Indentation management
770 self.indent_current_nsp = 0
770 self.indent_current_nsp = 0
771
771
772 # Dict to track post-execution functions that have been registered
772 # Dict to track post-execution functions that have been registered
773 self._post_execute = {}
773 self._post_execute = {}
774
774
775 def init_environment(self):
775 def init_environment(self):
776 """Any changes we need to make to the user's environment."""
776 """Any changes we need to make to the user's environment."""
777 pass
777 pass
778
778
779 def init_encoding(self):
779 def init_encoding(self):
780 # Get system encoding at startup time. Certain terminals (like Emacs
780 # Get system encoding at startup time. Certain terminals (like Emacs
781 # under Win32 have it set to None, and we need to have a known valid
781 # under Win32 have it set to None, and we need to have a known valid
782 # encoding to use in the raw_input() method
782 # encoding to use in the raw_input() method
783 try:
783 try:
784 self.stdin_encoding = sys.stdin.encoding or 'ascii'
784 self.stdin_encoding = sys.stdin.encoding or 'ascii'
785 except AttributeError:
785 except AttributeError:
786 self.stdin_encoding = 'ascii'
786 self.stdin_encoding = 'ascii'
787
787
788
788
789 @observe('colors')
789 @observe('colors')
790 def init_syntax_highlighting(self, changes=None):
790 def init_syntax_highlighting(self, changes=None):
791 # Python source parser/formatter for syntax highlighting
791 # Python source parser/formatter for syntax highlighting
792 pyformat = PyColorize.Parser(style=self.colors, parent=self).format
792 pyformat = PyColorize.Parser(style=self.colors, parent=self).format
793 self.pycolorize = lambda src: pyformat(src,'str')
793 self.pycolorize = lambda src: pyformat(src,'str')
794
794
795 def refresh_style(self):
795 def refresh_style(self):
796 # No-op here, used in subclass
796 # No-op here, used in subclass
797 pass
797 pass
798
798
799 def init_pushd_popd_magic(self):
799 def init_pushd_popd_magic(self):
800 # for pushd/popd management
800 # for pushd/popd management
801 self.home_dir = get_home_dir()
801 self.home_dir = get_home_dir()
802
802
803 self.dir_stack = []
803 self.dir_stack = []
804
804
805 def init_logger(self):
805 def init_logger(self):
806 self.logger = Logger(self.home_dir, logfname='ipython_log.py',
806 self.logger = Logger(self.home_dir, logfname='ipython_log.py',
807 logmode='rotate')
807 logmode='rotate')
808
808
809 def init_logstart(self):
809 def init_logstart(self):
810 """Initialize logging in case it was requested at the command line.
810 """Initialize logging in case it was requested at the command line.
811 """
811 """
812 if self.logappend:
812 if self.logappend:
813 self.magic('logstart %s append' % self.logappend)
813 self.magic('logstart %s append' % self.logappend)
814 elif self.logfile:
814 elif self.logfile:
815 self.magic('logstart %s' % self.logfile)
815 self.magic('logstart %s' % self.logfile)
816 elif self.logstart:
816 elif self.logstart:
817 self.magic('logstart')
817 self.magic('logstart')
818
818
819 def init_deprecation_warnings(self):
819 def init_deprecation_warnings(self):
820 """
820 """
821 register default filter for deprecation warning.
821 register default filter for deprecation warning.
822
822
823 This will allow deprecation warning of function used interactively to show
823 This will allow deprecation warning of function used interactively to show
824 warning to users, and still hide deprecation warning from libraries import.
824 warning to users, and still hide deprecation warning from libraries import.
825 """
825 """
826 if sys.version_info < (3,7):
826 if sys.version_info < (3,7):
827 warnings.filterwarnings("default", category=DeprecationWarning, module=self.user_ns.get("__name__"))
827 warnings.filterwarnings("default", category=DeprecationWarning, module=self.user_ns.get("__name__"))
828
828
829
829
830 def init_builtins(self):
830 def init_builtins(self):
831 # A single, static flag that we set to True. Its presence indicates
831 # A single, static flag that we set to True. Its presence indicates
832 # that an IPython shell has been created, and we make no attempts at
832 # that an IPython shell has been created, and we make no attempts at
833 # removing on exit or representing the existence of more than one
833 # removing on exit or representing the existence of more than one
834 # IPython at a time.
834 # IPython at a time.
835 builtin_mod.__dict__['__IPYTHON__'] = True
835 builtin_mod.__dict__['__IPYTHON__'] = True
836 builtin_mod.__dict__['display'] = display
836 builtin_mod.__dict__['display'] = display
837
837
838 self.builtin_trap = BuiltinTrap(shell=self)
838 self.builtin_trap = BuiltinTrap(shell=self)
839
839
840 @observe('colors')
840 @observe('colors')
841 def init_inspector(self, changes=None):
841 def init_inspector(self, changes=None):
842 # Object inspector
842 # Object inspector
843 self.inspector = oinspect.Inspector(oinspect.InspectColors,
843 self.inspector = oinspect.Inspector(oinspect.InspectColors,
844 PyColorize.ANSICodeColors,
844 PyColorize.ANSICodeColors,
845 self.colors,
845 self.colors,
846 self.object_info_string_level)
846 self.object_info_string_level)
847
847
848 def init_io(self):
848 def init_io(self):
849 # This will just use sys.stdout and sys.stderr. If you want to
849 # This will just use sys.stdout and sys.stderr. If you want to
850 # override sys.stdout and sys.stderr themselves, you need to do that
850 # override sys.stdout and sys.stderr themselves, you need to do that
851 # *before* instantiating this class, because io holds onto
851 # *before* instantiating this class, because io holds onto
852 # references to the underlying streams.
852 # references to the underlying streams.
853 # io.std* are deprecated, but don't show our own deprecation warnings
853 # io.std* are deprecated, but don't show our own deprecation warnings
854 # during initialization of the deprecated API.
854 # during initialization of the deprecated API.
855 with warnings.catch_warnings():
855 with warnings.catch_warnings():
856 warnings.simplefilter('ignore', DeprecationWarning)
856 warnings.simplefilter('ignore', DeprecationWarning)
857 io.stdout = io.IOStream(sys.stdout)
857 io.stdout = io.IOStream(sys.stdout)
858 io.stderr = io.IOStream(sys.stderr)
858 io.stderr = io.IOStream(sys.stderr)
859
859
860 def init_prompts(self):
860 def init_prompts(self):
861 # Set system prompts, so that scripts can decide if they are running
861 # Set system prompts, so that scripts can decide if they are running
862 # interactively.
862 # interactively.
863 sys.ps1 = 'In : '
863 sys.ps1 = 'In : '
864 sys.ps2 = '...: '
864 sys.ps2 = '...: '
865 sys.ps3 = 'Out: '
865 sys.ps3 = 'Out: '
866
866
867 def init_display_formatter(self):
867 def init_display_formatter(self):
868 self.display_formatter = DisplayFormatter(parent=self)
868 self.display_formatter = DisplayFormatter(parent=self)
869 self.configurables.append(self.display_formatter)
869 self.configurables.append(self.display_formatter)
870
870
871 def init_display_pub(self):
871 def init_display_pub(self):
872 self.display_pub = self.display_pub_class(parent=self, shell=self)
872 self.display_pub = self.display_pub_class(parent=self, shell=self)
873 self.configurables.append(self.display_pub)
873 self.configurables.append(self.display_pub)
874
874
875 def init_data_pub(self):
875 def init_data_pub(self):
876 if not self.data_pub_class:
876 if not self.data_pub_class:
877 self.data_pub = None
877 self.data_pub = None
878 return
878 return
879 self.data_pub = self.data_pub_class(parent=self)
879 self.data_pub = self.data_pub_class(parent=self)
880 self.configurables.append(self.data_pub)
880 self.configurables.append(self.data_pub)
881
881
882 def init_displayhook(self):
882 def init_displayhook(self):
883 # Initialize displayhook, set in/out prompts and printing system
883 # Initialize displayhook, set in/out prompts and printing system
884 self.displayhook = self.displayhook_class(
884 self.displayhook = self.displayhook_class(
885 parent=self,
885 parent=self,
886 shell=self,
886 shell=self,
887 cache_size=self.cache_size,
887 cache_size=self.cache_size,
888 )
888 )
889 self.configurables.append(self.displayhook)
889 self.configurables.append(self.displayhook)
890 # This is a context manager that installs/revmoes the displayhook at
890 # This is a context manager that installs/revmoes the displayhook at
891 # the appropriate time.
891 # the appropriate time.
892 self.display_trap = DisplayTrap(hook=self.displayhook)
892 self.display_trap = DisplayTrap(hook=self.displayhook)
893
893
894 def init_virtualenv(self):
894 def init_virtualenv(self):
895 """Add a virtualenv to sys.path so the user can import modules from it.
895 """Add a virtualenv to sys.path so the user can import modules from it.
896 This isn't perfect: it doesn't use the Python interpreter with which the
896 This isn't perfect: it doesn't use the Python interpreter with which the
897 virtualenv was built, and it ignores the --no-site-packages option. A
897 virtualenv was built, and it ignores the --no-site-packages option. A
898 warning will appear suggesting the user installs IPython in the
898 warning will appear suggesting the user installs IPython in the
899 virtualenv, but for many cases, it probably works well enough.
899 virtualenv, but for many cases, it probably works well enough.
900
900
901 Adapted from code snippets online.
901 Adapted from code snippets online.
902
902
903 http://blog.ufsoft.org/2009/1/29/ipython-and-virtualenv
903 http://blog.ufsoft.org/2009/1/29/ipython-and-virtualenv
904 """
904 """
905 if 'VIRTUAL_ENV' not in os.environ:
905 if 'VIRTUAL_ENV' not in os.environ:
906 # Not in a virtualenv
906 # Not in a virtualenv
907 return
907 return
908
908
909 p = os.path.normcase(sys.executable)
909 p = os.path.normcase(sys.executable)
910 p_venv = os.path.normcase(os.environ['VIRTUAL_ENV'])
910 p_venv = os.path.normcase(os.environ['VIRTUAL_ENV'])
911
911
912 # executable path should end like /bin/python or \\scripts\\python.exe
912 # executable path should end like /bin/python or \\scripts\\python.exe
913 p_exe_up2 = os.path.dirname(os.path.dirname(p))
913 p_exe_up2 = os.path.dirname(os.path.dirname(p))
914 if p_exe_up2 and os.path.exists(p_venv) and os.path.samefile(p_exe_up2, p_venv):
914 if p_exe_up2 and os.path.exists(p_venv) and os.path.samefile(p_exe_up2, p_venv):
915 # Our exe is inside the virtualenv, don't need to do anything.
915 # Our exe is inside the virtualenv, don't need to do anything.
916 return
916 return
917
917
918 # fallback venv detection:
918 # fallback venv detection:
919 # stdlib venv may symlink sys.executable, so we can't use realpath.
919 # stdlib venv may symlink sys.executable, so we can't use realpath.
920 # but others can symlink *to* the venv Python, so we can't just use sys.executable.
920 # but others can symlink *to* the venv Python, so we can't just use sys.executable.
921 # So we just check every item in the symlink tree (generally <= 3)
921 # So we just check every item in the symlink tree (generally <= 3)
922 paths = [p]
922 paths = [p]
923 while os.path.islink(p):
923 while os.path.islink(p):
924 p = os.path.normcase(os.path.join(os.path.dirname(p), os.readlink(p)))
924 p = os.path.normcase(os.path.join(os.path.dirname(p), os.readlink(p)))
925 paths.append(p)
925 paths.append(p)
926
926
927 # In Cygwin paths like "c:\..." and '\cygdrive\c\...' are possible
927 # In Cygwin paths like "c:\..." and '\cygdrive\c\...' are possible
928 if p_venv.startswith('\\cygdrive'):
928 if p_venv.startswith('\\cygdrive'):
929 p_venv = p_venv[11:]
929 p_venv = p_venv[11:]
930 elif len(p_venv) >= 2 and p_venv[1] == ':':
930 elif len(p_venv) >= 2 and p_venv[1] == ':':
931 p_venv = p_venv[2:]
931 p_venv = p_venv[2:]
932
932
933 if any(p_venv in p for p in paths):
933 if any(p_venv in p for p in paths):
934 # Running properly in the virtualenv, don't need to do anything
934 # Running properly in the virtualenv, don't need to do anything
935 return
935 return
936
936
937 warn("Attempting to work in a virtualenv. If you encounter problems, please "
937 warn("Attempting to work in a virtualenv. If you encounter problems, please "
938 "install IPython inside the virtualenv.")
938 "install IPython inside the virtualenv.")
939 if sys.platform == "win32":
939 if sys.platform == "win32":
940 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'Lib', 'site-packages')
940 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'Lib', 'site-packages')
941 else:
941 else:
942 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'lib',
942 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'lib',
943 'python%d.%d' % sys.version_info[:2], 'site-packages')
943 'python%d.%d' % sys.version_info[:2], 'site-packages')
944
944
945 import site
945 import site
946 sys.path.insert(0, virtual_env)
946 sys.path.insert(0, virtual_env)
947 site.addsitedir(virtual_env)
947 site.addsitedir(virtual_env)
948
948
949 #-------------------------------------------------------------------------
949 #-------------------------------------------------------------------------
950 # Things related to injections into the sys module
950 # Things related to injections into the sys module
951 #-------------------------------------------------------------------------
951 #-------------------------------------------------------------------------
952
952
953 def save_sys_module_state(self):
953 def save_sys_module_state(self):
954 """Save the state of hooks in the sys module.
954 """Save the state of hooks in the sys module.
955
955
956 This has to be called after self.user_module is created.
956 This has to be called after self.user_module is created.
957 """
957 """
958 self._orig_sys_module_state = {'stdin': sys.stdin,
958 self._orig_sys_module_state = {'stdin': sys.stdin,
959 'stdout': sys.stdout,
959 'stdout': sys.stdout,
960 'stderr': sys.stderr,
960 'stderr': sys.stderr,
961 'excepthook': sys.excepthook}
961 'excepthook': sys.excepthook}
962 self._orig_sys_modules_main_name = self.user_module.__name__
962 self._orig_sys_modules_main_name = self.user_module.__name__
963 self._orig_sys_modules_main_mod = sys.modules.get(self.user_module.__name__)
963 self._orig_sys_modules_main_mod = sys.modules.get(self.user_module.__name__)
964
964
965 def restore_sys_module_state(self):
965 def restore_sys_module_state(self):
966 """Restore the state of the sys module."""
966 """Restore the state of the sys module."""
967 try:
967 try:
968 for k, v in self._orig_sys_module_state.items():
968 for k, v in self._orig_sys_module_state.items():
969 setattr(sys, k, v)
969 setattr(sys, k, v)
970 except AttributeError:
970 except AttributeError:
971 pass
971 pass
972 # Reset what what done in self.init_sys_modules
972 # Reset what what done in self.init_sys_modules
973 if self._orig_sys_modules_main_mod is not None:
973 if self._orig_sys_modules_main_mod is not None:
974 sys.modules[self._orig_sys_modules_main_name] = self._orig_sys_modules_main_mod
974 sys.modules[self._orig_sys_modules_main_name] = self._orig_sys_modules_main_mod
975
975
976 #-------------------------------------------------------------------------
976 #-------------------------------------------------------------------------
977 # Things related to the banner
977 # Things related to the banner
978 #-------------------------------------------------------------------------
978 #-------------------------------------------------------------------------
979
979
980 @property
980 @property
981 def banner(self):
981 def banner(self):
982 banner = self.banner1
982 banner = self.banner1
983 if self.profile and self.profile != 'default':
983 if self.profile and self.profile != 'default':
984 banner += '\nIPython profile: %s\n' % self.profile
984 banner += '\nIPython profile: %s\n' % self.profile
985 if self.banner2:
985 if self.banner2:
986 banner += '\n' + self.banner2
986 banner += '\n' + self.banner2
987 return banner
987 return banner
988
988
989 def show_banner(self, banner=None):
989 def show_banner(self, banner=None):
990 if banner is None:
990 if banner is None:
991 banner = self.banner
991 banner = self.banner
992 sys.stdout.write(banner)
992 sys.stdout.write(banner)
993
993
994 #-------------------------------------------------------------------------
994 #-------------------------------------------------------------------------
995 # Things related to hooks
995 # Things related to hooks
996 #-------------------------------------------------------------------------
996 #-------------------------------------------------------------------------
997
997
998 def init_hooks(self):
998 def init_hooks(self):
999 # hooks holds pointers used for user-side customizations
999 # hooks holds pointers used for user-side customizations
1000 self.hooks = Struct()
1000 self.hooks = Struct()
1001
1001
1002 self.strdispatchers = {}
1002 self.strdispatchers = {}
1003
1003
1004 # Set all default hooks, defined in the IPython.hooks module.
1004 # Set all default hooks, defined in the IPython.hooks module.
1005 hooks = IPython.core.hooks
1005 hooks = IPython.core.hooks
1006 for hook_name in hooks.__all__:
1006 for hook_name in hooks.__all__:
1007 # default hooks have priority 100, i.e. low; user hooks should have
1007 # default hooks have priority 100, i.e. low; user hooks should have
1008 # 0-100 priority
1008 # 0-100 priority
1009 self.set_hook(hook_name,getattr(hooks,hook_name), 100, _warn_deprecated=False)
1009 self.set_hook(hook_name,getattr(hooks,hook_name), 100, _warn_deprecated=False)
1010
1010
1011 if self.display_page:
1011 if self.display_page:
1012 self.set_hook('show_in_pager', page.as_hook(page.display_page), 90)
1012 self.set_hook('show_in_pager', page.as_hook(page.display_page), 90)
1013
1013
1014 def set_hook(self,name,hook, priority=50, str_key=None, re_key=None,
1014 def set_hook(self,name,hook, priority=50, str_key=None, re_key=None,
1015 _warn_deprecated=True):
1015 _warn_deprecated=True):
1016 """set_hook(name,hook) -> sets an internal IPython hook.
1016 """set_hook(name,hook) -> sets an internal IPython hook.
1017
1017
1018 IPython exposes some of its internal API as user-modifiable hooks. By
1018 IPython exposes some of its internal API as user-modifiable hooks. By
1019 adding your function to one of these hooks, you can modify IPython's
1019 adding your function to one of these hooks, you can modify IPython's
1020 behavior to call at runtime your own routines."""
1020 behavior to call at runtime your own routines."""
1021
1021
1022 # At some point in the future, this should validate the hook before it
1022 # At some point in the future, this should validate the hook before it
1023 # accepts it. Probably at least check that the hook takes the number
1023 # accepts it. Probably at least check that the hook takes the number
1024 # of args it's supposed to.
1024 # of args it's supposed to.
1025
1025
1026 f = types.MethodType(hook,self)
1026 f = types.MethodType(hook,self)
1027
1027
1028 # check if the hook is for strdispatcher first
1028 # check if the hook is for strdispatcher first
1029 if str_key is not None:
1029 if str_key is not None:
1030 sdp = self.strdispatchers.get(name, StrDispatch())
1030 sdp = self.strdispatchers.get(name, StrDispatch())
1031 sdp.add_s(str_key, f, priority )
1031 sdp.add_s(str_key, f, priority )
1032 self.strdispatchers[name] = sdp
1032 self.strdispatchers[name] = sdp
1033 return
1033 return
1034 if re_key is not None:
1034 if re_key is not None:
1035 sdp = self.strdispatchers.get(name, StrDispatch())
1035 sdp = self.strdispatchers.get(name, StrDispatch())
1036 sdp.add_re(re.compile(re_key), f, priority )
1036 sdp.add_re(re.compile(re_key), f, priority )
1037 self.strdispatchers[name] = sdp
1037 self.strdispatchers[name] = sdp
1038 return
1038 return
1039
1039
1040 dp = getattr(self.hooks, name, None)
1040 dp = getattr(self.hooks, name, None)
1041 if name not in IPython.core.hooks.__all__:
1041 if name not in IPython.core.hooks.__all__:
1042 print("Warning! Hook '%s' is not one of %s" % \
1042 print("Warning! Hook '%s' is not one of %s" % \
1043 (name, IPython.core.hooks.__all__ ))
1043 (name, IPython.core.hooks.__all__ ))
1044
1044
1045 if _warn_deprecated and (name in IPython.core.hooks.deprecated):
1045 if _warn_deprecated and (name in IPython.core.hooks.deprecated):
1046 alternative = IPython.core.hooks.deprecated[name]
1046 alternative = IPython.core.hooks.deprecated[name]
1047 warn("Hook {} is deprecated. Use {} instead.".format(name, alternative), stacklevel=2)
1047 warn("Hook {} is deprecated. Use {} instead.".format(name, alternative), stacklevel=2)
1048
1048
1049 if not dp:
1049 if not dp:
1050 dp = IPython.core.hooks.CommandChainDispatcher()
1050 dp = IPython.core.hooks.CommandChainDispatcher()
1051
1051
1052 try:
1052 try:
1053 dp.add(f,priority)
1053 dp.add(f,priority)
1054 except AttributeError:
1054 except AttributeError:
1055 # it was not commandchain, plain old func - replace
1055 # it was not commandchain, plain old func - replace
1056 dp = f
1056 dp = f
1057
1057
1058 setattr(self.hooks,name, dp)
1058 setattr(self.hooks,name, dp)
1059
1059
1060 #-------------------------------------------------------------------------
1060 #-------------------------------------------------------------------------
1061 # Things related to events
1061 # Things related to events
1062 #-------------------------------------------------------------------------
1062 #-------------------------------------------------------------------------
1063
1063
1064 def init_events(self):
1064 def init_events(self):
1065 self.events = EventManager(self, available_events)
1065 self.events = EventManager(self, available_events)
1066
1066
1067 self.events.register("pre_execute", self._clear_warning_registry)
1067 self.events.register("pre_execute", self._clear_warning_registry)
1068
1068
1069 def register_post_execute(self, func):
1069 def register_post_execute(self, func):
1070 """DEPRECATED: Use ip.events.register('post_run_cell', func)
1070 """DEPRECATED: Use ip.events.register('post_run_cell', func)
1071
1071
1072 Register a function for calling after code execution.
1072 Register a function for calling after code execution.
1073 """
1073 """
1074 warn("ip.register_post_execute is deprecated, use "
1074 warn("ip.register_post_execute is deprecated, use "
1075 "ip.events.register('post_run_cell', func) instead.", stacklevel=2)
1075 "ip.events.register('post_run_cell', func) instead.", stacklevel=2)
1076 self.events.register('post_run_cell', func)
1076 self.events.register('post_run_cell', func)
1077
1077
1078 def _clear_warning_registry(self):
1078 def _clear_warning_registry(self):
1079 # clear the warning registry, so that different code blocks with
1079 # clear the warning registry, so that different code blocks with
1080 # overlapping line number ranges don't cause spurious suppression of
1080 # overlapping line number ranges don't cause spurious suppression of
1081 # warnings (see gh-6611 for details)
1081 # warnings (see gh-6611 for details)
1082 if "__warningregistry__" in self.user_global_ns:
1082 if "__warningregistry__" in self.user_global_ns:
1083 del self.user_global_ns["__warningregistry__"]
1083 del self.user_global_ns["__warningregistry__"]
1084
1084
1085 #-------------------------------------------------------------------------
1085 #-------------------------------------------------------------------------
1086 # Things related to the "main" module
1086 # Things related to the "main" module
1087 #-------------------------------------------------------------------------
1087 #-------------------------------------------------------------------------
1088
1088
1089 def new_main_mod(self, filename, modname):
1089 def new_main_mod(self, filename, modname):
1090 """Return a new 'main' module object for user code execution.
1090 """Return a new 'main' module object for user code execution.
1091
1091
1092 ``filename`` should be the path of the script which will be run in the
1092 ``filename`` should be the path of the script which will be run in the
1093 module. Requests with the same filename will get the same module, with
1093 module. Requests with the same filename will get the same module, with
1094 its namespace cleared.
1094 its namespace cleared.
1095
1095
1096 ``modname`` should be the module name - normally either '__main__' or
1096 ``modname`` should be the module name - normally either '__main__' or
1097 the basename of the file without the extension.
1097 the basename of the file without the extension.
1098
1098
1099 When scripts are executed via %run, we must keep a reference to their
1099 When scripts are executed via %run, we must keep a reference to their
1100 __main__ module around so that Python doesn't
1100 __main__ module around so that Python doesn't
1101 clear it, rendering references to module globals useless.
1101 clear it, rendering references to module globals useless.
1102
1102
1103 This method keeps said reference in a private dict, keyed by the
1103 This method keeps said reference in a private dict, keyed by the
1104 absolute path of the script. This way, for multiple executions of the
1104 absolute path of the script. This way, for multiple executions of the
1105 same script we only keep one copy of the namespace (the last one),
1105 same script we only keep one copy of the namespace (the last one),
1106 thus preventing memory leaks from old references while allowing the
1106 thus preventing memory leaks from old references while allowing the
1107 objects from the last execution to be accessible.
1107 objects from the last execution to be accessible.
1108 """
1108 """
1109 filename = os.path.abspath(filename)
1109 filename = os.path.abspath(filename)
1110 try:
1110 try:
1111 main_mod = self._main_mod_cache[filename]
1111 main_mod = self._main_mod_cache[filename]
1112 except KeyError:
1112 except KeyError:
1113 main_mod = self._main_mod_cache[filename] = types.ModuleType(
1113 main_mod = self._main_mod_cache[filename] = types.ModuleType(
1114 modname,
1114 modname,
1115 doc="Module created for script run in IPython")
1115 doc="Module created for script run in IPython")
1116 else:
1116 else:
1117 main_mod.__dict__.clear()
1117 main_mod.__dict__.clear()
1118 main_mod.__name__ = modname
1118 main_mod.__name__ = modname
1119
1119
1120 main_mod.__file__ = filename
1120 main_mod.__file__ = filename
1121 # It seems pydoc (and perhaps others) needs any module instance to
1121 # It seems pydoc (and perhaps others) needs any module instance to
1122 # implement a __nonzero__ method
1122 # implement a __nonzero__ method
1123 main_mod.__nonzero__ = lambda : True
1123 main_mod.__nonzero__ = lambda : True
1124
1124
1125 return main_mod
1125 return main_mod
1126
1126
1127 def clear_main_mod_cache(self):
1127 def clear_main_mod_cache(self):
1128 """Clear the cache of main modules.
1128 """Clear the cache of main modules.
1129
1129
1130 Mainly for use by utilities like %reset.
1130 Mainly for use by utilities like %reset.
1131
1131
1132 Examples
1132 Examples
1133 --------
1133 --------
1134
1134
1135 In [15]: import IPython
1135 In [15]: import IPython
1136
1136
1137 In [16]: m = _ip.new_main_mod(IPython.__file__, 'IPython')
1137 In [16]: m = _ip.new_main_mod(IPython.__file__, 'IPython')
1138
1138
1139 In [17]: len(_ip._main_mod_cache) > 0
1139 In [17]: len(_ip._main_mod_cache) > 0
1140 Out[17]: True
1140 Out[17]: True
1141
1141
1142 In [18]: _ip.clear_main_mod_cache()
1142 In [18]: _ip.clear_main_mod_cache()
1143
1143
1144 In [19]: len(_ip._main_mod_cache) == 0
1144 In [19]: len(_ip._main_mod_cache) == 0
1145 Out[19]: True
1145 Out[19]: True
1146 """
1146 """
1147 self._main_mod_cache.clear()
1147 self._main_mod_cache.clear()
1148
1148
1149 #-------------------------------------------------------------------------
1149 #-------------------------------------------------------------------------
1150 # Things related to debugging
1150 # Things related to debugging
1151 #-------------------------------------------------------------------------
1151 #-------------------------------------------------------------------------
1152
1152
1153 def init_pdb(self):
1153 def init_pdb(self):
1154 # Set calling of pdb on exceptions
1154 # Set calling of pdb on exceptions
1155 # self.call_pdb is a property
1155 # self.call_pdb is a property
1156 self.call_pdb = self.pdb
1156 self.call_pdb = self.pdb
1157
1157
1158 def _get_call_pdb(self):
1158 def _get_call_pdb(self):
1159 return self._call_pdb
1159 return self._call_pdb
1160
1160
1161 def _set_call_pdb(self,val):
1161 def _set_call_pdb(self,val):
1162
1162
1163 if val not in (0,1,False,True):
1163 if val not in (0,1,False,True):
1164 raise ValueError('new call_pdb value must be boolean')
1164 raise ValueError('new call_pdb value must be boolean')
1165
1165
1166 # store value in instance
1166 # store value in instance
1167 self._call_pdb = val
1167 self._call_pdb = val
1168
1168
1169 # notify the actual exception handlers
1169 # notify the actual exception handlers
1170 self.InteractiveTB.call_pdb = val
1170 self.InteractiveTB.call_pdb = val
1171
1171
1172 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
1172 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
1173 'Control auto-activation of pdb at exceptions')
1173 'Control auto-activation of pdb at exceptions')
1174
1174
1175 def debugger(self,force=False):
1175 def debugger(self,force=False):
1176 """Call the pdb debugger.
1176 """Call the pdb debugger.
1177
1177
1178 Keywords:
1178 Keywords:
1179
1179
1180 - force(False): by default, this routine checks the instance call_pdb
1180 - force(False): by default, this routine checks the instance call_pdb
1181 flag and does not actually invoke the debugger if the flag is false.
1181 flag and does not actually invoke the debugger if the flag is false.
1182 The 'force' option forces the debugger to activate even if the flag
1182 The 'force' option forces the debugger to activate even if the flag
1183 is false.
1183 is false.
1184 """
1184 """
1185
1185
1186 if not (force or self.call_pdb):
1186 if not (force or self.call_pdb):
1187 return
1187 return
1188
1188
1189 if not hasattr(sys,'last_traceback'):
1189 if not hasattr(sys,'last_traceback'):
1190 error('No traceback has been produced, nothing to debug.')
1190 error('No traceback has been produced, nothing to debug.')
1191 return
1191 return
1192
1192
1193 self.InteractiveTB.debugger(force=True)
1193 self.InteractiveTB.debugger(force=True)
1194
1194
1195 #-------------------------------------------------------------------------
1195 #-------------------------------------------------------------------------
1196 # Things related to IPython's various namespaces
1196 # Things related to IPython's various namespaces
1197 #-------------------------------------------------------------------------
1197 #-------------------------------------------------------------------------
1198 default_user_namespaces = True
1198 default_user_namespaces = True
1199
1199
1200 def init_create_namespaces(self, user_module=None, user_ns=None):
1200 def init_create_namespaces(self, user_module=None, user_ns=None):
1201 # Create the namespace where the user will operate. user_ns is
1201 # Create the namespace where the user will operate. user_ns is
1202 # normally the only one used, and it is passed to the exec calls as
1202 # normally the only one used, and it is passed to the exec calls as
1203 # the locals argument. But we do carry a user_global_ns namespace
1203 # the locals argument. But we do carry a user_global_ns namespace
1204 # given as the exec 'globals' argument, This is useful in embedding
1204 # given as the exec 'globals' argument, This is useful in embedding
1205 # situations where the ipython shell opens in a context where the
1205 # situations where the ipython shell opens in a context where the
1206 # distinction between locals and globals is meaningful. For
1206 # distinction between locals and globals is meaningful. For
1207 # non-embedded contexts, it is just the same object as the user_ns dict.
1207 # non-embedded contexts, it is just the same object as the user_ns dict.
1208
1208
1209 # FIXME. For some strange reason, __builtins__ is showing up at user
1209 # FIXME. For some strange reason, __builtins__ is showing up at user
1210 # level as a dict instead of a module. This is a manual fix, but I
1210 # level as a dict instead of a module. This is a manual fix, but I
1211 # should really track down where the problem is coming from. Alex
1211 # should really track down where the problem is coming from. Alex
1212 # Schmolck reported this problem first.
1212 # Schmolck reported this problem first.
1213
1213
1214 # A useful post by Alex Martelli on this topic:
1214 # A useful post by Alex Martelli on this topic:
1215 # Re: inconsistent value from __builtins__
1215 # Re: inconsistent value from __builtins__
1216 # Von: Alex Martelli <aleaxit@yahoo.com>
1216 # Von: Alex Martelli <aleaxit@yahoo.com>
1217 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
1217 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
1218 # Gruppen: comp.lang.python
1218 # Gruppen: comp.lang.python
1219
1219
1220 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
1220 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
1221 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
1221 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
1222 # > <type 'dict'>
1222 # > <type 'dict'>
1223 # > >>> print type(__builtins__)
1223 # > >>> print type(__builtins__)
1224 # > <type 'module'>
1224 # > <type 'module'>
1225 # > Is this difference in return value intentional?
1225 # > Is this difference in return value intentional?
1226
1226
1227 # Well, it's documented that '__builtins__' can be either a dictionary
1227 # Well, it's documented that '__builtins__' can be either a dictionary
1228 # or a module, and it's been that way for a long time. Whether it's
1228 # or a module, and it's been that way for a long time. Whether it's
1229 # intentional (or sensible), I don't know. In any case, the idea is
1229 # intentional (or sensible), I don't know. In any case, the idea is
1230 # that if you need to access the built-in namespace directly, you
1230 # that if you need to access the built-in namespace directly, you
1231 # should start with "import __builtin__" (note, no 's') which will
1231 # should start with "import __builtin__" (note, no 's') which will
1232 # definitely give you a module. Yeah, it's somewhat confusing:-(.
1232 # definitely give you a module. Yeah, it's somewhat confusing:-(.
1233
1233
1234 # These routines return a properly built module and dict as needed by
1234 # These routines return a properly built module and dict as needed by
1235 # the rest of the code, and can also be used by extension writers to
1235 # the rest of the code, and can also be used by extension writers to
1236 # generate properly initialized namespaces.
1236 # generate properly initialized namespaces.
1237 if (user_ns is not None) or (user_module is not None):
1237 if (user_ns is not None) or (user_module is not None):
1238 self.default_user_namespaces = False
1238 self.default_user_namespaces = False
1239 self.user_module, self.user_ns = self.prepare_user_module(user_module, user_ns)
1239 self.user_module, self.user_ns = self.prepare_user_module(user_module, user_ns)
1240
1240
1241 # A record of hidden variables we have added to the user namespace, so
1241 # A record of hidden variables we have added to the user namespace, so
1242 # we can list later only variables defined in actual interactive use.
1242 # we can list later only variables defined in actual interactive use.
1243 self.user_ns_hidden = {}
1243 self.user_ns_hidden = {}
1244
1244
1245 # Now that FakeModule produces a real module, we've run into a nasty
1245 # Now that FakeModule produces a real module, we've run into a nasty
1246 # problem: after script execution (via %run), the module where the user
1246 # problem: after script execution (via %run), the module where the user
1247 # code ran is deleted. Now that this object is a true module (needed
1247 # code ran is deleted. Now that this object is a true module (needed
1248 # so doctest and other tools work correctly), the Python module
1248 # so doctest and other tools work correctly), the Python module
1249 # teardown mechanism runs over it, and sets to None every variable
1249 # teardown mechanism runs over it, and sets to None every variable
1250 # present in that module. Top-level references to objects from the
1250 # present in that module. Top-level references to objects from the
1251 # script survive, because the user_ns is updated with them. However,
1251 # script survive, because the user_ns is updated with them. However,
1252 # calling functions defined in the script that use other things from
1252 # calling functions defined in the script that use other things from
1253 # the script will fail, because the function's closure had references
1253 # the script will fail, because the function's closure had references
1254 # to the original objects, which are now all None. So we must protect
1254 # to the original objects, which are now all None. So we must protect
1255 # these modules from deletion by keeping a cache.
1255 # these modules from deletion by keeping a cache.
1256 #
1256 #
1257 # To avoid keeping stale modules around (we only need the one from the
1257 # To avoid keeping stale modules around (we only need the one from the
1258 # last run), we use a dict keyed with the full path to the script, so
1258 # last run), we use a dict keyed with the full path to the script, so
1259 # only the last version of the module is held in the cache. Note,
1259 # only the last version of the module is held in the cache. Note,
1260 # however, that we must cache the module *namespace contents* (their
1260 # however, that we must cache the module *namespace contents* (their
1261 # __dict__). Because if we try to cache the actual modules, old ones
1261 # __dict__). Because if we try to cache the actual modules, old ones
1262 # (uncached) could be destroyed while still holding references (such as
1262 # (uncached) could be destroyed while still holding references (such as
1263 # those held by GUI objects that tend to be long-lived)>
1263 # those held by GUI objects that tend to be long-lived)>
1264 #
1264 #
1265 # The %reset command will flush this cache. See the cache_main_mod()
1265 # The %reset command will flush this cache. See the cache_main_mod()
1266 # and clear_main_mod_cache() methods for details on use.
1266 # and clear_main_mod_cache() methods for details on use.
1267
1267
1268 # This is the cache used for 'main' namespaces
1268 # This is the cache used for 'main' namespaces
1269 self._main_mod_cache = {}
1269 self._main_mod_cache = {}
1270
1270
1271 # A table holding all the namespaces IPython deals with, so that
1271 # A table holding all the namespaces IPython deals with, so that
1272 # introspection facilities can search easily.
1272 # introspection facilities can search easily.
1273 self.ns_table = {'user_global':self.user_module.__dict__,
1273 self.ns_table = {'user_global':self.user_module.__dict__,
1274 'user_local':self.user_ns,
1274 'user_local':self.user_ns,
1275 'builtin':builtin_mod.__dict__
1275 'builtin':builtin_mod.__dict__
1276 }
1276 }
1277
1277
1278 @property
1278 @property
1279 def user_global_ns(self):
1279 def user_global_ns(self):
1280 return self.user_module.__dict__
1280 return self.user_module.__dict__
1281
1281
1282 def prepare_user_module(self, user_module=None, user_ns=None):
1282 def prepare_user_module(self, user_module=None, user_ns=None):
1283 """Prepare the module and namespace in which user code will be run.
1283 """Prepare the module and namespace in which user code will be run.
1284
1284
1285 When IPython is started normally, both parameters are None: a new module
1285 When IPython is started normally, both parameters are None: a new module
1286 is created automatically, and its __dict__ used as the namespace.
1286 is created automatically, and its __dict__ used as the namespace.
1287
1287
1288 If only user_module is provided, its __dict__ is used as the namespace.
1288 If only user_module is provided, its __dict__ is used as the namespace.
1289 If only user_ns is provided, a dummy module is created, and user_ns
1289 If only user_ns is provided, a dummy module is created, and user_ns
1290 becomes the global namespace. If both are provided (as they may be
1290 becomes the global namespace. If both are provided (as they may be
1291 when embedding), user_ns is the local namespace, and user_module
1291 when embedding), user_ns is the local namespace, and user_module
1292 provides the global namespace.
1292 provides the global namespace.
1293
1293
1294 Parameters
1294 Parameters
1295 ----------
1295 ----------
1296 user_module : module, optional
1296 user_module : module, optional
1297 The current user module in which IPython is being run. If None,
1297 The current user module in which IPython is being run. If None,
1298 a clean module will be created.
1298 a clean module will be created.
1299 user_ns : dict, optional
1299 user_ns : dict, optional
1300 A namespace in which to run interactive commands.
1300 A namespace in which to run interactive commands.
1301
1301
1302 Returns
1302 Returns
1303 -------
1303 -------
1304 A tuple of user_module and user_ns, each properly initialised.
1304 A tuple of user_module and user_ns, each properly initialised.
1305 """
1305 """
1306 if user_module is None and user_ns is not None:
1306 if user_module is None and user_ns is not None:
1307 user_ns.setdefault("__name__", "__main__")
1307 user_ns.setdefault("__name__", "__main__")
1308 user_module = DummyMod()
1308 user_module = DummyMod()
1309 user_module.__dict__ = user_ns
1309 user_module.__dict__ = user_ns
1310
1310
1311 if user_module is None:
1311 if user_module is None:
1312 user_module = types.ModuleType("__main__",
1312 user_module = types.ModuleType("__main__",
1313 doc="Automatically created module for IPython interactive environment")
1313 doc="Automatically created module for IPython interactive environment")
1314
1314
1315 # We must ensure that __builtin__ (without the final 's') is always
1315 # We must ensure that __builtin__ (without the final 's') is always
1316 # available and pointing to the __builtin__ *module*. For more details:
1316 # available and pointing to the __builtin__ *module*. For more details:
1317 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1317 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1318 user_module.__dict__.setdefault('__builtin__', builtin_mod)
1318 user_module.__dict__.setdefault('__builtin__', builtin_mod)
1319 user_module.__dict__.setdefault('__builtins__', builtin_mod)
1319 user_module.__dict__.setdefault('__builtins__', builtin_mod)
1320
1320
1321 if user_ns is None:
1321 if user_ns is None:
1322 user_ns = user_module.__dict__
1322 user_ns = user_module.__dict__
1323
1323
1324 return user_module, user_ns
1324 return user_module, user_ns
1325
1325
1326 def init_sys_modules(self):
1326 def init_sys_modules(self):
1327 # We need to insert into sys.modules something that looks like a
1327 # We need to insert into sys.modules something that looks like a
1328 # module but which accesses the IPython namespace, for shelve and
1328 # module but which accesses the IPython namespace, for shelve and
1329 # pickle to work interactively. Normally they rely on getting
1329 # pickle to work interactively. Normally they rely on getting
1330 # everything out of __main__, but for embedding purposes each IPython
1330 # everything out of __main__, but for embedding purposes each IPython
1331 # instance has its own private namespace, so we can't go shoving
1331 # instance has its own private namespace, so we can't go shoving
1332 # everything into __main__.
1332 # everything into __main__.
1333
1333
1334 # note, however, that we should only do this for non-embedded
1334 # note, however, that we should only do this for non-embedded
1335 # ipythons, which really mimic the __main__.__dict__ with their own
1335 # ipythons, which really mimic the __main__.__dict__ with their own
1336 # namespace. Embedded instances, on the other hand, should not do
1336 # namespace. Embedded instances, on the other hand, should not do
1337 # this because they need to manage the user local/global namespaces
1337 # this because they need to manage the user local/global namespaces
1338 # only, but they live within a 'normal' __main__ (meaning, they
1338 # only, but they live within a 'normal' __main__ (meaning, they
1339 # shouldn't overtake the execution environment of the script they're
1339 # shouldn't overtake the execution environment of the script they're
1340 # embedded in).
1340 # embedded in).
1341
1341
1342 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
1342 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
1343 main_name = self.user_module.__name__
1343 main_name = self.user_module.__name__
1344 sys.modules[main_name] = self.user_module
1344 sys.modules[main_name] = self.user_module
1345
1345
1346 def init_user_ns(self):
1346 def init_user_ns(self):
1347 """Initialize all user-visible namespaces to their minimum defaults.
1347 """Initialize all user-visible namespaces to their minimum defaults.
1348
1348
1349 Certain history lists are also initialized here, as they effectively
1349 Certain history lists are also initialized here, as they effectively
1350 act as user namespaces.
1350 act as user namespaces.
1351
1351
1352 Notes
1352 Notes
1353 -----
1353 -----
1354 All data structures here are only filled in, they are NOT reset by this
1354 All data structures here are only filled in, they are NOT reset by this
1355 method. If they were not empty before, data will simply be added to
1355 method. If they were not empty before, data will simply be added to
1356 them.
1356 them.
1357 """
1357 """
1358 # This function works in two parts: first we put a few things in
1358 # This function works in two parts: first we put a few things in
1359 # user_ns, and we sync that contents into user_ns_hidden so that these
1359 # user_ns, and we sync that contents into user_ns_hidden so that these
1360 # initial variables aren't shown by %who. After the sync, we add the
1360 # initial variables aren't shown by %who. After the sync, we add the
1361 # rest of what we *do* want the user to see with %who even on a new
1361 # rest of what we *do* want the user to see with %who even on a new
1362 # session (probably nothing, so they really only see their own stuff)
1362 # session (probably nothing, so they really only see their own stuff)
1363
1363
1364 # The user dict must *always* have a __builtin__ reference to the
1364 # The user dict must *always* have a __builtin__ reference to the
1365 # Python standard __builtin__ namespace, which must be imported.
1365 # Python standard __builtin__ namespace, which must be imported.
1366 # This is so that certain operations in prompt evaluation can be
1366 # This is so that certain operations in prompt evaluation can be
1367 # reliably executed with builtins. Note that we can NOT use
1367 # reliably executed with builtins. Note that we can NOT use
1368 # __builtins__ (note the 's'), because that can either be a dict or a
1368 # __builtins__ (note the 's'), because that can either be a dict or a
1369 # module, and can even mutate at runtime, depending on the context
1369 # module, and can even mutate at runtime, depending on the context
1370 # (Python makes no guarantees on it). In contrast, __builtin__ is
1370 # (Python makes no guarantees on it). In contrast, __builtin__ is
1371 # always a module object, though it must be explicitly imported.
1371 # always a module object, though it must be explicitly imported.
1372
1372
1373 # For more details:
1373 # For more details:
1374 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1374 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1375 ns = {}
1375 ns = {}
1376
1376
1377 # make global variables for user access to the histories
1377 # make global variables for user access to the histories
1378 ns['_ih'] = self.history_manager.input_hist_parsed
1378 ns['_ih'] = self.history_manager.input_hist_parsed
1379 ns['_oh'] = self.history_manager.output_hist
1379 ns['_oh'] = self.history_manager.output_hist
1380 ns['_dh'] = self.history_manager.dir_hist
1380 ns['_dh'] = self.history_manager.dir_hist
1381
1381
1382 # user aliases to input and output histories. These shouldn't show up
1382 # user aliases to input and output histories. These shouldn't show up
1383 # in %who, as they can have very large reprs.
1383 # in %who, as they can have very large reprs.
1384 ns['In'] = self.history_manager.input_hist_parsed
1384 ns['In'] = self.history_manager.input_hist_parsed
1385 ns['Out'] = self.history_manager.output_hist
1385 ns['Out'] = self.history_manager.output_hist
1386
1386
1387 # Store myself as the public api!!!
1387 # Store myself as the public api!!!
1388 ns['get_ipython'] = self.get_ipython
1388 ns['get_ipython'] = self.get_ipython
1389
1389
1390 ns['exit'] = self.exiter
1390 ns['exit'] = self.exiter
1391 ns['quit'] = self.exiter
1391 ns['quit'] = self.exiter
1392
1392
1393 # Sync what we've added so far to user_ns_hidden so these aren't seen
1393 # Sync what we've added so far to user_ns_hidden so these aren't seen
1394 # by %who
1394 # by %who
1395 self.user_ns_hidden.update(ns)
1395 self.user_ns_hidden.update(ns)
1396
1396
1397 # Anything put into ns now would show up in %who. Think twice before
1397 # Anything put into ns now would show up in %who. Think twice before
1398 # putting anything here, as we really want %who to show the user their
1398 # putting anything here, as we really want %who to show the user their
1399 # stuff, not our variables.
1399 # stuff, not our variables.
1400
1400
1401 # Finally, update the real user's namespace
1401 # Finally, update the real user's namespace
1402 self.user_ns.update(ns)
1402 self.user_ns.update(ns)
1403
1403
1404 @property
1404 @property
1405 def all_ns_refs(self):
1405 def all_ns_refs(self):
1406 """Get a list of references to all the namespace dictionaries in which
1406 """Get a list of references to all the namespace dictionaries in which
1407 IPython might store a user-created object.
1407 IPython might store a user-created object.
1408
1408
1409 Note that this does not include the displayhook, which also caches
1409 Note that this does not include the displayhook, which also caches
1410 objects from the output."""
1410 objects from the output."""
1411 return [self.user_ns, self.user_global_ns, self.user_ns_hidden] + \
1411 return [self.user_ns, self.user_global_ns, self.user_ns_hidden] + \
1412 [m.__dict__ for m in self._main_mod_cache.values()]
1412 [m.__dict__ for m in self._main_mod_cache.values()]
1413
1413
1414 def reset(self, new_session=True, aggressive=False):
1414 def reset(self, new_session=True, aggressive=False):
1415 """Clear all internal namespaces, and attempt to release references to
1415 """Clear all internal namespaces, and attempt to release references to
1416 user objects.
1416 user objects.
1417
1417
1418 If new_session is True, a new history session will be opened.
1418 If new_session is True, a new history session will be opened.
1419 """
1419 """
1420 # Clear histories
1420 # Clear histories
1421 self.history_manager.reset(new_session)
1421 self.history_manager.reset(new_session)
1422 # Reset counter used to index all histories
1422 # Reset counter used to index all histories
1423 if new_session:
1423 if new_session:
1424 self.execution_count = 1
1424 self.execution_count = 1
1425
1425
1426 # Reset last execution result
1426 # Reset last execution result
1427 self.last_execution_succeeded = True
1427 self.last_execution_succeeded = True
1428 self.last_execution_result = None
1428 self.last_execution_result = None
1429
1429
1430 # Flush cached output items
1430 # Flush cached output items
1431 if self.displayhook.do_full_cache:
1431 if self.displayhook.do_full_cache:
1432 self.displayhook.flush()
1432 self.displayhook.flush()
1433
1433
1434 # The main execution namespaces must be cleared very carefully,
1434 # The main execution namespaces must be cleared very carefully,
1435 # skipping the deletion of the builtin-related keys, because doing so
1435 # skipping the deletion of the builtin-related keys, because doing so
1436 # would cause errors in many object's __del__ methods.
1436 # would cause errors in many object's __del__ methods.
1437 if self.user_ns is not self.user_global_ns:
1437 if self.user_ns is not self.user_global_ns:
1438 self.user_ns.clear()
1438 self.user_ns.clear()
1439 ns = self.user_global_ns
1439 ns = self.user_global_ns
1440 drop_keys = set(ns.keys())
1440 drop_keys = set(ns.keys())
1441 drop_keys.discard('__builtin__')
1441 drop_keys.discard('__builtin__')
1442 drop_keys.discard('__builtins__')
1442 drop_keys.discard('__builtins__')
1443 drop_keys.discard('__name__')
1443 drop_keys.discard('__name__')
1444 for k in drop_keys:
1444 for k in drop_keys:
1445 del ns[k]
1445 del ns[k]
1446
1446
1447 self.user_ns_hidden.clear()
1447 self.user_ns_hidden.clear()
1448
1448
1449 # Restore the user namespaces to minimal usability
1449 # Restore the user namespaces to minimal usability
1450 self.init_user_ns()
1450 self.init_user_ns()
1451 if aggressive and not hasattr(self, "_sys_modules_keys"):
1451 if aggressive and not hasattr(self, "_sys_modules_keys"):
1452 print("Cannot restore sys.module, no snapshot")
1452 print("Cannot restore sys.module, no snapshot")
1453 elif aggressive:
1453 elif aggressive:
1454 print("culling sys module...")
1454 print("culling sys module...")
1455 current_keys = set(sys.modules.keys())
1455 current_keys = set(sys.modules.keys())
1456 for k in current_keys - self._sys_modules_keys:
1456 for k in current_keys - self._sys_modules_keys:
1457 if k.startswith("multiprocessing"):
1457 if k.startswith("multiprocessing"):
1458 continue
1458 continue
1459 del sys.modules[k]
1459 del sys.modules[k]
1460
1460
1461 # Restore the default and user aliases
1461 # Restore the default and user aliases
1462 self.alias_manager.clear_aliases()
1462 self.alias_manager.clear_aliases()
1463 self.alias_manager.init_aliases()
1463 self.alias_manager.init_aliases()
1464
1464
1465 # Now define aliases that only make sense on the terminal, because they
1465 # Now define aliases that only make sense on the terminal, because they
1466 # need direct access to the console in a way that we can't emulate in
1466 # need direct access to the console in a way that we can't emulate in
1467 # GUI or web frontend
1467 # GUI or web frontend
1468 if os.name == 'posix':
1468 if os.name == 'posix':
1469 for cmd in ('clear', 'more', 'less', 'man'):
1469 for cmd in ('clear', 'more', 'less', 'man'):
1470 if cmd not in self.magics_manager.magics['line']:
1470 if cmd not in self.magics_manager.magics['line']:
1471 self.alias_manager.soft_define_alias(cmd, cmd)
1471 self.alias_manager.soft_define_alias(cmd, cmd)
1472
1472
1473 # Flush the private list of module references kept for script
1473 # Flush the private list of module references kept for script
1474 # execution protection
1474 # execution protection
1475 self.clear_main_mod_cache()
1475 self.clear_main_mod_cache()
1476
1476
1477 def del_var(self, varname, by_name=False):
1477 def del_var(self, varname, by_name=False):
1478 """Delete a variable from the various namespaces, so that, as
1478 """Delete a variable from the various namespaces, so that, as
1479 far as possible, we're not keeping any hidden references to it.
1479 far as possible, we're not keeping any hidden references to it.
1480
1480
1481 Parameters
1481 Parameters
1482 ----------
1482 ----------
1483 varname : str
1483 varname : str
1484 The name of the variable to delete.
1484 The name of the variable to delete.
1485 by_name : bool
1485 by_name : bool
1486 If True, delete variables with the given name in each
1486 If True, delete variables with the given name in each
1487 namespace. If False (default), find the variable in the user
1487 namespace. If False (default), find the variable in the user
1488 namespace, and delete references to it.
1488 namespace, and delete references to it.
1489 """
1489 """
1490 if varname in ('__builtin__', '__builtins__'):
1490 if varname in ('__builtin__', '__builtins__'):
1491 raise ValueError("Refusing to delete %s" % varname)
1491 raise ValueError("Refusing to delete %s" % varname)
1492
1492
1493 ns_refs = self.all_ns_refs
1493 ns_refs = self.all_ns_refs
1494
1494
1495 if by_name: # Delete by name
1495 if by_name: # Delete by name
1496 for ns in ns_refs:
1496 for ns in ns_refs:
1497 try:
1497 try:
1498 del ns[varname]
1498 del ns[varname]
1499 except KeyError:
1499 except KeyError:
1500 pass
1500 pass
1501 else: # Delete by object
1501 else: # Delete by object
1502 try:
1502 try:
1503 obj = self.user_ns[varname]
1503 obj = self.user_ns[varname]
1504 except KeyError:
1504 except KeyError:
1505 raise NameError("name '%s' is not defined" % varname)
1505 raise NameError("name '%s' is not defined" % varname)
1506 # Also check in output history
1506 # Also check in output history
1507 ns_refs.append(self.history_manager.output_hist)
1507 ns_refs.append(self.history_manager.output_hist)
1508 for ns in ns_refs:
1508 for ns in ns_refs:
1509 to_delete = [n for n, o in ns.items() if o is obj]
1509 to_delete = [n for n, o in ns.items() if o is obj]
1510 for name in to_delete:
1510 for name in to_delete:
1511 del ns[name]
1511 del ns[name]
1512
1512
1513 # Ensure it is removed from the last execution result
1513 # Ensure it is removed from the last execution result
1514 if self.last_execution_result.result is obj:
1514 if self.last_execution_result.result is obj:
1515 self.last_execution_result = None
1515 self.last_execution_result = None
1516
1516
1517 # displayhook keeps extra references, but not in a dictionary
1517 # displayhook keeps extra references, but not in a dictionary
1518 for name in ('_', '__', '___'):
1518 for name in ('_', '__', '___'):
1519 if getattr(self.displayhook, name) is obj:
1519 if getattr(self.displayhook, name) is obj:
1520 setattr(self.displayhook, name, None)
1520 setattr(self.displayhook, name, None)
1521
1521
1522 def reset_selective(self, regex=None):
1522 def reset_selective(self, regex=None):
1523 """Clear selective variables from internal namespaces based on a
1523 """Clear selective variables from internal namespaces based on a
1524 specified regular expression.
1524 specified regular expression.
1525
1525
1526 Parameters
1526 Parameters
1527 ----------
1527 ----------
1528 regex : string or compiled pattern, optional
1528 regex : string or compiled pattern, optional
1529 A regular expression pattern that will be used in searching
1529 A regular expression pattern that will be used in searching
1530 variable names in the users namespaces.
1530 variable names in the users namespaces.
1531 """
1531 """
1532 if regex is not None:
1532 if regex is not None:
1533 try:
1533 try:
1534 m = re.compile(regex)
1534 m = re.compile(regex)
1535 except TypeError:
1535 except TypeError:
1536 raise TypeError('regex must be a string or compiled pattern')
1536 raise TypeError('regex must be a string or compiled pattern')
1537 # Search for keys in each namespace that match the given regex
1537 # Search for keys in each namespace that match the given regex
1538 # If a match is found, delete the key/value pair.
1538 # If a match is found, delete the key/value pair.
1539 for ns in self.all_ns_refs:
1539 for ns in self.all_ns_refs:
1540 for var in ns:
1540 for var in ns:
1541 if m.search(var):
1541 if m.search(var):
1542 del ns[var]
1542 del ns[var]
1543
1543
1544 def push(self, variables, interactive=True):
1544 def push(self, variables, interactive=True):
1545 """Inject a group of variables into the IPython user namespace.
1545 """Inject a group of variables into the IPython user namespace.
1546
1546
1547 Parameters
1547 Parameters
1548 ----------
1548 ----------
1549 variables : dict, str or list/tuple of str
1549 variables : dict, str or list/tuple of str
1550 The variables to inject into the user's namespace. If a dict, a
1550 The variables to inject into the user's namespace. If a dict, a
1551 simple update is done. If a str, the string is assumed to have
1551 simple update is done. If a str, the string is assumed to have
1552 variable names separated by spaces. A list/tuple of str can also
1552 variable names separated by spaces. A list/tuple of str can also
1553 be used to give the variable names. If just the variable names are
1553 be used to give the variable names. If just the variable names are
1554 give (list/tuple/str) then the variable values looked up in the
1554 give (list/tuple/str) then the variable values looked up in the
1555 callers frame.
1555 callers frame.
1556 interactive : bool
1556 interactive : bool
1557 If True (default), the variables will be listed with the ``who``
1557 If True (default), the variables will be listed with the ``who``
1558 magic.
1558 magic.
1559 """
1559 """
1560 vdict = None
1560 vdict = None
1561
1561
1562 # We need a dict of name/value pairs to do namespace updates.
1562 # We need a dict of name/value pairs to do namespace updates.
1563 if isinstance(variables, dict):
1563 if isinstance(variables, dict):
1564 vdict = variables
1564 vdict = variables
1565 elif isinstance(variables, (str, list, tuple)):
1565 elif isinstance(variables, (str, list, tuple)):
1566 if isinstance(variables, str):
1566 if isinstance(variables, str):
1567 vlist = variables.split()
1567 vlist = variables.split()
1568 else:
1568 else:
1569 vlist = variables
1569 vlist = variables
1570 vdict = {}
1570 vdict = {}
1571 cf = sys._getframe(1)
1571 cf = sys._getframe(1)
1572 for name in vlist:
1572 for name in vlist:
1573 try:
1573 try:
1574 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1574 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1575 except:
1575 except:
1576 print('Could not get variable %s from %s' %
1576 print('Could not get variable %s from %s' %
1577 (name,cf.f_code.co_name))
1577 (name,cf.f_code.co_name))
1578 else:
1578 else:
1579 raise ValueError('variables must be a dict/str/list/tuple')
1579 raise ValueError('variables must be a dict/str/list/tuple')
1580
1580
1581 # Propagate variables to user namespace
1581 # Propagate variables to user namespace
1582 self.user_ns.update(vdict)
1582 self.user_ns.update(vdict)
1583
1583
1584 # And configure interactive visibility
1584 # And configure interactive visibility
1585 user_ns_hidden = self.user_ns_hidden
1585 user_ns_hidden = self.user_ns_hidden
1586 if interactive:
1586 if interactive:
1587 for name in vdict:
1587 for name in vdict:
1588 user_ns_hidden.pop(name, None)
1588 user_ns_hidden.pop(name, None)
1589 else:
1589 else:
1590 user_ns_hidden.update(vdict)
1590 user_ns_hidden.update(vdict)
1591
1591
1592 def drop_by_id(self, variables):
1592 def drop_by_id(self, variables):
1593 """Remove a dict of variables from the user namespace, if they are the
1593 """Remove a dict of variables from the user namespace, if they are the
1594 same as the values in the dictionary.
1594 same as the values in the dictionary.
1595
1595
1596 This is intended for use by extensions: variables that they've added can
1596 This is intended for use by extensions: variables that they've added can
1597 be taken back out if they are unloaded, without removing any that the
1597 be taken back out if they are unloaded, without removing any that the
1598 user has overwritten.
1598 user has overwritten.
1599
1599
1600 Parameters
1600 Parameters
1601 ----------
1601 ----------
1602 variables : dict
1602 variables : dict
1603 A dictionary mapping object names (as strings) to the objects.
1603 A dictionary mapping object names (as strings) to the objects.
1604 """
1604 """
1605 for name, obj in variables.items():
1605 for name, obj in variables.items():
1606 if name in self.user_ns and self.user_ns[name] is obj:
1606 if name in self.user_ns and self.user_ns[name] is obj:
1607 del self.user_ns[name]
1607 del self.user_ns[name]
1608 self.user_ns_hidden.pop(name, None)
1608 self.user_ns_hidden.pop(name, None)
1609
1609
1610 #-------------------------------------------------------------------------
1610 #-------------------------------------------------------------------------
1611 # Things related to object introspection
1611 # Things related to object introspection
1612 #-------------------------------------------------------------------------
1612 #-------------------------------------------------------------------------
1613
1613
1614 def _ofind(self, oname, namespaces=None):
1614 def _ofind(self, oname, namespaces=None):
1615 """Find an object in the available namespaces.
1615 """Find an object in the available namespaces.
1616
1616
1617 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
1617 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
1618
1618
1619 Has special code to detect magic functions.
1619 Has special code to detect magic functions.
1620 """
1620 """
1621 oname = oname.strip()
1621 oname = oname.strip()
1622 if not oname.startswith(ESC_MAGIC) and \
1622 if not oname.startswith(ESC_MAGIC) and \
1623 not oname.startswith(ESC_MAGIC2) and \
1623 not oname.startswith(ESC_MAGIC2) and \
1624 not all(a.isidentifier() for a in oname.split(".")):
1624 not all(a.isidentifier() for a in oname.split(".")):
1625 return {'found': False}
1625 return {'found': False}
1626
1626
1627 if namespaces is None:
1627 if namespaces is None:
1628 # Namespaces to search in:
1628 # Namespaces to search in:
1629 # Put them in a list. The order is important so that we
1629 # Put them in a list. The order is important so that we
1630 # find things in the same order that Python finds them.
1630 # find things in the same order that Python finds them.
1631 namespaces = [ ('Interactive', self.user_ns),
1631 namespaces = [ ('Interactive', self.user_ns),
1632 ('Interactive (global)', self.user_global_ns),
1632 ('Interactive (global)', self.user_global_ns),
1633 ('Python builtin', builtin_mod.__dict__),
1633 ('Python builtin', builtin_mod.__dict__),
1634 ]
1634 ]
1635
1635
1636 ismagic = False
1636 ismagic = False
1637 isalias = False
1637 isalias = False
1638 found = False
1638 found = False
1639 ospace = None
1639 ospace = None
1640 parent = None
1640 parent = None
1641 obj = None
1641 obj = None
1642
1642
1643
1643
1644 # Look for the given name by splitting it in parts. If the head is
1644 # Look for the given name by splitting it in parts. If the head is
1645 # found, then we look for all the remaining parts as members, and only
1645 # found, then we look for all the remaining parts as members, and only
1646 # declare success if we can find them all.
1646 # declare success if we can find them all.
1647 oname_parts = oname.split('.')
1647 oname_parts = oname.split('.')
1648 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
1648 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
1649 for nsname,ns in namespaces:
1649 for nsname,ns in namespaces:
1650 try:
1650 try:
1651 obj = ns[oname_head]
1651 obj = ns[oname_head]
1652 except KeyError:
1652 except KeyError:
1653 continue
1653 continue
1654 else:
1654 else:
1655 for idx, part in enumerate(oname_rest):
1655 for idx, part in enumerate(oname_rest):
1656 try:
1656 try:
1657 parent = obj
1657 parent = obj
1658 # The last part is looked up in a special way to avoid
1658 # The last part is looked up in a special way to avoid
1659 # descriptor invocation as it may raise or have side
1659 # descriptor invocation as it may raise or have side
1660 # effects.
1660 # effects.
1661 if idx == len(oname_rest) - 1:
1661 if idx == len(oname_rest) - 1:
1662 obj = self._getattr_property(obj, part)
1662 obj = self._getattr_property(obj, part)
1663 else:
1663 else:
1664 obj = getattr(obj, part)
1664 obj = getattr(obj, part)
1665 except:
1665 except:
1666 # Blanket except b/c some badly implemented objects
1666 # Blanket except b/c some badly implemented objects
1667 # allow __getattr__ to raise exceptions other than
1667 # allow __getattr__ to raise exceptions other than
1668 # AttributeError, which then crashes IPython.
1668 # AttributeError, which then crashes IPython.
1669 break
1669 break
1670 else:
1670 else:
1671 # If we finish the for loop (no break), we got all members
1671 # If we finish the for loop (no break), we got all members
1672 found = True
1672 found = True
1673 ospace = nsname
1673 ospace = nsname
1674 break # namespace loop
1674 break # namespace loop
1675
1675
1676 # Try to see if it's magic
1676 # Try to see if it's magic
1677 if not found:
1677 if not found:
1678 obj = None
1678 obj = None
1679 if oname.startswith(ESC_MAGIC2):
1679 if oname.startswith(ESC_MAGIC2):
1680 oname = oname.lstrip(ESC_MAGIC2)
1680 oname = oname.lstrip(ESC_MAGIC2)
1681 obj = self.find_cell_magic(oname)
1681 obj = self.find_cell_magic(oname)
1682 elif oname.startswith(ESC_MAGIC):
1682 elif oname.startswith(ESC_MAGIC):
1683 oname = oname.lstrip(ESC_MAGIC)
1683 oname = oname.lstrip(ESC_MAGIC)
1684 obj = self.find_line_magic(oname)
1684 obj = self.find_line_magic(oname)
1685 else:
1685 else:
1686 # search without prefix, so run? will find %run?
1686 # search without prefix, so run? will find %run?
1687 obj = self.find_line_magic(oname)
1687 obj = self.find_line_magic(oname)
1688 if obj is None:
1688 if obj is None:
1689 obj = self.find_cell_magic(oname)
1689 obj = self.find_cell_magic(oname)
1690 if obj is not None:
1690 if obj is not None:
1691 found = True
1691 found = True
1692 ospace = 'IPython internal'
1692 ospace = 'IPython internal'
1693 ismagic = True
1693 ismagic = True
1694 isalias = isinstance(obj, Alias)
1694 isalias = isinstance(obj, Alias)
1695
1695
1696 # Last try: special-case some literals like '', [], {}, etc:
1696 # Last try: special-case some literals like '', [], {}, etc:
1697 if not found and oname_head in ["''",'""','[]','{}','()']:
1697 if not found and oname_head in ["''",'""','[]','{}','()']:
1698 obj = eval(oname_head)
1698 obj = eval(oname_head)
1699 found = True
1699 found = True
1700 ospace = 'Interactive'
1700 ospace = 'Interactive'
1701
1701
1702 return {
1702 return {
1703 'obj':obj,
1703 'obj':obj,
1704 'found':found,
1704 'found':found,
1705 'parent':parent,
1705 'parent':parent,
1706 'ismagic':ismagic,
1706 'ismagic':ismagic,
1707 'isalias':isalias,
1707 'isalias':isalias,
1708 'namespace':ospace
1708 'namespace':ospace
1709 }
1709 }
1710
1710
1711 @staticmethod
1711 @staticmethod
1712 def _getattr_property(obj, attrname):
1712 def _getattr_property(obj, attrname):
1713 """Property-aware getattr to use in object finding.
1713 """Property-aware getattr to use in object finding.
1714
1714
1715 If attrname represents a property, return it unevaluated (in case it has
1715 If attrname represents a property, return it unevaluated (in case it has
1716 side effects or raises an error.
1716 side effects or raises an error.
1717
1717
1718 """
1718 """
1719 if not isinstance(obj, type):
1719 if not isinstance(obj, type):
1720 try:
1720 try:
1721 # `getattr(type(obj), attrname)` is not guaranteed to return
1721 # `getattr(type(obj), attrname)` is not guaranteed to return
1722 # `obj`, but does so for property:
1722 # `obj`, but does so for property:
1723 #
1723 #
1724 # property.__get__(self, None, cls) -> self
1724 # property.__get__(self, None, cls) -> self
1725 #
1725 #
1726 # The universal alternative is to traverse the mro manually
1726 # The universal alternative is to traverse the mro manually
1727 # searching for attrname in class dicts.
1727 # searching for attrname in class dicts.
1728 attr = getattr(type(obj), attrname)
1728 attr = getattr(type(obj), attrname)
1729 except AttributeError:
1729 except AttributeError:
1730 pass
1730 pass
1731 else:
1731 else:
1732 # This relies on the fact that data descriptors (with both
1732 # This relies on the fact that data descriptors (with both
1733 # __get__ & __set__ magic methods) take precedence over
1733 # __get__ & __set__ magic methods) take precedence over
1734 # instance-level attributes:
1734 # instance-level attributes:
1735 #
1735 #
1736 # class A(object):
1736 # class A(object):
1737 # @property
1737 # @property
1738 # def foobar(self): return 123
1738 # def foobar(self): return 123
1739 # a = A()
1739 # a = A()
1740 # a.__dict__['foobar'] = 345
1740 # a.__dict__['foobar'] = 345
1741 # a.foobar # == 123
1741 # a.foobar # == 123
1742 #
1742 #
1743 # So, a property may be returned right away.
1743 # So, a property may be returned right away.
1744 if isinstance(attr, property):
1744 if isinstance(attr, property):
1745 return attr
1745 return attr
1746
1746
1747 # Nothing helped, fall back.
1747 # Nothing helped, fall back.
1748 return getattr(obj, attrname)
1748 return getattr(obj, attrname)
1749
1749
1750 def _object_find(self, oname, namespaces=None):
1750 def _object_find(self, oname, namespaces=None):
1751 """Find an object and return a struct with info about it."""
1751 """Find an object and return a struct with info about it."""
1752 return Struct(self._ofind(oname, namespaces))
1752 return Struct(self._ofind(oname, namespaces))
1753
1753
1754 def _inspect(self, meth, oname, namespaces=None, **kw):
1754 def _inspect(self, meth, oname, namespaces=None, **kw):
1755 """Generic interface to the inspector system.
1755 """Generic interface to the inspector system.
1756
1756
1757 This function is meant to be called by pdef, pdoc & friends.
1757 This function is meant to be called by pdef, pdoc & friends.
1758 """
1758 """
1759 info = self._object_find(oname, namespaces)
1759 info = self._object_find(oname, namespaces)
1760 docformat = sphinxify if self.sphinxify_docstring else None
1760 docformat = sphinxify if self.sphinxify_docstring else None
1761 if info.found:
1761 if info.found:
1762 pmethod = getattr(self.inspector, meth)
1762 pmethod = getattr(self.inspector, meth)
1763 # TODO: only apply format_screen to the plain/text repr of the mime
1763 # TODO: only apply format_screen to the plain/text repr of the mime
1764 # bundle.
1764 # bundle.
1765 formatter = format_screen if info.ismagic else docformat
1765 formatter = format_screen if info.ismagic else docformat
1766 if meth == 'pdoc':
1766 if meth == 'pdoc':
1767 pmethod(info.obj, oname, formatter)
1767 pmethod(info.obj, oname, formatter)
1768 elif meth == 'pinfo':
1768 elif meth == 'pinfo':
1769 pmethod(
1769 pmethod(
1770 info.obj,
1770 info.obj,
1771 oname,
1771 oname,
1772 formatter,
1772 formatter,
1773 info,
1773 info,
1774 enable_html_pager=self.enable_html_pager,
1774 enable_html_pager=self.enable_html_pager,
1775 **kw
1775 **kw
1776 )
1776 )
1777 else:
1777 else:
1778 pmethod(info.obj, oname)
1778 pmethod(info.obj, oname)
1779 else:
1779 else:
1780 print('Object `%s` not found.' % oname)
1780 print('Object `%s` not found.' % oname)
1781 return 'not found' # so callers can take other action
1781 return 'not found' # so callers can take other action
1782
1782
1783 def object_inspect(self, oname, detail_level=0):
1783 def object_inspect(self, oname, detail_level=0):
1784 """Get object info about oname"""
1784 """Get object info about oname"""
1785 with self.builtin_trap:
1785 with self.builtin_trap:
1786 info = self._object_find(oname)
1786 info = self._object_find(oname)
1787 if info.found:
1787 if info.found:
1788 return self.inspector.info(info.obj, oname, info=info,
1788 return self.inspector.info(info.obj, oname, info=info,
1789 detail_level=detail_level
1789 detail_level=detail_level
1790 )
1790 )
1791 else:
1791 else:
1792 return oinspect.object_info(name=oname, found=False)
1792 return oinspect.object_info(name=oname, found=False)
1793
1793
1794 def object_inspect_text(self, oname, detail_level=0):
1794 def object_inspect_text(self, oname, detail_level=0):
1795 """Get object info as formatted text"""
1795 """Get object info as formatted text"""
1796 return self.object_inspect_mime(oname, detail_level)['text/plain']
1796 return self.object_inspect_mime(oname, detail_level)['text/plain']
1797
1797
1798 def object_inspect_mime(self, oname, detail_level=0):
1798 def object_inspect_mime(self, oname, detail_level=0):
1799 """Get object info as a mimebundle of formatted representations.
1799 """Get object info as a mimebundle of formatted representations.
1800
1800
1801 A mimebundle is a dictionary, keyed by mime-type.
1801 A mimebundle is a dictionary, keyed by mime-type.
1802 It must always have the key `'text/plain'`.
1802 It must always have the key `'text/plain'`.
1803 """
1803 """
1804 with self.builtin_trap:
1804 with self.builtin_trap:
1805 info = self._object_find(oname)
1805 info = self._object_find(oname)
1806 if info.found:
1806 if info.found:
1807 return self.inspector._get_info(info.obj, oname, info=info,
1807 return self.inspector._get_info(info.obj, oname, info=info,
1808 detail_level=detail_level
1808 detail_level=detail_level
1809 )
1809 )
1810 else:
1810 else:
1811 raise KeyError(oname)
1811 raise KeyError(oname)
1812
1812
1813 #-------------------------------------------------------------------------
1813 #-------------------------------------------------------------------------
1814 # Things related to history management
1814 # Things related to history management
1815 #-------------------------------------------------------------------------
1815 #-------------------------------------------------------------------------
1816
1816
1817 def init_history(self):
1817 def init_history(self):
1818 """Sets up the command history, and starts regular autosaves."""
1818 """Sets up the command history, and starts regular autosaves."""
1819 self.history_manager = HistoryManager(shell=self, parent=self)
1819 self.history_manager = HistoryManager(shell=self, parent=self)
1820 self.configurables.append(self.history_manager)
1820 self.configurables.append(self.history_manager)
1821
1821
1822 #-------------------------------------------------------------------------
1822 #-------------------------------------------------------------------------
1823 # Things related to exception handling and tracebacks (not debugging)
1823 # Things related to exception handling and tracebacks (not debugging)
1824 #-------------------------------------------------------------------------
1824 #-------------------------------------------------------------------------
1825
1825
1826 debugger_cls = Pdb
1826 debugger_cls = Pdb
1827
1827
1828 def init_traceback_handlers(self, custom_exceptions):
1828 def init_traceback_handlers(self, custom_exceptions):
1829 # Syntax error handler.
1829 # Syntax error handler.
1830 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor', parent=self)
1830 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor', parent=self)
1831
1831
1832 # The interactive one is initialized with an offset, meaning we always
1832 # The interactive one is initialized with an offset, meaning we always
1833 # want to remove the topmost item in the traceback, which is our own
1833 # want to remove the topmost item in the traceback, which is our own
1834 # internal code. Valid modes: ['Plain','Context','Verbose','Minimal']
1834 # internal code. Valid modes: ['Plain','Context','Verbose','Minimal']
1835 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1835 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1836 color_scheme='NoColor',
1836 color_scheme='NoColor',
1837 tb_offset = 1,
1837 tb_offset = 1,
1838 check_cache=check_linecache_ipython,
1838 check_cache=check_linecache_ipython,
1839 debugger_cls=self.debugger_cls, parent=self)
1839 debugger_cls=self.debugger_cls, parent=self)
1840
1840
1841 # The instance will store a pointer to the system-wide exception hook,
1841 # The instance will store a pointer to the system-wide exception hook,
1842 # so that runtime code (such as magics) can access it. This is because
1842 # so that runtime code (such as magics) can access it. This is because
1843 # during the read-eval loop, it may get temporarily overwritten.
1843 # during the read-eval loop, it may get temporarily overwritten.
1844 self.sys_excepthook = sys.excepthook
1844 self.sys_excepthook = sys.excepthook
1845
1845
1846 # and add any custom exception handlers the user may have specified
1846 # and add any custom exception handlers the user may have specified
1847 self.set_custom_exc(*custom_exceptions)
1847 self.set_custom_exc(*custom_exceptions)
1848
1848
1849 # Set the exception mode
1849 # Set the exception mode
1850 self.InteractiveTB.set_mode(mode=self.xmode)
1850 self.InteractiveTB.set_mode(mode=self.xmode)
1851
1851
1852 def set_custom_exc(self, exc_tuple, handler):
1852 def set_custom_exc(self, exc_tuple, handler):
1853 """set_custom_exc(exc_tuple, handler)
1853 """set_custom_exc(exc_tuple, handler)
1854
1854
1855 Set a custom exception handler, which will be called if any of the
1855 Set a custom exception handler, which will be called if any of the
1856 exceptions in exc_tuple occur in the mainloop (specifically, in the
1856 exceptions in exc_tuple occur in the mainloop (specifically, in the
1857 run_code() method).
1857 run_code() method).
1858
1858
1859 Parameters
1859 Parameters
1860 ----------
1860 ----------
1861
1861
1862 exc_tuple : tuple of exception classes
1862 exc_tuple : tuple of exception classes
1863 A *tuple* of exception classes, for which to call the defined
1863 A *tuple* of exception classes, for which to call the defined
1864 handler. It is very important that you use a tuple, and NOT A
1864 handler. It is very important that you use a tuple, and NOT A
1865 LIST here, because of the way Python's except statement works. If
1865 LIST here, because of the way Python's except statement works. If
1866 you only want to trap a single exception, use a singleton tuple::
1866 you only want to trap a single exception, use a singleton tuple::
1867
1867
1868 exc_tuple == (MyCustomException,)
1868 exc_tuple == (MyCustomException,)
1869
1869
1870 handler : callable
1870 handler : callable
1871 handler must have the following signature::
1871 handler must have the following signature::
1872
1872
1873 def my_handler(self, etype, value, tb, tb_offset=None):
1873 def my_handler(self, etype, value, tb, tb_offset=None):
1874 ...
1874 ...
1875 return structured_traceback
1875 return structured_traceback
1876
1876
1877 Your handler must return a structured traceback (a list of strings),
1877 Your handler must return a structured traceback (a list of strings),
1878 or None.
1878 or None.
1879
1879
1880 This will be made into an instance method (via types.MethodType)
1880 This will be made into an instance method (via types.MethodType)
1881 of IPython itself, and it will be called if any of the exceptions
1881 of IPython itself, and it will be called if any of the exceptions
1882 listed in the exc_tuple are caught. If the handler is None, an
1882 listed in the exc_tuple are caught. If the handler is None, an
1883 internal basic one is used, which just prints basic info.
1883 internal basic one is used, which just prints basic info.
1884
1884
1885 To protect IPython from crashes, if your handler ever raises an
1885 To protect IPython from crashes, if your handler ever raises an
1886 exception or returns an invalid result, it will be immediately
1886 exception or returns an invalid result, it will be immediately
1887 disabled.
1887 disabled.
1888
1888
1889 WARNING: by putting in your own exception handler into IPython's main
1889 WARNING: by putting in your own exception handler into IPython's main
1890 execution loop, you run a very good chance of nasty crashes. This
1890 execution loop, you run a very good chance of nasty crashes. This
1891 facility should only be used if you really know what you are doing."""
1891 facility should only be used if you really know what you are doing."""
1892 if not isinstance(exc_tuple, tuple):
1892 if not isinstance(exc_tuple, tuple):
1893 raise TypeError("The custom exceptions must be given as a tuple.")
1893 raise TypeError("The custom exceptions must be given as a tuple.")
1894
1894
1895 def dummy_handler(self, etype, value, tb, tb_offset=None):
1895 def dummy_handler(self, etype, value, tb, tb_offset=None):
1896 print('*** Simple custom exception handler ***')
1896 print('*** Simple custom exception handler ***')
1897 print('Exception type :', etype)
1897 print('Exception type :', etype)
1898 print('Exception value:', value)
1898 print('Exception value:', value)
1899 print('Traceback :', tb)
1899 print('Traceback :', tb)
1900
1900
1901 def validate_stb(stb):
1901 def validate_stb(stb):
1902 """validate structured traceback return type
1902 """validate structured traceback return type
1903
1903
1904 return type of CustomTB *should* be a list of strings, but allow
1904 return type of CustomTB *should* be a list of strings, but allow
1905 single strings or None, which are harmless.
1905 single strings or None, which are harmless.
1906
1906
1907 This function will *always* return a list of strings,
1907 This function will *always* return a list of strings,
1908 and will raise a TypeError if stb is inappropriate.
1908 and will raise a TypeError if stb is inappropriate.
1909 """
1909 """
1910 msg = "CustomTB must return list of strings, not %r" % stb
1910 msg = "CustomTB must return list of strings, not %r" % stb
1911 if stb is None:
1911 if stb is None:
1912 return []
1912 return []
1913 elif isinstance(stb, str):
1913 elif isinstance(stb, str):
1914 return [stb]
1914 return [stb]
1915 elif not isinstance(stb, list):
1915 elif not isinstance(stb, list):
1916 raise TypeError(msg)
1916 raise TypeError(msg)
1917 # it's a list
1917 # it's a list
1918 for line in stb:
1918 for line in stb:
1919 # check every element
1919 # check every element
1920 if not isinstance(line, str):
1920 if not isinstance(line, str):
1921 raise TypeError(msg)
1921 raise TypeError(msg)
1922 return stb
1922 return stb
1923
1923
1924 if handler is None:
1924 if handler is None:
1925 wrapped = dummy_handler
1925 wrapped = dummy_handler
1926 else:
1926 else:
1927 def wrapped(self,etype,value,tb,tb_offset=None):
1927 def wrapped(self,etype,value,tb,tb_offset=None):
1928 """wrap CustomTB handler, to protect IPython from user code
1928 """wrap CustomTB handler, to protect IPython from user code
1929
1929
1930 This makes it harder (but not impossible) for custom exception
1930 This makes it harder (but not impossible) for custom exception
1931 handlers to crash IPython.
1931 handlers to crash IPython.
1932 """
1932 """
1933 try:
1933 try:
1934 stb = handler(self,etype,value,tb,tb_offset=tb_offset)
1934 stb = handler(self,etype,value,tb,tb_offset=tb_offset)
1935 return validate_stb(stb)
1935 return validate_stb(stb)
1936 except:
1936 except:
1937 # clear custom handler immediately
1937 # clear custom handler immediately
1938 self.set_custom_exc((), None)
1938 self.set_custom_exc((), None)
1939 print("Custom TB Handler failed, unregistering", file=sys.stderr)
1939 print("Custom TB Handler failed, unregistering", file=sys.stderr)
1940 # show the exception in handler first
1940 # show the exception in handler first
1941 stb = self.InteractiveTB.structured_traceback(*sys.exc_info())
1941 stb = self.InteractiveTB.structured_traceback(*sys.exc_info())
1942 print(self.InteractiveTB.stb2text(stb))
1942 print(self.InteractiveTB.stb2text(stb))
1943 print("The original exception:")
1943 print("The original exception:")
1944 stb = self.InteractiveTB.structured_traceback(
1944 stb = self.InteractiveTB.structured_traceback(
1945 (etype,value,tb), tb_offset=tb_offset
1945 (etype,value,tb), tb_offset=tb_offset
1946 )
1946 )
1947 return stb
1947 return stb
1948
1948
1949 self.CustomTB = types.MethodType(wrapped,self)
1949 self.CustomTB = types.MethodType(wrapped,self)
1950 self.custom_exceptions = exc_tuple
1950 self.custom_exceptions = exc_tuple
1951
1951
1952 def excepthook(self, etype, value, tb):
1952 def excepthook(self, etype, value, tb):
1953 """One more defense for GUI apps that call sys.excepthook.
1953 """One more defense for GUI apps that call sys.excepthook.
1954
1954
1955 GUI frameworks like wxPython trap exceptions and call
1955 GUI frameworks like wxPython trap exceptions and call
1956 sys.excepthook themselves. I guess this is a feature that
1956 sys.excepthook themselves. I guess this is a feature that
1957 enables them to keep running after exceptions that would
1957 enables them to keep running after exceptions that would
1958 otherwise kill their mainloop. This is a bother for IPython
1958 otherwise kill their mainloop. This is a bother for IPython
1959 which excepts to catch all of the program exceptions with a try:
1959 which excepts to catch all of the program exceptions with a try:
1960 except: statement.
1960 except: statement.
1961
1961
1962 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1962 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1963 any app directly invokes sys.excepthook, it will look to the user like
1963 any app directly invokes sys.excepthook, it will look to the user like
1964 IPython crashed. In order to work around this, we can disable the
1964 IPython crashed. In order to work around this, we can disable the
1965 CrashHandler and replace it with this excepthook instead, which prints a
1965 CrashHandler and replace it with this excepthook instead, which prints a
1966 regular traceback using our InteractiveTB. In this fashion, apps which
1966 regular traceback using our InteractiveTB. In this fashion, apps which
1967 call sys.excepthook will generate a regular-looking exception from
1967 call sys.excepthook will generate a regular-looking exception from
1968 IPython, and the CrashHandler will only be triggered by real IPython
1968 IPython, and the CrashHandler will only be triggered by real IPython
1969 crashes.
1969 crashes.
1970
1970
1971 This hook should be used sparingly, only in places which are not likely
1971 This hook should be used sparingly, only in places which are not likely
1972 to be true IPython errors.
1972 to be true IPython errors.
1973 """
1973 """
1974 self.showtraceback((etype, value, tb), tb_offset=0)
1974 self.showtraceback((etype, value, tb), tb_offset=0)
1975
1975
1976 def _get_exc_info(self, exc_tuple=None):
1976 def _get_exc_info(self, exc_tuple=None):
1977 """get exc_info from a given tuple, sys.exc_info() or sys.last_type etc.
1977 """get exc_info from a given tuple, sys.exc_info() or sys.last_type etc.
1978
1978
1979 Ensures sys.last_type,value,traceback hold the exc_info we found,
1979 Ensures sys.last_type,value,traceback hold the exc_info we found,
1980 from whichever source.
1980 from whichever source.
1981
1981
1982 raises ValueError if none of these contain any information
1982 raises ValueError if none of these contain any information
1983 """
1983 """
1984 if exc_tuple is None:
1984 if exc_tuple is None:
1985 etype, value, tb = sys.exc_info()
1985 etype, value, tb = sys.exc_info()
1986 else:
1986 else:
1987 etype, value, tb = exc_tuple
1987 etype, value, tb = exc_tuple
1988
1988
1989 if etype is None:
1989 if etype is None:
1990 if hasattr(sys, 'last_type'):
1990 if hasattr(sys, 'last_type'):
1991 etype, value, tb = sys.last_type, sys.last_value, \
1991 etype, value, tb = sys.last_type, sys.last_value, \
1992 sys.last_traceback
1992 sys.last_traceback
1993
1993
1994 if etype is None:
1994 if etype is None:
1995 raise ValueError("No exception to find")
1995 raise ValueError("No exception to find")
1996
1996
1997 # Now store the exception info in sys.last_type etc.
1997 # Now store the exception info in sys.last_type etc.
1998 # WARNING: these variables are somewhat deprecated and not
1998 # WARNING: these variables are somewhat deprecated and not
1999 # necessarily safe to use in a threaded environment, but tools
1999 # necessarily safe to use in a threaded environment, but tools
2000 # like pdb depend on their existence, so let's set them. If we
2000 # like pdb depend on their existence, so let's set them. If we
2001 # find problems in the field, we'll need to revisit their use.
2001 # find problems in the field, we'll need to revisit their use.
2002 sys.last_type = etype
2002 sys.last_type = etype
2003 sys.last_value = value
2003 sys.last_value = value
2004 sys.last_traceback = tb
2004 sys.last_traceback = tb
2005
2005
2006 return etype, value, tb
2006 return etype, value, tb
2007
2007
2008 def show_usage_error(self, exc):
2008 def show_usage_error(self, exc):
2009 """Show a short message for UsageErrors
2009 """Show a short message for UsageErrors
2010
2010
2011 These are special exceptions that shouldn't show a traceback.
2011 These are special exceptions that shouldn't show a traceback.
2012 """
2012 """
2013 print("UsageError: %s" % exc, file=sys.stderr)
2013 print("UsageError: %s" % exc, file=sys.stderr)
2014
2014
2015 def get_exception_only(self, exc_tuple=None):
2015 def get_exception_only(self, exc_tuple=None):
2016 """
2016 """
2017 Return as a string (ending with a newline) the exception that
2017 Return as a string (ending with a newline) the exception that
2018 just occurred, without any traceback.
2018 just occurred, without any traceback.
2019 """
2019 """
2020 etype, value, tb = self._get_exc_info(exc_tuple)
2020 etype, value, tb = self._get_exc_info(exc_tuple)
2021 msg = traceback.format_exception_only(etype, value)
2021 msg = traceback.format_exception_only(etype, value)
2022 return ''.join(msg)
2022 return ''.join(msg)
2023
2023
2024 def showtraceback(self, exc_tuple=None, filename=None, tb_offset=None,
2024 def showtraceback(self, exc_tuple=None, filename=None, tb_offset=None,
2025 exception_only=False, running_compiled_code=False):
2025 exception_only=False, running_compiled_code=False):
2026 """Display the exception that just occurred.
2026 """Display the exception that just occurred.
2027
2027
2028 If nothing is known about the exception, this is the method which
2028 If nothing is known about the exception, this is the method which
2029 should be used throughout the code for presenting user tracebacks,
2029 should be used throughout the code for presenting user tracebacks,
2030 rather than directly invoking the InteractiveTB object.
2030 rather than directly invoking the InteractiveTB object.
2031
2031
2032 A specific showsyntaxerror() also exists, but this method can take
2032 A specific showsyntaxerror() also exists, but this method can take
2033 care of calling it if needed, so unless you are explicitly catching a
2033 care of calling it if needed, so unless you are explicitly catching a
2034 SyntaxError exception, don't try to analyze the stack manually and
2034 SyntaxError exception, don't try to analyze the stack manually and
2035 simply call this method."""
2035 simply call this method."""
2036
2036
2037 try:
2037 try:
2038 try:
2038 try:
2039 etype, value, tb = self._get_exc_info(exc_tuple)
2039 etype, value, tb = self._get_exc_info(exc_tuple)
2040 except ValueError:
2040 except ValueError:
2041 print('No traceback available to show.', file=sys.stderr)
2041 print('No traceback available to show.', file=sys.stderr)
2042 return
2042 return
2043
2043
2044 if issubclass(etype, SyntaxError):
2044 if issubclass(etype, SyntaxError):
2045 # Though this won't be called by syntax errors in the input
2045 # Though this won't be called by syntax errors in the input
2046 # line, there may be SyntaxError cases with imported code.
2046 # line, there may be SyntaxError cases with imported code.
2047 self.showsyntaxerror(filename, running_compiled_code)
2047 self.showsyntaxerror(filename, running_compiled_code)
2048 elif etype is UsageError:
2048 elif etype is UsageError:
2049 self.show_usage_error(value)
2049 self.show_usage_error(value)
2050 else:
2050 else:
2051 if exception_only:
2051 if exception_only:
2052 stb = ['An exception has occurred, use %tb to see '
2052 stb = ['An exception has occurred, use %tb to see '
2053 'the full traceback.\n']
2053 'the full traceback.\n']
2054 stb.extend(self.InteractiveTB.get_exception_only(etype,
2054 stb.extend(self.InteractiveTB.get_exception_only(etype,
2055 value))
2055 value))
2056 else:
2056 else:
2057 try:
2057 try:
2058 # Exception classes can customise their traceback - we
2058 # Exception classes can customise their traceback - we
2059 # use this in IPython.parallel for exceptions occurring
2059 # use this in IPython.parallel for exceptions occurring
2060 # in the engines. This should return a list of strings.
2060 # in the engines. This should return a list of strings.
2061 stb = value._render_traceback_()
2061 stb = value._render_traceback_()
2062 except Exception:
2062 except Exception:
2063 stb = self.InteractiveTB.structured_traceback(etype,
2063 stb = self.InteractiveTB.structured_traceback(etype,
2064 value, tb, tb_offset=tb_offset)
2064 value, tb, tb_offset=tb_offset)
2065
2065
2066 self._showtraceback(etype, value, stb)
2066 self._showtraceback(etype, value, stb)
2067 if self.call_pdb:
2067 if self.call_pdb:
2068 # drop into debugger
2068 # drop into debugger
2069 self.debugger(force=True)
2069 self.debugger(force=True)
2070 return
2070 return
2071
2071
2072 # Actually show the traceback
2072 # Actually show the traceback
2073 self._showtraceback(etype, value, stb)
2073 self._showtraceback(etype, value, stb)
2074
2074
2075 except KeyboardInterrupt:
2075 except KeyboardInterrupt:
2076 print('\n' + self.get_exception_only(), file=sys.stderr)
2076 print('\n' + self.get_exception_only(), file=sys.stderr)
2077
2077
2078 def _showtraceback(self, etype, evalue, stb: str):
2078 def _showtraceback(self, etype, evalue, stb: str):
2079 """Actually show a traceback.
2079 """Actually show a traceback.
2080
2080
2081 Subclasses may override this method to put the traceback on a different
2081 Subclasses may override this method to put the traceback on a different
2082 place, like a side channel.
2082 place, like a side channel.
2083 """
2083 """
2084 val = self.InteractiveTB.stb2text(stb)
2084 val = self.InteractiveTB.stb2text(stb)
2085 try:
2085 try:
2086 print(val)
2086 print(val)
2087 except UnicodeEncodeError:
2087 except UnicodeEncodeError:
2088 print(val.encode("utf-8", "backslashreplace").decode())
2088 print(val.encode("utf-8", "backslashreplace").decode())
2089
2089
2090 def showsyntaxerror(self, filename=None, running_compiled_code=False):
2090 def showsyntaxerror(self, filename=None, running_compiled_code=False):
2091 """Display the syntax error that just occurred.
2091 """Display the syntax error that just occurred.
2092
2092
2093 This doesn't display a stack trace because there isn't one.
2093 This doesn't display a stack trace because there isn't one.
2094
2094
2095 If a filename is given, it is stuffed in the exception instead
2095 If a filename is given, it is stuffed in the exception instead
2096 of what was there before (because Python's parser always uses
2096 of what was there before (because Python's parser always uses
2097 "<string>" when reading from a string).
2097 "<string>" when reading from a string).
2098
2098
2099 If the syntax error occurred when running a compiled code (i.e. running_compile_code=True),
2099 If the syntax error occurred when running a compiled code (i.e. running_compile_code=True),
2100 longer stack trace will be displayed.
2100 longer stack trace will be displayed.
2101 """
2101 """
2102 etype, value, last_traceback = self._get_exc_info()
2102 etype, value, last_traceback = self._get_exc_info()
2103
2103
2104 if filename and issubclass(etype, SyntaxError):
2104 if filename and issubclass(etype, SyntaxError):
2105 try:
2105 try:
2106 value.filename = filename
2106 value.filename = filename
2107 except:
2107 except:
2108 # Not the format we expect; leave it alone
2108 # Not the format we expect; leave it alone
2109 pass
2109 pass
2110
2110
2111 # If the error occurred when executing compiled code, we should provide full stacktrace.
2111 # If the error occurred when executing compiled code, we should provide full stacktrace.
2112 elist = traceback.extract_tb(last_traceback) if running_compiled_code else []
2112 elist = traceback.extract_tb(last_traceback) if running_compiled_code else []
2113 stb = self.SyntaxTB.structured_traceback(etype, value, elist)
2113 stb = self.SyntaxTB.structured_traceback(etype, value, elist)
2114 self._showtraceback(etype, value, stb)
2114 self._showtraceback(etype, value, stb)
2115
2115
2116 # This is overridden in TerminalInteractiveShell to show a message about
2116 # This is overridden in TerminalInteractiveShell to show a message about
2117 # the %paste magic.
2117 # the %paste magic.
2118 def showindentationerror(self):
2118 def showindentationerror(self):
2119 """Called by _run_cell when there's an IndentationError in code entered
2119 """Called by _run_cell when there's an IndentationError in code entered
2120 at the prompt.
2120 at the prompt.
2121
2121
2122 This is overridden in TerminalInteractiveShell to show a message about
2122 This is overridden in TerminalInteractiveShell to show a message about
2123 the %paste magic."""
2123 the %paste magic."""
2124 self.showsyntaxerror()
2124 self.showsyntaxerror()
2125
2125
2126 #-------------------------------------------------------------------------
2126 #-------------------------------------------------------------------------
2127 # Things related to readline
2127 # Things related to readline
2128 #-------------------------------------------------------------------------
2128 #-------------------------------------------------------------------------
2129
2129
2130 def init_readline(self):
2130 def init_readline(self):
2131 """DEPRECATED
2131 """DEPRECATED
2132
2132
2133 Moved to terminal subclass, here only to simplify the init logic."""
2133 Moved to terminal subclass, here only to simplify the init logic."""
2134 # Set a number of methods that depend on readline to be no-op
2134 # Set a number of methods that depend on readline to be no-op
2135 warnings.warn('`init_readline` is no-op since IPython 5.0 and is Deprecated',
2135 warnings.warn('`init_readline` is no-op since IPython 5.0 and is Deprecated',
2136 DeprecationWarning, stacklevel=2)
2136 DeprecationWarning, stacklevel=2)
2137 self.set_custom_completer = no_op
2137 self.set_custom_completer = no_op
2138
2138
2139 @skip_doctest
2139 @skip_doctest
2140 def set_next_input(self, s, replace=False):
2140 def set_next_input(self, s, replace=False):
2141 """ Sets the 'default' input string for the next command line.
2141 """ Sets the 'default' input string for the next command line.
2142
2142
2143 Example::
2143 Example::
2144
2144
2145 In [1]: _ip.set_next_input("Hello Word")
2145 In [1]: _ip.set_next_input("Hello Word")
2146 In [2]: Hello Word_ # cursor is here
2146 In [2]: Hello Word_ # cursor is here
2147 """
2147 """
2148 self.rl_next_input = s
2148 self.rl_next_input = s
2149
2149
2150 def _indent_current_str(self):
2150 def _indent_current_str(self):
2151 """return the current level of indentation as a string"""
2151 """return the current level of indentation as a string"""
2152 return self.input_splitter.get_indent_spaces() * ' '
2152 return self.input_splitter.get_indent_spaces() * ' '
2153
2153
2154 #-------------------------------------------------------------------------
2154 #-------------------------------------------------------------------------
2155 # Things related to text completion
2155 # Things related to text completion
2156 #-------------------------------------------------------------------------
2156 #-------------------------------------------------------------------------
2157
2157
2158 def init_completer(self):
2158 def init_completer(self):
2159 """Initialize the completion machinery.
2159 """Initialize the completion machinery.
2160
2160
2161 This creates completion machinery that can be used by client code,
2161 This creates completion machinery that can be used by client code,
2162 either interactively in-process (typically triggered by the readline
2162 either interactively in-process (typically triggered by the readline
2163 library), programmatically (such as in test suites) or out-of-process
2163 library), programmatically (such as in test suites) or out-of-process
2164 (typically over the network by remote frontends).
2164 (typically over the network by remote frontends).
2165 """
2165 """
2166 from IPython.core.completer import IPCompleter
2166 from IPython.core.completer import IPCompleter
2167 from IPython.core.completerlib import (module_completer,
2167 from IPython.core.completerlib import (module_completer,
2168 magic_run_completer, cd_completer, reset_completer)
2168 magic_run_completer, cd_completer, reset_completer)
2169
2169
2170 self.Completer = IPCompleter(shell=self,
2170 self.Completer = IPCompleter(shell=self,
2171 namespace=self.user_ns,
2171 namespace=self.user_ns,
2172 global_namespace=self.user_global_ns,
2172 global_namespace=self.user_global_ns,
2173 parent=self,
2173 parent=self,
2174 )
2174 )
2175 self.configurables.append(self.Completer)
2175 self.configurables.append(self.Completer)
2176
2176
2177 # Add custom completers to the basic ones built into IPCompleter
2177 # Add custom completers to the basic ones built into IPCompleter
2178 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
2178 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
2179 self.strdispatchers['complete_command'] = sdisp
2179 self.strdispatchers['complete_command'] = sdisp
2180 self.Completer.custom_completers = sdisp
2180 self.Completer.custom_completers = sdisp
2181
2181
2182 self.set_hook('complete_command', module_completer, str_key = 'import')
2182 self.set_hook('complete_command', module_completer, str_key = 'import')
2183 self.set_hook('complete_command', module_completer, str_key = 'from')
2183 self.set_hook('complete_command', module_completer, str_key = 'from')
2184 self.set_hook('complete_command', module_completer, str_key = '%aimport')
2184 self.set_hook('complete_command', module_completer, str_key = '%aimport')
2185 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
2185 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
2186 self.set_hook('complete_command', cd_completer, str_key = '%cd')
2186 self.set_hook('complete_command', cd_completer, str_key = '%cd')
2187 self.set_hook('complete_command', reset_completer, str_key = '%reset')
2187 self.set_hook('complete_command', reset_completer, str_key = '%reset')
2188
2188
2189 @skip_doctest
2189 @skip_doctest
2190 def complete(self, text, line=None, cursor_pos=None):
2190 def complete(self, text, line=None, cursor_pos=None):
2191 """Return the completed text and a list of completions.
2191 """Return the completed text and a list of completions.
2192
2192
2193 Parameters
2193 Parameters
2194 ----------
2194 ----------
2195
2195
2196 text : string
2196 text : string
2197 A string of text to be completed on. It can be given as empty and
2197 A string of text to be completed on. It can be given as empty and
2198 instead a line/position pair are given. In this case, the
2198 instead a line/position pair are given. In this case, the
2199 completer itself will split the line like readline does.
2199 completer itself will split the line like readline does.
2200
2200
2201 line : string, optional
2201 line : string, optional
2202 The complete line that text is part of.
2202 The complete line that text is part of.
2203
2203
2204 cursor_pos : int, optional
2204 cursor_pos : int, optional
2205 The position of the cursor on the input line.
2205 The position of the cursor on the input line.
2206
2206
2207 Returns
2207 Returns
2208 -------
2208 -------
2209 text : string
2209 text : string
2210 The actual text that was completed.
2210 The actual text that was completed.
2211
2211
2212 matches : list
2212 matches : list
2213 A sorted list with all possible completions.
2213 A sorted list with all possible completions.
2214
2214
2215 The optional arguments allow the completion to take more context into
2215 The optional arguments allow the completion to take more context into
2216 account, and are part of the low-level completion API.
2216 account, and are part of the low-level completion API.
2217
2217
2218 This is a wrapper around the completion mechanism, similar to what
2218 This is a wrapper around the completion mechanism, similar to what
2219 readline does at the command line when the TAB key is hit. By
2219 readline does at the command line when the TAB key is hit. By
2220 exposing it as a method, it can be used by other non-readline
2220 exposing it as a method, it can be used by other non-readline
2221 environments (such as GUIs) for text completion.
2221 environments (such as GUIs) for text completion.
2222
2222
2223 Simple usage example:
2223 Simple usage example:
2224
2224
2225 In [1]: x = 'hello'
2225 In [1]: x = 'hello'
2226
2226
2227 In [2]: _ip.complete('x.l')
2227 In [2]: _ip.complete('x.l')
2228 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
2228 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
2229 """
2229 """
2230
2230
2231 # Inject names into __builtin__ so we can complete on the added names.
2231 # Inject names into __builtin__ so we can complete on the added names.
2232 with self.builtin_trap:
2232 with self.builtin_trap:
2233 return self.Completer.complete(text, line, cursor_pos)
2233 return self.Completer.complete(text, line, cursor_pos)
2234
2234
2235 def set_custom_completer(self, completer, pos=0) -> None:
2235 def set_custom_completer(self, completer, pos=0) -> None:
2236 """Adds a new custom completer function.
2236 """Adds a new custom completer function.
2237
2237
2238 The position argument (defaults to 0) is the index in the completers
2238 The position argument (defaults to 0) is the index in the completers
2239 list where you want the completer to be inserted.
2239 list where you want the completer to be inserted.
2240
2240
2241 `completer` should have the following signature::
2241 `completer` should have the following signature::
2242
2242
2243 def completion(self: Completer, text: string) -> List[str]:
2243 def completion(self: Completer, text: string) -> List[str]:
2244 raise NotImplementedError
2244 raise NotImplementedError
2245
2245
2246 It will be bound to the current Completer instance and pass some text
2246 It will be bound to the current Completer instance and pass some text
2247 and return a list with current completions to suggest to the user.
2247 and return a list with current completions to suggest to the user.
2248 """
2248 """
2249
2249
2250 newcomp = types.MethodType(completer, self.Completer)
2250 newcomp = types.MethodType(completer, self.Completer)
2251 self.Completer.custom_matchers.insert(pos,newcomp)
2251 self.Completer.custom_matchers.insert(pos,newcomp)
2252
2252
2253 def set_completer_frame(self, frame=None):
2253 def set_completer_frame(self, frame=None):
2254 """Set the frame of the completer."""
2254 """Set the frame of the completer."""
2255 if frame:
2255 if frame:
2256 self.Completer.namespace = frame.f_locals
2256 self.Completer.namespace = frame.f_locals
2257 self.Completer.global_namespace = frame.f_globals
2257 self.Completer.global_namespace = frame.f_globals
2258 else:
2258 else:
2259 self.Completer.namespace = self.user_ns
2259 self.Completer.namespace = self.user_ns
2260 self.Completer.global_namespace = self.user_global_ns
2260 self.Completer.global_namespace = self.user_global_ns
2261
2261
2262 #-------------------------------------------------------------------------
2262 #-------------------------------------------------------------------------
2263 # Things related to magics
2263 # Things related to magics
2264 #-------------------------------------------------------------------------
2264 #-------------------------------------------------------------------------
2265
2265
2266 def init_magics(self):
2266 def init_magics(self):
2267 from IPython.core import magics as m
2267 from IPython.core import magics as m
2268 self.magics_manager = magic.MagicsManager(shell=self,
2268 self.magics_manager = magic.MagicsManager(shell=self,
2269 parent=self,
2269 parent=self,
2270 user_magics=m.UserMagics(self))
2270 user_magics=m.UserMagics(self))
2271 self.configurables.append(self.magics_manager)
2271 self.configurables.append(self.magics_manager)
2272
2272
2273 # Expose as public API from the magics manager
2273 # Expose as public API from the magics manager
2274 self.register_magics = self.magics_manager.register
2274 self.register_magics = self.magics_manager.register
2275
2275
2276 self.register_magics(m.AutoMagics, m.BasicMagics, m.CodeMagics,
2276 self.register_magics(m.AutoMagics, m.BasicMagics, m.CodeMagics,
2277 m.ConfigMagics, m.DisplayMagics, m.ExecutionMagics,
2277 m.ConfigMagics, m.DisplayMagics, m.ExecutionMagics,
2278 m.ExtensionMagics, m.HistoryMagics, m.LoggingMagics,
2278 m.ExtensionMagics, m.HistoryMagics, m.LoggingMagics,
2279 m.NamespaceMagics, m.OSMagics, m.PackagingMagics,
2279 m.NamespaceMagics, m.OSMagics, m.PackagingMagics,
2280 m.PylabMagics, m.ScriptMagics,
2280 m.PylabMagics, m.ScriptMagics,
2281 )
2281 )
2282 self.register_magics(m.AsyncMagics)
2282 self.register_magics(m.AsyncMagics)
2283
2283
2284 # Register Magic Aliases
2284 # Register Magic Aliases
2285 mman = self.magics_manager
2285 mman = self.magics_manager
2286 # FIXME: magic aliases should be defined by the Magics classes
2286 # FIXME: magic aliases should be defined by the Magics classes
2287 # or in MagicsManager, not here
2287 # or in MagicsManager, not here
2288 mman.register_alias('ed', 'edit')
2288 mman.register_alias('ed', 'edit')
2289 mman.register_alias('hist', 'history')
2289 mman.register_alias('hist', 'history')
2290 mman.register_alias('rep', 'recall')
2290 mman.register_alias('rep', 'recall')
2291 mman.register_alias('SVG', 'svg', 'cell')
2291 mman.register_alias('SVG', 'svg', 'cell')
2292 mman.register_alias('HTML', 'html', 'cell')
2292 mman.register_alias('HTML', 'html', 'cell')
2293 mman.register_alias('file', 'writefile', 'cell')
2293 mman.register_alias('file', 'writefile', 'cell')
2294
2294
2295 # FIXME: Move the color initialization to the DisplayHook, which
2295 # FIXME: Move the color initialization to the DisplayHook, which
2296 # should be split into a prompt manager and displayhook. We probably
2296 # should be split into a prompt manager and displayhook. We probably
2297 # even need a centralize colors management object.
2297 # even need a centralize colors management object.
2298 self.run_line_magic('colors', self.colors)
2298 self.run_line_magic('colors', self.colors)
2299
2299
2300 # Defined here so that it's included in the documentation
2300 # Defined here so that it's included in the documentation
2301 @functools.wraps(magic.MagicsManager.register_function)
2301 @functools.wraps(magic.MagicsManager.register_function)
2302 def register_magic_function(self, func, magic_kind='line', magic_name=None):
2302 def register_magic_function(self, func, magic_kind='line', magic_name=None):
2303 self.magics_manager.register_function(
2303 self.magics_manager.register_function(
2304 func, magic_kind=magic_kind, magic_name=magic_name
2304 func, magic_kind=magic_kind, magic_name=magic_name
2305 )
2305 )
2306
2306
2307 def run_line_magic(self, magic_name, line, _stack_depth=1):
2307 def run_line_magic(self, magic_name, line, _stack_depth=1):
2308 """Execute the given line magic.
2308 """Execute the given line magic.
2309
2309
2310 Parameters
2310 Parameters
2311 ----------
2311 ----------
2312 magic_name : str
2312 magic_name : str
2313 Name of the desired magic function, without '%' prefix.
2313 Name of the desired magic function, without '%' prefix.
2314
2314
2315 line : str
2315 line : str
2316 The rest of the input line as a single string.
2316 The rest of the input line as a single string.
2317
2317
2318 _stack_depth : int
2318 _stack_depth : int
2319 If run_line_magic() is called from magic() then _stack_depth=2.
2319 If run_line_magic() is called from magic() then _stack_depth=2.
2320 This is added to ensure backward compatibility for use of 'get_ipython().magic()'
2320 This is added to ensure backward compatibility for use of 'get_ipython().magic()'
2321 """
2321 """
2322 fn = self.find_line_magic(magic_name)
2322 fn = self.find_line_magic(magic_name)
2323 if fn is None:
2323 if fn is None:
2324 cm = self.find_cell_magic(magic_name)
2324 cm = self.find_cell_magic(magic_name)
2325 etpl = "Line magic function `%%%s` not found%s."
2325 etpl = "Line magic function `%%%s` not found%s."
2326 extra = '' if cm is None else (' (But cell magic `%%%%%s` exists, '
2326 extra = '' if cm is None else (' (But cell magic `%%%%%s` exists, '
2327 'did you mean that instead?)' % magic_name )
2327 'did you mean that instead?)' % magic_name )
2328 raise UsageError(etpl % (magic_name, extra))
2328 raise UsageError(etpl % (magic_name, extra))
2329 else:
2329 else:
2330 # Note: this is the distance in the stack to the user's frame.
2330 # Note: this is the distance in the stack to the user's frame.
2331 # This will need to be updated if the internal calling logic gets
2331 # This will need to be updated if the internal calling logic gets
2332 # refactored, or else we'll be expanding the wrong variables.
2332 # refactored, or else we'll be expanding the wrong variables.
2333
2333
2334 # Determine stack_depth depending on where run_line_magic() has been called
2334 # Determine stack_depth depending on where run_line_magic() has been called
2335 stack_depth = _stack_depth
2335 stack_depth = _stack_depth
2336 if getattr(fn, magic.MAGIC_NO_VAR_EXPAND_ATTR, False):
2336 if getattr(fn, magic.MAGIC_NO_VAR_EXPAND_ATTR, False):
2337 # magic has opted out of var_expand
2337 # magic has opted out of var_expand
2338 magic_arg_s = line
2338 magic_arg_s = line
2339 else:
2339 else:
2340 magic_arg_s = self.var_expand(line, stack_depth)
2340 magic_arg_s = self.var_expand(line, stack_depth)
2341 # Put magic args in a list so we can call with f(*a) syntax
2341 # Put magic args in a list so we can call with f(*a) syntax
2342 args = [magic_arg_s]
2342 args = [magic_arg_s]
2343 kwargs = {}
2343 kwargs = {}
2344 # Grab local namespace if we need it:
2344 # Grab local namespace if we need it:
2345 if getattr(fn, "needs_local_scope", False):
2345 if getattr(fn, "needs_local_scope", False):
2346 kwargs['local_ns'] = self.get_local_scope(stack_depth)
2346 kwargs['local_ns'] = self.get_local_scope(stack_depth)
2347 with self.builtin_trap:
2347 with self.builtin_trap:
2348 result = fn(*args, **kwargs)
2348 result = fn(*args, **kwargs)
2349 return result
2349 return result
2350
2350
2351 def get_local_scope(self, stack_depth):
2351 def get_local_scope(self, stack_depth):
2352 """Get local scope at given stack depth.
2352 """Get local scope at given stack depth.
2353
2353
2354 Parameters
2354 Parameters
2355 ----------
2355 ----------
2356 stack_depth : int
2356 stack_depth : int
2357 Depth relative to calling frame
2357 Depth relative to calling frame
2358 """
2358 """
2359 return sys._getframe(stack_depth + 1).f_locals
2359 return sys._getframe(stack_depth + 1).f_locals
2360
2360
2361 def run_cell_magic(self, magic_name, line, cell):
2361 def run_cell_magic(self, magic_name, line, cell):
2362 """Execute the given cell magic.
2362 """Execute the given cell magic.
2363
2363
2364 Parameters
2364 Parameters
2365 ----------
2365 ----------
2366 magic_name : str
2366 magic_name : str
2367 Name of the desired magic function, without '%' prefix.
2367 Name of the desired magic function, without '%' prefix.
2368
2368
2369 line : str
2369 line : str
2370 The rest of the first input line as a single string.
2370 The rest of the first input line as a single string.
2371
2371
2372 cell : str
2372 cell : str
2373 The body of the cell as a (possibly multiline) string.
2373 The body of the cell as a (possibly multiline) string.
2374 """
2374 """
2375 fn = self.find_cell_magic(magic_name)
2375 fn = self.find_cell_magic(magic_name)
2376 if fn is None:
2376 if fn is None:
2377 lm = self.find_line_magic(magic_name)
2377 lm = self.find_line_magic(magic_name)
2378 etpl = "Cell magic `%%{0}` not found{1}."
2378 etpl = "Cell magic `%%{0}` not found{1}."
2379 extra = '' if lm is None else (' (But line magic `%{0}` exists, '
2379 extra = '' if lm is None else (' (But line magic `%{0}` exists, '
2380 'did you mean that instead?)'.format(magic_name))
2380 'did you mean that instead?)'.format(magic_name))
2381 raise UsageError(etpl.format(magic_name, extra))
2381 raise UsageError(etpl.format(magic_name, extra))
2382 elif cell == '':
2382 elif cell == '':
2383 message = '%%{0} is a cell magic, but the cell body is empty.'.format(magic_name)
2383 message = '%%{0} is a cell magic, but the cell body is empty.'.format(magic_name)
2384 if self.find_line_magic(magic_name) is not None:
2384 if self.find_line_magic(magic_name) is not None:
2385 message += ' Did you mean the line magic %{0} (single %)?'.format(magic_name)
2385 message += ' Did you mean the line magic %{0} (single %)?'.format(magic_name)
2386 raise UsageError(message)
2386 raise UsageError(message)
2387 else:
2387 else:
2388 # Note: this is the distance in the stack to the user's frame.
2388 # Note: this is the distance in the stack to the user's frame.
2389 # This will need to be updated if the internal calling logic gets
2389 # This will need to be updated if the internal calling logic gets
2390 # refactored, or else we'll be expanding the wrong variables.
2390 # refactored, or else we'll be expanding the wrong variables.
2391 stack_depth = 2
2391 stack_depth = 2
2392 if getattr(fn, magic.MAGIC_NO_VAR_EXPAND_ATTR, False):
2392 if getattr(fn, magic.MAGIC_NO_VAR_EXPAND_ATTR, False):
2393 # magic has opted out of var_expand
2393 # magic has opted out of var_expand
2394 magic_arg_s = line
2394 magic_arg_s = line
2395 else:
2395 else:
2396 magic_arg_s = self.var_expand(line, stack_depth)
2396 magic_arg_s = self.var_expand(line, stack_depth)
2397 kwargs = {}
2397 kwargs = {}
2398 if getattr(fn, "needs_local_scope", False):
2398 if getattr(fn, "needs_local_scope", False):
2399 kwargs['local_ns'] = self.user_ns
2399 kwargs['local_ns'] = self.user_ns
2400
2400
2401 with self.builtin_trap:
2401 with self.builtin_trap:
2402 args = (magic_arg_s, cell)
2402 args = (magic_arg_s, cell)
2403 result = fn(*args, **kwargs)
2403 result = fn(*args, **kwargs)
2404 return result
2404 return result
2405
2405
2406 def find_line_magic(self, magic_name):
2406 def find_line_magic(self, magic_name):
2407 """Find and return a line magic by name.
2407 """Find and return a line magic by name.
2408
2408
2409 Returns None if the magic isn't found."""
2409 Returns None if the magic isn't found."""
2410 return self.magics_manager.magics['line'].get(magic_name)
2410 return self.magics_manager.magics['line'].get(magic_name)
2411
2411
2412 def find_cell_magic(self, magic_name):
2412 def find_cell_magic(self, magic_name):
2413 """Find and return a cell magic by name.
2413 """Find and return a cell magic by name.
2414
2414
2415 Returns None if the magic isn't found."""
2415 Returns None if the magic isn't found."""
2416 return self.magics_manager.magics['cell'].get(magic_name)
2416 return self.magics_manager.magics['cell'].get(magic_name)
2417
2417
2418 def find_magic(self, magic_name, magic_kind='line'):
2418 def find_magic(self, magic_name, magic_kind='line'):
2419 """Find and return a magic of the given type by name.
2419 """Find and return a magic of the given type by name.
2420
2420
2421 Returns None if the magic isn't found."""
2421 Returns None if the magic isn't found."""
2422 return self.magics_manager.magics[magic_kind].get(magic_name)
2422 return self.magics_manager.magics[magic_kind].get(magic_name)
2423
2423
2424 def magic(self, arg_s):
2424 def magic(self, arg_s):
2425 """DEPRECATED. Use run_line_magic() instead.
2425 """DEPRECATED. Use run_line_magic() instead.
2426
2426
2427 Call a magic function by name.
2427 Call a magic function by name.
2428
2428
2429 Input: a string containing the name of the magic function to call and
2429 Input: a string containing the name of the magic function to call and
2430 any additional arguments to be passed to the magic.
2430 any additional arguments to be passed to the magic.
2431
2431
2432 magic('name -opt foo bar') is equivalent to typing at the ipython
2432 magic('name -opt foo bar') is equivalent to typing at the ipython
2433 prompt:
2433 prompt:
2434
2434
2435 In[1]: %name -opt foo bar
2435 In[1]: %name -opt foo bar
2436
2436
2437 To call a magic without arguments, simply use magic('name').
2437 To call a magic without arguments, simply use magic('name').
2438
2438
2439 This provides a proper Python function to call IPython's magics in any
2439 This provides a proper Python function to call IPython's magics in any
2440 valid Python code you can type at the interpreter, including loops and
2440 valid Python code you can type at the interpreter, including loops and
2441 compound statements.
2441 compound statements.
2442 """
2442 """
2443 # TODO: should we issue a loud deprecation warning here?
2443 # TODO: should we issue a loud deprecation warning here?
2444 magic_name, _, magic_arg_s = arg_s.partition(' ')
2444 magic_name, _, magic_arg_s = arg_s.partition(' ')
2445 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
2445 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
2446 return self.run_line_magic(magic_name, magic_arg_s, _stack_depth=2)
2446 return self.run_line_magic(magic_name, magic_arg_s, _stack_depth=2)
2447
2447
2448 #-------------------------------------------------------------------------
2448 #-------------------------------------------------------------------------
2449 # Things related to macros
2449 # Things related to macros
2450 #-------------------------------------------------------------------------
2450 #-------------------------------------------------------------------------
2451
2451
2452 def define_macro(self, name, themacro):
2452 def define_macro(self, name, themacro):
2453 """Define a new macro
2453 """Define a new macro
2454
2454
2455 Parameters
2455 Parameters
2456 ----------
2456 ----------
2457 name : str
2457 name : str
2458 The name of the macro.
2458 The name of the macro.
2459 themacro : str or Macro
2459 themacro : str or Macro
2460 The action to do upon invoking the macro. If a string, a new
2460 The action to do upon invoking the macro. If a string, a new
2461 Macro object is created by passing the string to it.
2461 Macro object is created by passing the string to it.
2462 """
2462 """
2463
2463
2464 from IPython.core import macro
2464 from IPython.core import macro
2465
2465
2466 if isinstance(themacro, str):
2466 if isinstance(themacro, str):
2467 themacro = macro.Macro(themacro)
2467 themacro = macro.Macro(themacro)
2468 if not isinstance(themacro, macro.Macro):
2468 if not isinstance(themacro, macro.Macro):
2469 raise ValueError('A macro must be a string or a Macro instance.')
2469 raise ValueError('A macro must be a string or a Macro instance.')
2470 self.user_ns[name] = themacro
2470 self.user_ns[name] = themacro
2471
2471
2472 #-------------------------------------------------------------------------
2472 #-------------------------------------------------------------------------
2473 # Things related to the running of system commands
2473 # Things related to the running of system commands
2474 #-------------------------------------------------------------------------
2474 #-------------------------------------------------------------------------
2475
2475
2476 def system_piped(self, cmd):
2476 def system_piped(self, cmd):
2477 """Call the given cmd in a subprocess, piping stdout/err
2477 """Call the given cmd in a subprocess, piping stdout/err
2478
2478
2479 Parameters
2479 Parameters
2480 ----------
2480 ----------
2481 cmd : str
2481 cmd : str
2482 Command to execute (can not end in '&', as background processes are
2482 Command to execute (can not end in '&', as background processes are
2483 not supported. Should not be a command that expects input
2483 not supported. Should not be a command that expects input
2484 other than simple text.
2484 other than simple text.
2485 """
2485 """
2486 if cmd.rstrip().endswith('&'):
2486 if cmd.rstrip().endswith('&'):
2487 # this is *far* from a rigorous test
2487 # this is *far* from a rigorous test
2488 # We do not support backgrounding processes because we either use
2488 # We do not support backgrounding processes because we either use
2489 # pexpect or pipes to read from. Users can always just call
2489 # pexpect or pipes to read from. Users can always just call
2490 # os.system() or use ip.system=ip.system_raw
2490 # os.system() or use ip.system=ip.system_raw
2491 # if they really want a background process.
2491 # if they really want a background process.
2492 raise OSError("Background processes not supported.")
2492 raise OSError("Background processes not supported.")
2493
2493
2494 # we explicitly do NOT return the subprocess status code, because
2494 # we explicitly do NOT return the subprocess status code, because
2495 # a non-None value would trigger :func:`sys.displayhook` calls.
2495 # a non-None value would trigger :func:`sys.displayhook` calls.
2496 # Instead, we store the exit_code in user_ns.
2496 # Instead, we store the exit_code in user_ns.
2497 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=1))
2497 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=1))
2498
2498
2499 def system_raw(self, cmd):
2499 def system_raw(self, cmd):
2500 """Call the given cmd in a subprocess using os.system on Windows or
2500 """Call the given cmd in a subprocess using os.system on Windows or
2501 subprocess.call using the system shell on other platforms.
2501 subprocess.call using the system shell on other platforms.
2502
2502
2503 Parameters
2503 Parameters
2504 ----------
2504 ----------
2505 cmd : str
2505 cmd : str
2506 Command to execute.
2506 Command to execute.
2507 """
2507 """
2508 cmd = self.var_expand(cmd, depth=1)
2508 cmd = self.var_expand(cmd, depth=1)
2509 # protect os.system from UNC paths on Windows, which it can't handle:
2509 # protect os.system from UNC paths on Windows, which it can't handle:
2510 if sys.platform == 'win32':
2510 if sys.platform == 'win32':
2511 from IPython.utils._process_win32 import AvoidUNCPath
2511 from IPython.utils._process_win32 import AvoidUNCPath
2512 with AvoidUNCPath() as path:
2512 with AvoidUNCPath() as path:
2513 if path is not None:
2513 if path is not None:
2514 cmd = '"pushd %s &&"%s' % (path, cmd)
2514 cmd = '"pushd %s &&"%s' % (path, cmd)
2515 try:
2515 try:
2516 ec = os.system(cmd)
2516 ec = os.system(cmd)
2517 except KeyboardInterrupt:
2517 except KeyboardInterrupt:
2518 print('\n' + self.get_exception_only(), file=sys.stderr)
2518 print('\n' + self.get_exception_only(), file=sys.stderr)
2519 ec = -2
2519 ec = -2
2520 else:
2520 else:
2521 # For posix the result of the subprocess.call() below is an exit
2521 # For posix the result of the subprocess.call() below is an exit
2522 # code, which by convention is zero for success, positive for
2522 # code, which by convention is zero for success, positive for
2523 # program failure. Exit codes above 128 are reserved for signals,
2523 # program failure. Exit codes above 128 are reserved for signals,
2524 # and the formula for converting a signal to an exit code is usually
2524 # and the formula for converting a signal to an exit code is usually
2525 # signal_number+128. To more easily differentiate between exit
2525 # signal_number+128. To more easily differentiate between exit
2526 # codes and signals, ipython uses negative numbers. For instance
2526 # codes and signals, ipython uses negative numbers. For instance
2527 # since control-c is signal 2 but exit code 130, ipython's
2527 # since control-c is signal 2 but exit code 130, ipython's
2528 # _exit_code variable will read -2. Note that some shells like
2528 # _exit_code variable will read -2. Note that some shells like
2529 # csh and fish don't follow sh/bash conventions for exit codes.
2529 # csh and fish don't follow sh/bash conventions for exit codes.
2530 executable = os.environ.get('SHELL', None)
2530 executable = os.environ.get('SHELL', None)
2531 try:
2531 try:
2532 # Use env shell instead of default /bin/sh
2532 # Use env shell instead of default /bin/sh
2533 ec = subprocess.call(cmd, shell=True, executable=executable)
2533 ec = subprocess.call(cmd, shell=True, executable=executable)
2534 except KeyboardInterrupt:
2534 except KeyboardInterrupt:
2535 # intercept control-C; a long traceback is not useful here
2535 # intercept control-C; a long traceback is not useful here
2536 print('\n' + self.get_exception_only(), file=sys.stderr)
2536 print('\n' + self.get_exception_only(), file=sys.stderr)
2537 ec = 130
2537 ec = 130
2538 if ec > 128:
2538 if ec > 128:
2539 ec = -(ec - 128)
2539 ec = -(ec - 128)
2540
2540
2541 # We explicitly do NOT return the subprocess status code, because
2541 # We explicitly do NOT return the subprocess status code, because
2542 # a non-None value would trigger :func:`sys.displayhook` calls.
2542 # a non-None value would trigger :func:`sys.displayhook` calls.
2543 # Instead, we store the exit_code in user_ns. Note the semantics
2543 # Instead, we store the exit_code in user_ns. Note the semantics
2544 # of _exit_code: for control-c, _exit_code == -signal.SIGNIT,
2544 # of _exit_code: for control-c, _exit_code == -signal.SIGNIT,
2545 # but raising SystemExit(_exit_code) will give status 254!
2545 # but raising SystemExit(_exit_code) will give status 254!
2546 self.user_ns['_exit_code'] = ec
2546 self.user_ns['_exit_code'] = ec
2547
2547
2548 # use piped system by default, because it is better behaved
2548 # use piped system by default, because it is better behaved
2549 system = system_piped
2549 system = system_piped
2550
2550
2551 def getoutput(self, cmd, split=True, depth=0):
2551 def getoutput(self, cmd, split=True, depth=0):
2552 """Get output (possibly including stderr) from a subprocess.
2552 """Get output (possibly including stderr) from a subprocess.
2553
2553
2554 Parameters
2554 Parameters
2555 ----------
2555 ----------
2556 cmd : str
2556 cmd : str
2557 Command to execute (can not end in '&', as background processes are
2557 Command to execute (can not end in '&', as background processes are
2558 not supported.
2558 not supported.
2559 split : bool, optional
2559 split : bool, optional
2560 If True, split the output into an IPython SList. Otherwise, an
2560 If True, split the output into an IPython SList. Otherwise, an
2561 IPython LSString is returned. These are objects similar to normal
2561 IPython LSString is returned. These are objects similar to normal
2562 lists and strings, with a few convenience attributes for easier
2562 lists and strings, with a few convenience attributes for easier
2563 manipulation of line-based output. You can use '?' on them for
2563 manipulation of line-based output. You can use '?' on them for
2564 details.
2564 details.
2565 depth : int, optional
2565 depth : int, optional
2566 How many frames above the caller are the local variables which should
2566 How many frames above the caller are the local variables which should
2567 be expanded in the command string? The default (0) assumes that the
2567 be expanded in the command string? The default (0) assumes that the
2568 expansion variables are in the stack frame calling this function.
2568 expansion variables are in the stack frame calling this function.
2569 """
2569 """
2570 if cmd.rstrip().endswith('&'):
2570 if cmd.rstrip().endswith('&'):
2571 # this is *far* from a rigorous test
2571 # this is *far* from a rigorous test
2572 raise OSError("Background processes not supported.")
2572 raise OSError("Background processes not supported.")
2573 out = getoutput(self.var_expand(cmd, depth=depth+1))
2573 out = getoutput(self.var_expand(cmd, depth=depth+1))
2574 if split:
2574 if split:
2575 out = SList(out.splitlines())
2575 out = SList(out.splitlines())
2576 else:
2576 else:
2577 out = LSString(out)
2577 out = LSString(out)
2578 return out
2578 return out
2579
2579
2580 #-------------------------------------------------------------------------
2580 #-------------------------------------------------------------------------
2581 # Things related to aliases
2581 # Things related to aliases
2582 #-------------------------------------------------------------------------
2582 #-------------------------------------------------------------------------
2583
2583
2584 def init_alias(self):
2584 def init_alias(self):
2585 self.alias_manager = AliasManager(shell=self, parent=self)
2585 self.alias_manager = AliasManager(shell=self, parent=self)
2586 self.configurables.append(self.alias_manager)
2586 self.configurables.append(self.alias_manager)
2587
2587
2588 #-------------------------------------------------------------------------
2588 #-------------------------------------------------------------------------
2589 # Things related to extensions
2589 # Things related to extensions
2590 #-------------------------------------------------------------------------
2590 #-------------------------------------------------------------------------
2591
2591
2592 def init_extension_manager(self):
2592 def init_extension_manager(self):
2593 self.extension_manager = ExtensionManager(shell=self, parent=self)
2593 self.extension_manager = ExtensionManager(shell=self, parent=self)
2594 self.configurables.append(self.extension_manager)
2594 self.configurables.append(self.extension_manager)
2595
2595
2596 #-------------------------------------------------------------------------
2596 #-------------------------------------------------------------------------
2597 # Things related to payloads
2597 # Things related to payloads
2598 #-------------------------------------------------------------------------
2598 #-------------------------------------------------------------------------
2599
2599
2600 def init_payload(self):
2600 def init_payload(self):
2601 self.payload_manager = PayloadManager(parent=self)
2601 self.payload_manager = PayloadManager(parent=self)
2602 self.configurables.append(self.payload_manager)
2602 self.configurables.append(self.payload_manager)
2603
2603
2604 #-------------------------------------------------------------------------
2604 #-------------------------------------------------------------------------
2605 # Things related to the prefilter
2605 # Things related to the prefilter
2606 #-------------------------------------------------------------------------
2606 #-------------------------------------------------------------------------
2607
2607
2608 def init_prefilter(self):
2608 def init_prefilter(self):
2609 self.prefilter_manager = PrefilterManager(shell=self, parent=self)
2609 self.prefilter_manager = PrefilterManager(shell=self, parent=self)
2610 self.configurables.append(self.prefilter_manager)
2610 self.configurables.append(self.prefilter_manager)
2611 # Ultimately this will be refactored in the new interpreter code, but
2611 # Ultimately this will be refactored in the new interpreter code, but
2612 # for now, we should expose the main prefilter method (there's legacy
2612 # for now, we should expose the main prefilter method (there's legacy
2613 # code out there that may rely on this).
2613 # code out there that may rely on this).
2614 self.prefilter = self.prefilter_manager.prefilter_lines
2614 self.prefilter = self.prefilter_manager.prefilter_lines
2615
2615
2616 def auto_rewrite_input(self, cmd):
2616 def auto_rewrite_input(self, cmd):
2617 """Print to the screen the rewritten form of the user's command.
2617 """Print to the screen the rewritten form of the user's command.
2618
2618
2619 This shows visual feedback by rewriting input lines that cause
2619 This shows visual feedback by rewriting input lines that cause
2620 automatic calling to kick in, like::
2620 automatic calling to kick in, like::
2621
2621
2622 /f x
2622 /f x
2623
2623
2624 into::
2624 into::
2625
2625
2626 ------> f(x)
2626 ------> f(x)
2627
2627
2628 after the user's input prompt. This helps the user understand that the
2628 after the user's input prompt. This helps the user understand that the
2629 input line was transformed automatically by IPython.
2629 input line was transformed automatically by IPython.
2630 """
2630 """
2631 if not self.show_rewritten_input:
2631 if not self.show_rewritten_input:
2632 return
2632 return
2633
2633
2634 # This is overridden in TerminalInteractiveShell to use fancy prompts
2634 # This is overridden in TerminalInteractiveShell to use fancy prompts
2635 print("------> " + cmd)
2635 print("------> " + cmd)
2636
2636
2637 #-------------------------------------------------------------------------
2637 #-------------------------------------------------------------------------
2638 # Things related to extracting values/expressions from kernel and user_ns
2638 # Things related to extracting values/expressions from kernel and user_ns
2639 #-------------------------------------------------------------------------
2639 #-------------------------------------------------------------------------
2640
2640
2641 def _user_obj_error(self):
2641 def _user_obj_error(self):
2642 """return simple exception dict
2642 """return simple exception dict
2643
2643
2644 for use in user_expressions
2644 for use in user_expressions
2645 """
2645 """
2646
2646
2647 etype, evalue, tb = self._get_exc_info()
2647 etype, evalue, tb = self._get_exc_info()
2648 stb = self.InteractiveTB.get_exception_only(etype, evalue)
2648 stb = self.InteractiveTB.get_exception_only(etype, evalue)
2649
2649
2650 exc_info = {
2650 exc_info = {
2651 u'status' : 'error',
2651 u'status' : 'error',
2652 u'traceback' : stb,
2652 u'traceback' : stb,
2653 u'ename' : etype.__name__,
2653 u'ename' : etype.__name__,
2654 u'evalue' : py3compat.safe_unicode(evalue),
2654 u'evalue' : py3compat.safe_unicode(evalue),
2655 }
2655 }
2656
2656
2657 return exc_info
2657 return exc_info
2658
2658
2659 def _format_user_obj(self, obj):
2659 def _format_user_obj(self, obj):
2660 """format a user object to display dict
2660 """format a user object to display dict
2661
2661
2662 for use in user_expressions
2662 for use in user_expressions
2663 """
2663 """
2664
2664
2665 data, md = self.display_formatter.format(obj)
2665 data, md = self.display_formatter.format(obj)
2666 value = {
2666 value = {
2667 'status' : 'ok',
2667 'status' : 'ok',
2668 'data' : data,
2668 'data' : data,
2669 'metadata' : md,
2669 'metadata' : md,
2670 }
2670 }
2671 return value
2671 return value
2672
2672
2673 def user_expressions(self, expressions):
2673 def user_expressions(self, expressions):
2674 """Evaluate a dict of expressions in the user's namespace.
2674 """Evaluate a dict of expressions in the user's namespace.
2675
2675
2676 Parameters
2676 Parameters
2677 ----------
2677 ----------
2678 expressions : dict
2678 expressions : dict
2679 A dict with string keys and string values. The expression values
2679 A dict with string keys and string values. The expression values
2680 should be valid Python expressions, each of which will be evaluated
2680 should be valid Python expressions, each of which will be evaluated
2681 in the user namespace.
2681 in the user namespace.
2682
2682
2683 Returns
2683 Returns
2684 -------
2684 -------
2685 A dict, keyed like the input expressions dict, with the rich mime-typed
2685 A dict, keyed like the input expressions dict, with the rich mime-typed
2686 display_data of each value.
2686 display_data of each value.
2687 """
2687 """
2688 out = {}
2688 out = {}
2689 user_ns = self.user_ns
2689 user_ns = self.user_ns
2690 global_ns = self.user_global_ns
2690 global_ns = self.user_global_ns
2691
2691
2692 for key, expr in expressions.items():
2692 for key, expr in expressions.items():
2693 try:
2693 try:
2694 value = self._format_user_obj(eval(expr, global_ns, user_ns))
2694 value = self._format_user_obj(eval(expr, global_ns, user_ns))
2695 except:
2695 except:
2696 value = self._user_obj_error()
2696 value = self._user_obj_error()
2697 out[key] = value
2697 out[key] = value
2698 return out
2698 return out
2699
2699
2700 #-------------------------------------------------------------------------
2700 #-------------------------------------------------------------------------
2701 # Things related to the running of code
2701 # Things related to the running of code
2702 #-------------------------------------------------------------------------
2702 #-------------------------------------------------------------------------
2703
2703
2704 def ex(self, cmd):
2704 def ex(self, cmd):
2705 """Execute a normal python statement in user namespace."""
2705 """Execute a normal python statement in user namespace."""
2706 with self.builtin_trap:
2706 with self.builtin_trap:
2707 exec(cmd, self.user_global_ns, self.user_ns)
2707 exec(cmd, self.user_global_ns, self.user_ns)
2708
2708
2709 def ev(self, expr):
2709 def ev(self, expr):
2710 """Evaluate python expression expr in user namespace.
2710 """Evaluate python expression expr in user namespace.
2711
2711
2712 Returns the result of evaluation
2712 Returns the result of evaluation
2713 """
2713 """
2714 with self.builtin_trap:
2714 with self.builtin_trap:
2715 return eval(expr, self.user_global_ns, self.user_ns)
2715 return eval(expr, self.user_global_ns, self.user_ns)
2716
2716
2717 def safe_execfile(self, fname, *where, exit_ignore=False, raise_exceptions=False, shell_futures=False):
2717 def safe_execfile(self, fname, *where, exit_ignore=False, raise_exceptions=False, shell_futures=False):
2718 """A safe version of the builtin execfile().
2718 """A safe version of the builtin execfile().
2719
2719
2720 This version will never throw an exception, but instead print
2720 This version will never throw an exception, but instead print
2721 helpful error messages to the screen. This only works on pure
2721 helpful error messages to the screen. This only works on pure
2722 Python files with the .py extension.
2722 Python files with the .py extension.
2723
2723
2724 Parameters
2724 Parameters
2725 ----------
2725 ----------
2726 fname : string
2726 fname : string
2727 The name of the file to be executed.
2727 The name of the file to be executed.
2728 where : tuple
2728 where : tuple
2729 One or two namespaces, passed to execfile() as (globals,locals).
2729 One or two namespaces, passed to execfile() as (globals,locals).
2730 If only one is given, it is passed as both.
2730 If only one is given, it is passed as both.
2731 exit_ignore : bool (False)
2731 exit_ignore : bool (False)
2732 If True, then silence SystemExit for non-zero status (it is always
2732 If True, then silence SystemExit for non-zero status (it is always
2733 silenced for zero status, as it is so common).
2733 silenced for zero status, as it is so common).
2734 raise_exceptions : bool (False)
2734 raise_exceptions : bool (False)
2735 If True raise exceptions everywhere. Meant for testing.
2735 If True raise exceptions everywhere. Meant for testing.
2736 shell_futures : bool (False)
2736 shell_futures : bool (False)
2737 If True, the code will share future statements with the interactive
2737 If True, the code will share future statements with the interactive
2738 shell. It will both be affected by previous __future__ imports, and
2738 shell. It will both be affected by previous __future__ imports, and
2739 any __future__ imports in the code will affect the shell. If False,
2739 any __future__ imports in the code will affect the shell. If False,
2740 __future__ imports are not shared in either direction.
2740 __future__ imports are not shared in either direction.
2741
2741
2742 """
2742 """
2743 fname = os.path.abspath(os.path.expanduser(fname))
2743 fname = os.path.abspath(os.path.expanduser(fname))
2744
2744
2745 # Make sure we can open the file
2745 # Make sure we can open the file
2746 try:
2746 try:
2747 with open(fname):
2747 with open(fname):
2748 pass
2748 pass
2749 except:
2749 except:
2750 warn('Could not open file <%s> for safe execution.' % fname)
2750 warn('Could not open file <%s> for safe execution.' % fname)
2751 return
2751 return
2752
2752
2753 # Find things also in current directory. This is needed to mimic the
2753 # Find things also in current directory. This is needed to mimic the
2754 # behavior of running a script from the system command line, where
2754 # behavior of running a script from the system command line, where
2755 # Python inserts the script's directory into sys.path
2755 # Python inserts the script's directory into sys.path
2756 dname = os.path.dirname(fname)
2756 dname = os.path.dirname(fname)
2757
2757
2758 with prepended_to_syspath(dname), self.builtin_trap:
2758 with prepended_to_syspath(dname), self.builtin_trap:
2759 try:
2759 try:
2760 glob, loc = (where + (None, ))[:2]
2760 glob, loc = (where + (None, ))[:2]
2761 py3compat.execfile(
2761 py3compat.execfile(
2762 fname, glob, loc,
2762 fname, glob, loc,
2763 self.compile if shell_futures else None)
2763 self.compile if shell_futures else None)
2764 except SystemExit as status:
2764 except SystemExit as status:
2765 # If the call was made with 0 or None exit status (sys.exit(0)
2765 # If the call was made with 0 or None exit status (sys.exit(0)
2766 # or sys.exit() ), don't bother showing a traceback, as both of
2766 # or sys.exit() ), don't bother showing a traceback, as both of
2767 # these are considered normal by the OS:
2767 # these are considered normal by the OS:
2768 # > python -c'import sys;sys.exit(0)'; echo $?
2768 # > python -c'import sys;sys.exit(0)'; echo $?
2769 # 0
2769 # 0
2770 # > python -c'import sys;sys.exit()'; echo $?
2770 # > python -c'import sys;sys.exit()'; echo $?
2771 # 0
2771 # 0
2772 # For other exit status, we show the exception unless
2772 # For other exit status, we show the exception unless
2773 # explicitly silenced, but only in short form.
2773 # explicitly silenced, but only in short form.
2774 if status.code:
2774 if status.code:
2775 if raise_exceptions:
2775 if raise_exceptions:
2776 raise
2776 raise
2777 if not exit_ignore:
2777 if not exit_ignore:
2778 self.showtraceback(exception_only=True)
2778 self.showtraceback(exception_only=True)
2779 except:
2779 except:
2780 if raise_exceptions:
2780 if raise_exceptions:
2781 raise
2781 raise
2782 # tb offset is 2 because we wrap execfile
2782 # tb offset is 2 because we wrap execfile
2783 self.showtraceback(tb_offset=2)
2783 self.showtraceback(tb_offset=2)
2784
2784
2785 def safe_execfile_ipy(self, fname, shell_futures=False, raise_exceptions=False):
2785 def safe_execfile_ipy(self, fname, shell_futures=False, raise_exceptions=False):
2786 """Like safe_execfile, but for .ipy or .ipynb files with IPython syntax.
2786 """Like safe_execfile, but for .ipy or .ipynb files with IPython syntax.
2787
2787
2788 Parameters
2788 Parameters
2789 ----------
2789 ----------
2790 fname : str
2790 fname : str
2791 The name of the file to execute. The filename must have a
2791 The name of the file to execute. The filename must have a
2792 .ipy or .ipynb extension.
2792 .ipy or .ipynb extension.
2793 shell_futures : bool (False)
2793 shell_futures : bool (False)
2794 If True, the code will share future statements with the interactive
2794 If True, the code will share future statements with the interactive
2795 shell. It will both be affected by previous __future__ imports, and
2795 shell. It will both be affected by previous __future__ imports, and
2796 any __future__ imports in the code will affect the shell. If False,
2796 any __future__ imports in the code will affect the shell. If False,
2797 __future__ imports are not shared in either direction.
2797 __future__ imports are not shared in either direction.
2798 raise_exceptions : bool (False)
2798 raise_exceptions : bool (False)
2799 If True raise exceptions everywhere. Meant for testing.
2799 If True raise exceptions everywhere. Meant for testing.
2800 """
2800 """
2801 fname = os.path.abspath(os.path.expanduser(fname))
2801 fname = os.path.abspath(os.path.expanduser(fname))
2802
2802
2803 # Make sure we can open the file
2803 # Make sure we can open the file
2804 try:
2804 try:
2805 with open(fname):
2805 with open(fname):
2806 pass
2806 pass
2807 except:
2807 except:
2808 warn('Could not open file <%s> for safe execution.' % fname)
2808 warn('Could not open file <%s> for safe execution.' % fname)
2809 return
2809 return
2810
2810
2811 # Find things also in current directory. This is needed to mimic the
2811 # Find things also in current directory. This is needed to mimic the
2812 # behavior of running a script from the system command line, where
2812 # behavior of running a script from the system command line, where
2813 # Python inserts the script's directory into sys.path
2813 # Python inserts the script's directory into sys.path
2814 dname = os.path.dirname(fname)
2814 dname = os.path.dirname(fname)
2815
2815
2816 def get_cells():
2816 def get_cells():
2817 """generator for sequence of code blocks to run"""
2817 """generator for sequence of code blocks to run"""
2818 if fname.endswith('.ipynb'):
2818 if fname.endswith('.ipynb'):
2819 from nbformat import read
2819 from nbformat import read
2820 nb = read(fname, as_version=4)
2820 nb = read(fname, as_version=4)
2821 if not nb.cells:
2821 if not nb.cells:
2822 return
2822 return
2823 for cell in nb.cells:
2823 for cell in nb.cells:
2824 if cell.cell_type == 'code':
2824 if cell.cell_type == 'code':
2825 yield cell.source
2825 yield cell.source
2826 else:
2826 else:
2827 with open(fname) as f:
2827 with open(fname) as f:
2828 yield f.read()
2828 yield f.read()
2829
2829
2830 with prepended_to_syspath(dname):
2830 with prepended_to_syspath(dname):
2831 try:
2831 try:
2832 for cell in get_cells():
2832 for cell in get_cells():
2833 result = self.run_cell(cell, silent=True, shell_futures=shell_futures)
2833 result = self.run_cell(cell, silent=True, shell_futures=shell_futures)
2834 if raise_exceptions:
2834 if raise_exceptions:
2835 result.raise_error()
2835 result.raise_error()
2836 elif not result.success:
2836 elif not result.success:
2837 break
2837 break
2838 except:
2838 except:
2839 if raise_exceptions:
2839 if raise_exceptions:
2840 raise
2840 raise
2841 self.showtraceback()
2841 self.showtraceback()
2842 warn('Unknown failure executing file: <%s>' % fname)
2842 warn('Unknown failure executing file: <%s>' % fname)
2843
2843
2844 def safe_run_module(self, mod_name, where):
2844 def safe_run_module(self, mod_name, where):
2845 """A safe version of runpy.run_module().
2845 """A safe version of runpy.run_module().
2846
2846
2847 This version will never throw an exception, but instead print
2847 This version will never throw an exception, but instead print
2848 helpful error messages to the screen.
2848 helpful error messages to the screen.
2849
2849
2850 `SystemExit` exceptions with status code 0 or None are ignored.
2850 `SystemExit` exceptions with status code 0 or None are ignored.
2851
2851
2852 Parameters
2852 Parameters
2853 ----------
2853 ----------
2854 mod_name : string
2854 mod_name : string
2855 The name of the module to be executed.
2855 The name of the module to be executed.
2856 where : dict
2856 where : dict
2857 The globals namespace.
2857 The globals namespace.
2858 """
2858 """
2859 try:
2859 try:
2860 try:
2860 try:
2861 where.update(
2861 where.update(
2862 runpy.run_module(str(mod_name), run_name="__main__",
2862 runpy.run_module(str(mod_name), run_name="__main__",
2863 alter_sys=True)
2863 alter_sys=True)
2864 )
2864 )
2865 except SystemExit as status:
2865 except SystemExit as status:
2866 if status.code:
2866 if status.code:
2867 raise
2867 raise
2868 except:
2868 except:
2869 self.showtraceback()
2869 self.showtraceback()
2870 warn('Unknown failure executing module: <%s>' % mod_name)
2870 warn('Unknown failure executing module: <%s>' % mod_name)
2871
2871
2872 def run_cell(self, raw_cell, store_history=False, silent=False, shell_futures=True):
2872 def run_cell(self, raw_cell, store_history=False, silent=False, shell_futures=True):
2873 """Run a complete IPython cell.
2873 """Run a complete IPython cell.
2874
2874
2875 Parameters
2875 Parameters
2876 ----------
2876 ----------
2877 raw_cell : str
2877 raw_cell : str
2878 The code (including IPython code such as %magic functions) to run.
2878 The code (including IPython code such as %magic functions) to run.
2879 store_history : bool
2879 store_history : bool
2880 If True, the raw and translated cell will be stored in IPython's
2880 If True, the raw and translated cell will be stored in IPython's
2881 history. For user code calling back into IPython's machinery, this
2881 history. For user code calling back into IPython's machinery, this
2882 should be set to False.
2882 should be set to False.
2883 silent : bool
2883 silent : bool
2884 If True, avoid side-effects, such as implicit displayhooks and
2884 If True, avoid side-effects, such as implicit displayhooks and
2885 and logging. silent=True forces store_history=False.
2885 and logging. silent=True forces store_history=False.
2886 shell_futures : bool
2886 shell_futures : bool
2887 If True, the code will share future statements with the interactive
2887 If True, the code will share future statements with the interactive
2888 shell. It will both be affected by previous __future__ imports, and
2888 shell. It will both be affected by previous __future__ imports, and
2889 any __future__ imports in the code will affect the shell. If False,
2889 any __future__ imports in the code will affect the shell. If False,
2890 __future__ imports are not shared in either direction.
2890 __future__ imports are not shared in either direction.
2891
2891
2892 Returns
2892 Returns
2893 -------
2893 -------
2894 result : :class:`ExecutionResult`
2894 result : :class:`ExecutionResult`
2895 """
2895 """
2896 result = None
2896 result = None
2897 try:
2897 try:
2898 result = self._run_cell(
2898 result = self._run_cell(
2899 raw_cell, store_history, silent, shell_futures)
2899 raw_cell, store_history, silent, shell_futures)
2900 finally:
2900 finally:
2901 self.events.trigger('post_execute')
2901 self.events.trigger('post_execute')
2902 if not silent:
2902 if not silent:
2903 self.events.trigger('post_run_cell', result)
2903 self.events.trigger('post_run_cell', result)
2904 return result
2904 return result
2905
2905
2906 def _run_cell(self, raw_cell:str, store_history:bool, silent:bool, shell_futures:bool):
2906 def _run_cell(self, raw_cell:str, store_history:bool, silent:bool, shell_futures:bool):
2907 """Internal method to run a complete IPython cell."""
2907 """Internal method to run a complete IPython cell."""
2908
2908
2909 # we need to avoid calling self.transform_cell multiple time on the same thing
2909 # we need to avoid calling self.transform_cell multiple time on the same thing
2910 # so we need to store some results:
2910 # so we need to store some results:
2911 preprocessing_exc_tuple = None
2911 preprocessing_exc_tuple = None
2912 try:
2912 try:
2913 transformed_cell = self.transform_cell(raw_cell)
2913 transformed_cell = self.transform_cell(raw_cell)
2914 except Exception:
2914 except Exception:
2915 transformed_cell = raw_cell
2915 transformed_cell = raw_cell
2916 preprocessing_exc_tuple = sys.exc_info()
2916 preprocessing_exc_tuple = sys.exc_info()
2917
2917
2918 assert transformed_cell is not None
2918 assert transformed_cell is not None
2919 coro = self.run_cell_async(
2919 coro = self.run_cell_async(
2920 raw_cell,
2920 raw_cell,
2921 store_history=store_history,
2921 store_history=store_history,
2922 silent=silent,
2922 silent=silent,
2923 shell_futures=shell_futures,
2923 shell_futures=shell_futures,
2924 transformed_cell=transformed_cell,
2924 transformed_cell=transformed_cell,
2925 preprocessing_exc_tuple=preprocessing_exc_tuple,
2925 preprocessing_exc_tuple=preprocessing_exc_tuple,
2926 )
2926 )
2927
2927
2928 # run_cell_async is async, but may not actually need an eventloop.
2928 # run_cell_async is async, but may not actually need an eventloop.
2929 # when this is the case, we want to run it using the pseudo_sync_runner
2929 # when this is the case, we want to run it using the pseudo_sync_runner
2930 # so that code can invoke eventloops (for example via the %run , and
2930 # so that code can invoke eventloops (for example via the %run , and
2931 # `%paste` magic.
2931 # `%paste` magic.
2932 if self.trio_runner:
2932 if self.trio_runner:
2933 runner = self.trio_runner
2933 runner = self.trio_runner
2934 elif self.should_run_async(
2934 elif self.should_run_async(
2935 raw_cell,
2935 raw_cell,
2936 transformed_cell=transformed_cell,
2936 transformed_cell=transformed_cell,
2937 preprocessing_exc_tuple=preprocessing_exc_tuple,
2937 preprocessing_exc_tuple=preprocessing_exc_tuple,
2938 ):
2938 ):
2939 runner = self.loop_runner
2939 runner = self.loop_runner
2940 else:
2940 else:
2941 runner = _pseudo_sync_runner
2941 runner = _pseudo_sync_runner
2942
2942
2943 try:
2943 try:
2944 return runner(coro)
2944 return runner(coro)
2945 except BaseException as e:
2945 except BaseException as e:
2946 info = ExecutionInfo(raw_cell, store_history, silent, shell_futures)
2946 info = ExecutionInfo(raw_cell, store_history, silent, shell_futures)
2947 result = ExecutionResult(info)
2947 result = ExecutionResult(info)
2948 result.error_in_exec = e
2948 result.error_in_exec = e
2949 self.showtraceback(running_compiled_code=True)
2949 self.showtraceback(running_compiled_code=True)
2950 return result
2950 return result
2951 return
2951 return
2952
2952
2953 def should_run_async(
2953 def should_run_async(
2954 self, raw_cell: str, *, transformed_cell=None, preprocessing_exc_tuple=None
2954 self, raw_cell: str, *, transformed_cell=None, preprocessing_exc_tuple=None
2955 ) -> bool:
2955 ) -> bool:
2956 """Return whether a cell should be run asynchronously via a coroutine runner
2956 """Return whether a cell should be run asynchronously via a coroutine runner
2957
2957
2958 Parameters
2958 Parameters
2959 ----------
2959 ----------
2960 raw_cell: str
2960 raw_cell: str
2961 The code to be executed
2961 The code to be executed
2962
2962
2963 Returns
2963 Returns
2964 -------
2964 -------
2965 result: bool
2965 result: bool
2966 Whether the code needs to be run with a coroutine runner or not
2966 Whether the code needs to be run with a coroutine runner or not
2967
2967
2968 .. versionadded: 7.0
2968 .. versionadded: 7.0
2969 """
2969 """
2970 if not self.autoawait:
2970 if not self.autoawait:
2971 return False
2971 return False
2972 if preprocessing_exc_tuple is not None:
2972 if preprocessing_exc_tuple is not None:
2973 return False
2973 return False
2974 assert preprocessing_exc_tuple is None
2974 assert preprocessing_exc_tuple is None
2975 if transformed_cell is None:
2975 if transformed_cell is None:
2976 warnings.warn(
2976 warnings.warn(
2977 "`should_run_async` will not call `transform_cell`"
2977 "`should_run_async` will not call `transform_cell`"
2978 " automatically in the future. Please pass the result to"
2978 " automatically in the future. Please pass the result to"
2979 " `transformed_cell` argument and any exception that happen"
2979 " `transformed_cell` argument and any exception that happen"
2980 " during the"
2980 " during the"
2981 "transform in `preprocessing_exc_tuple` in"
2981 "transform in `preprocessing_exc_tuple` in"
2982 " IPython 7.17 and above.",
2982 " IPython 7.17 and above.",
2983 DeprecationWarning,
2983 DeprecationWarning,
2984 stacklevel=2,
2984 stacklevel=2,
2985 )
2985 )
2986 try:
2986 try:
2987 cell = self.transform_cell(raw_cell)
2987 cell = self.transform_cell(raw_cell)
2988 except Exception:
2988 except Exception:
2989 # any exception during transform will be raised
2989 # any exception during transform will be raised
2990 # prior to execution
2990 # prior to execution
2991 return False
2991 return False
2992 else:
2992 else:
2993 cell = transformed_cell
2993 cell = transformed_cell
2994 return _should_be_async(cell)
2994 return _should_be_async(cell)
2995
2995
2996 async def run_cell_async(
2996 async def run_cell_async(
2997 self,
2997 self,
2998 raw_cell: str,
2998 raw_cell: str,
2999 store_history=False,
2999 store_history=False,
3000 silent=False,
3000 silent=False,
3001 shell_futures=True,
3001 shell_futures=True,
3002 *,
3002 *,
3003 transformed_cell: Optional[str] = None,
3003 transformed_cell: Optional[str] = None,
3004 preprocessing_exc_tuple: Optional[Any] = None
3004 preprocessing_exc_tuple: Optional[Any] = None
3005 ) -> ExecutionResult:
3005 ) -> ExecutionResult:
3006 """Run a complete IPython cell asynchronously.
3006 """Run a complete IPython cell asynchronously.
3007
3007
3008 Parameters
3008 Parameters
3009 ----------
3009 ----------
3010 raw_cell : str
3010 raw_cell : str
3011 The code (including IPython code such as %magic functions) to run.
3011 The code (including IPython code such as %magic functions) to run.
3012 store_history : bool
3012 store_history : bool
3013 If True, the raw and translated cell will be stored in IPython's
3013 If True, the raw and translated cell will be stored in IPython's
3014 history. For user code calling back into IPython's machinery, this
3014 history. For user code calling back into IPython's machinery, this
3015 should be set to False.
3015 should be set to False.
3016 silent : bool
3016 silent : bool
3017 If True, avoid side-effects, such as implicit displayhooks and
3017 If True, avoid side-effects, such as implicit displayhooks and
3018 and logging. silent=True forces store_history=False.
3018 and logging. silent=True forces store_history=False.
3019 shell_futures : bool
3019 shell_futures : bool
3020 If True, the code will share future statements with the interactive
3020 If True, the code will share future statements with the interactive
3021 shell. It will both be affected by previous __future__ imports, and
3021 shell. It will both be affected by previous __future__ imports, and
3022 any __future__ imports in the code will affect the shell. If False,
3022 any __future__ imports in the code will affect the shell. If False,
3023 __future__ imports are not shared in either direction.
3023 __future__ imports are not shared in either direction.
3024 transformed_cell: str
3024 transformed_cell: str
3025 cell that was passed through transformers
3025 cell that was passed through transformers
3026 preprocessing_exc_tuple:
3026 preprocessing_exc_tuple:
3027 trace if the transformation failed.
3027 trace if the transformation failed.
3028
3028
3029 Returns
3029 Returns
3030 -------
3030 -------
3031 result : :class:`ExecutionResult`
3031 result : :class:`ExecutionResult`
3032
3032
3033 .. versionadded: 7.0
3033 .. versionadded: 7.0
3034 """
3034 """
3035 info = ExecutionInfo(
3035 info = ExecutionInfo(
3036 raw_cell, store_history, silent, shell_futures)
3036 raw_cell, store_history, silent, shell_futures)
3037 result = ExecutionResult(info)
3037 result = ExecutionResult(info)
3038
3038
3039 if (not raw_cell) or raw_cell.isspace():
3039 if (not raw_cell) or raw_cell.isspace():
3040 self.last_execution_succeeded = True
3040 self.last_execution_succeeded = True
3041 self.last_execution_result = result
3041 self.last_execution_result = result
3042 return result
3042 return result
3043
3043
3044 if silent:
3044 if silent:
3045 store_history = False
3045 store_history = False
3046
3046
3047 if store_history:
3047 if store_history:
3048 result.execution_count = self.execution_count
3048 result.execution_count = self.execution_count
3049
3049
3050 def error_before_exec(value):
3050 def error_before_exec(value):
3051 if store_history:
3051 if store_history:
3052 self.execution_count += 1
3052 self.execution_count += 1
3053 result.error_before_exec = value
3053 result.error_before_exec = value
3054 self.last_execution_succeeded = False
3054 self.last_execution_succeeded = False
3055 self.last_execution_result = result
3055 self.last_execution_result = result
3056 return result
3056 return result
3057
3057
3058 self.events.trigger('pre_execute')
3058 self.events.trigger('pre_execute')
3059 if not silent:
3059 if not silent:
3060 self.events.trigger('pre_run_cell', info)
3060 self.events.trigger('pre_run_cell', info)
3061
3061
3062 if transformed_cell is None:
3062 if transformed_cell is None:
3063 warnings.warn(
3063 warnings.warn(
3064 "`run_cell_async` will not call `transform_cell`"
3064 "`run_cell_async` will not call `transform_cell`"
3065 " automatically in the future. Please pass the result to"
3065 " automatically in the future. Please pass the result to"
3066 " `transformed_cell` argument and any exception that happen"
3066 " `transformed_cell` argument and any exception that happen"
3067 " during the"
3067 " during the"
3068 "transform in `preprocessing_exc_tuple` in"
3068 "transform in `preprocessing_exc_tuple` in"
3069 " IPython 7.17 and above.",
3069 " IPython 7.17 and above.",
3070 DeprecationWarning,
3070 DeprecationWarning,
3071 stacklevel=2,
3071 stacklevel=2,
3072 )
3072 )
3073 # If any of our input transformation (input_transformer_manager or
3073 # If any of our input transformation (input_transformer_manager or
3074 # prefilter_manager) raises an exception, we store it in this variable
3074 # prefilter_manager) raises an exception, we store it in this variable
3075 # so that we can display the error after logging the input and storing
3075 # so that we can display the error after logging the input and storing
3076 # it in the history.
3076 # it in the history.
3077 try:
3077 try:
3078 cell = self.transform_cell(raw_cell)
3078 cell = self.transform_cell(raw_cell)
3079 except Exception:
3079 except Exception:
3080 preprocessing_exc_tuple = sys.exc_info()
3080 preprocessing_exc_tuple = sys.exc_info()
3081 cell = raw_cell # cell has to exist so it can be stored/logged
3081 cell = raw_cell # cell has to exist so it can be stored/logged
3082 else:
3082 else:
3083 preprocessing_exc_tuple = None
3083 preprocessing_exc_tuple = None
3084 else:
3084 else:
3085 if preprocessing_exc_tuple is None:
3085 if preprocessing_exc_tuple is None:
3086 cell = transformed_cell
3086 cell = transformed_cell
3087 else:
3087 else:
3088 cell = raw_cell
3088 cell = raw_cell
3089
3089
3090 # Store raw and processed history
3090 # Store raw and processed history
3091 if store_history:
3091 if store_history:
3092 self.history_manager.store_inputs(self.execution_count,
3092 self.history_manager.store_inputs(self.execution_count,
3093 cell, raw_cell)
3093 cell, raw_cell)
3094 if not silent:
3094 if not silent:
3095 self.logger.log(cell, raw_cell)
3095 self.logger.log(cell, raw_cell)
3096
3096
3097 # Display the exception if input processing failed.
3097 # Display the exception if input processing failed.
3098 if preprocessing_exc_tuple is not None:
3098 if preprocessing_exc_tuple is not None:
3099 self.showtraceback(preprocessing_exc_tuple)
3099 self.showtraceback(preprocessing_exc_tuple)
3100 if store_history:
3100 if store_history:
3101 self.execution_count += 1
3101 self.execution_count += 1
3102 return error_before_exec(preprocessing_exc_tuple[1])
3102 return error_before_exec(preprocessing_exc_tuple[1])
3103
3103
3104 # Our own compiler remembers the __future__ environment. If we want to
3104 # Our own compiler remembers the __future__ environment. If we want to
3105 # run code with a separate __future__ environment, use the default
3105 # run code with a separate __future__ environment, use the default
3106 # compiler
3106 # compiler
3107 compiler = self.compile if shell_futures else self.compiler_class()
3107 compiler = self.compile if shell_futures else self.compiler_class()
3108
3108
3109 _run_async = False
3109 _run_async = False
3110
3110
3111 with self.builtin_trap:
3111 with self.builtin_trap:
3112 cell_name = self.compile.cache(
3112 cell_name = self.compile.cache(
3113 cell, self.execution_count, raw_code=raw_cell
3113 cell, self.execution_count, raw_code=raw_cell
3114 )
3114 )
3115
3115
3116 with self.display_trap:
3116 with self.display_trap:
3117 # Compile to bytecode
3117 # Compile to bytecode
3118 try:
3118 try:
3119 if sys.version_info < (3,8) and self.autoawait:
3119 if sys.version_info < (3,8) and self.autoawait:
3120 if _should_be_async(cell):
3120 if _should_be_async(cell):
3121 # the code AST below will not be user code: we wrap it
3121 # the code AST below will not be user code: we wrap it
3122 # in an `async def`. This will likely make some AST
3122 # in an `async def`. This will likely make some AST
3123 # transformer below miss some transform opportunity and
3123 # transformer below miss some transform opportunity and
3124 # introduce a small coupling to run_code (in which we
3124 # introduce a small coupling to run_code (in which we
3125 # bake some assumptions of what _ast_asyncify returns.
3125 # bake some assumptions of what _ast_asyncify returns.
3126 # they are ways around (like grafting part of the ast
3126 # they are ways around (like grafting part of the ast
3127 # later:
3127 # later:
3128 # - Here, return code_ast.body[0].body[1:-1], as well
3128 # - Here, return code_ast.body[0].body[1:-1], as well
3129 # as last expression in return statement which is
3129 # as last expression in return statement which is
3130 # the user code part.
3130 # the user code part.
3131 # - Let it go through the AST transformers, and graft
3131 # - Let it go through the AST transformers, and graft
3132 # - it back after the AST transform
3132 # - it back after the AST transform
3133 # But that seem unreasonable, at least while we
3133 # But that seem unreasonable, at least while we
3134 # do not need it.
3134 # do not need it.
3135 code_ast = _ast_asyncify(cell, 'async-def-wrapper')
3135 code_ast = _ast_asyncify(cell, 'async-def-wrapper')
3136 _run_async = True
3136 _run_async = True
3137 else:
3137 else:
3138 code_ast = compiler.ast_parse(cell, filename=cell_name)
3138 code_ast = compiler.ast_parse(cell, filename=cell_name)
3139 else:
3139 else:
3140 code_ast = compiler.ast_parse(cell, filename=cell_name)
3140 code_ast = compiler.ast_parse(cell, filename=cell_name)
3141 except self.custom_exceptions as e:
3141 except self.custom_exceptions as e:
3142 etype, value, tb = sys.exc_info()
3142 etype, value, tb = sys.exc_info()
3143 self.CustomTB(etype, value, tb)
3143 self.CustomTB(etype, value, tb)
3144 return error_before_exec(e)
3144 return error_before_exec(e)
3145 except IndentationError as e:
3145 except IndentationError as e:
3146 self.showindentationerror()
3146 self.showindentationerror()
3147 return error_before_exec(e)
3147 return error_before_exec(e)
3148 except (OverflowError, SyntaxError, ValueError, TypeError,
3148 except (OverflowError, SyntaxError, ValueError, TypeError,
3149 MemoryError) as e:
3149 MemoryError) as e:
3150 self.showsyntaxerror()
3150 self.showsyntaxerror()
3151 return error_before_exec(e)
3151 return error_before_exec(e)
3152
3152
3153 # Apply AST transformations
3153 # Apply AST transformations
3154 try:
3154 try:
3155 code_ast = self.transform_ast(code_ast)
3155 code_ast = self.transform_ast(code_ast)
3156 except InputRejected as e:
3156 except InputRejected as e:
3157 self.showtraceback()
3157 self.showtraceback()
3158 return error_before_exec(e)
3158 return error_before_exec(e)
3159
3159
3160 # Give the displayhook a reference to our ExecutionResult so it
3160 # Give the displayhook a reference to our ExecutionResult so it
3161 # can fill in the output value.
3161 # can fill in the output value.
3162 self.displayhook.exec_result = result
3162 self.displayhook.exec_result = result
3163
3163
3164 # Execute the user code
3164 # Execute the user code
3165 interactivity = "none" if silent else self.ast_node_interactivity
3165 interactivity = "none" if silent else self.ast_node_interactivity
3166 if _run_async:
3166 if _run_async:
3167 interactivity = 'async'
3167 interactivity = 'async'
3168
3168
3169 has_raised = await self.run_ast_nodes(code_ast.body, cell_name,
3169 has_raised = await self.run_ast_nodes(code_ast.body, cell_name,
3170 interactivity=interactivity, compiler=compiler, result=result)
3170 interactivity=interactivity, compiler=compiler, result=result)
3171
3171
3172 self.last_execution_succeeded = not has_raised
3172 self.last_execution_succeeded = not has_raised
3173 self.last_execution_result = result
3173 self.last_execution_result = result
3174
3174
3175 # Reset this so later displayed values do not modify the
3175 # Reset this so later displayed values do not modify the
3176 # ExecutionResult
3176 # ExecutionResult
3177 self.displayhook.exec_result = None
3177 self.displayhook.exec_result = None
3178
3178
3179 if store_history:
3179 if store_history:
3180 # Write output to the database. Does nothing unless
3180 # Write output to the database. Does nothing unless
3181 # history output logging is enabled.
3181 # history output logging is enabled.
3182 self.history_manager.store_output(self.execution_count)
3182 self.history_manager.store_output(self.execution_count)
3183 # Each cell is a *single* input, regardless of how many lines it has
3183 # Each cell is a *single* input, regardless of how many lines it has
3184 self.execution_count += 1
3184 self.execution_count += 1
3185
3185
3186 return result
3186 return result
3187
3187
3188 def transform_cell(self, raw_cell):
3188 def transform_cell(self, raw_cell):
3189 """Transform an input cell before parsing it.
3189 """Transform an input cell before parsing it.
3190
3190
3191 Static transformations, implemented in IPython.core.inputtransformer2,
3191 Static transformations, implemented in IPython.core.inputtransformer2,
3192 deal with things like ``%magic`` and ``!system`` commands.
3192 deal with things like ``%magic`` and ``!system`` commands.
3193 These run on all input.
3193 These run on all input.
3194 Dynamic transformations, for things like unescaped magics and the exit
3194 Dynamic transformations, for things like unescaped magics and the exit
3195 autocall, depend on the state of the interpreter.
3195 autocall, depend on the state of the interpreter.
3196 These only apply to single line inputs.
3196 These only apply to single line inputs.
3197
3197
3198 These string-based transformations are followed by AST transformations;
3198 These string-based transformations are followed by AST transformations;
3199 see :meth:`transform_ast`.
3199 see :meth:`transform_ast`.
3200 """
3200 """
3201 # Static input transformations
3201 # Static input transformations
3202 cell = self.input_transformer_manager.transform_cell(raw_cell)
3202 cell = self.input_transformer_manager.transform_cell(raw_cell)
3203
3203
3204 if len(cell.splitlines()) == 1:
3204 if len(cell.splitlines()) == 1:
3205 # Dynamic transformations - only applied for single line commands
3205 # Dynamic transformations - only applied for single line commands
3206 with self.builtin_trap:
3206 with self.builtin_trap:
3207 # use prefilter_lines to handle trailing newlines
3207 # use prefilter_lines to handle trailing newlines
3208 # restore trailing newline for ast.parse
3208 # restore trailing newline for ast.parse
3209 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
3209 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
3210
3210
3211 lines = cell.splitlines(keepends=True)
3211 lines = cell.splitlines(keepends=True)
3212 for transform in self.input_transformers_post:
3212 for transform in self.input_transformers_post:
3213 lines = transform(lines)
3213 lines = transform(lines)
3214 cell = ''.join(lines)
3214 cell = ''.join(lines)
3215
3215
3216 return cell
3216 return cell
3217
3217
3218 def transform_ast(self, node):
3218 def transform_ast(self, node):
3219 """Apply the AST transformations from self.ast_transformers
3219 """Apply the AST transformations from self.ast_transformers
3220
3220
3221 Parameters
3221 Parameters
3222 ----------
3222 ----------
3223 node : ast.Node
3223 node : ast.Node
3224 The root node to be transformed. Typically called with the ast.Module
3224 The root node to be transformed. Typically called with the ast.Module
3225 produced by parsing user input.
3225 produced by parsing user input.
3226
3226
3227 Returns
3227 Returns
3228 -------
3228 -------
3229 An ast.Node corresponding to the node it was called with. Note that it
3229 An ast.Node corresponding to the node it was called with. Note that it
3230 may also modify the passed object, so don't rely on references to the
3230 may also modify the passed object, so don't rely on references to the
3231 original AST.
3231 original AST.
3232 """
3232 """
3233 for transformer in self.ast_transformers:
3233 for transformer in self.ast_transformers:
3234 try:
3234 try:
3235 node = transformer.visit(node)
3235 node = transformer.visit(node)
3236 except InputRejected:
3236 except InputRejected:
3237 # User-supplied AST transformers can reject an input by raising
3237 # User-supplied AST transformers can reject an input by raising
3238 # an InputRejected. Short-circuit in this case so that we
3238 # an InputRejected. Short-circuit in this case so that we
3239 # don't unregister the transform.
3239 # don't unregister the transform.
3240 raise
3240 raise
3241 except Exception:
3241 except Exception:
3242 warn("AST transformer %r threw an error. It will be unregistered." % transformer)
3242 warn("AST transformer %r threw an error. It will be unregistered." % transformer)
3243 self.ast_transformers.remove(transformer)
3243 self.ast_transformers.remove(transformer)
3244
3244
3245 if self.ast_transformers:
3245 if self.ast_transformers:
3246 ast.fix_missing_locations(node)
3246 ast.fix_missing_locations(node)
3247 return node
3247 return node
3248
3248
3249 async def run_ast_nodes(self, nodelist:ListType[AST], cell_name:str, interactivity='last_expr',
3249 async def run_ast_nodes(self, nodelist:ListType[AST], cell_name:str, interactivity='last_expr',
3250 compiler=compile, result=None):
3250 compiler=compile, result=None):
3251 """Run a sequence of AST nodes. The execution mode depends on the
3251 """Run a sequence of AST nodes. The execution mode depends on the
3252 interactivity parameter.
3252 interactivity parameter.
3253
3253
3254 Parameters
3254 Parameters
3255 ----------
3255 ----------
3256 nodelist : list
3256 nodelist : list
3257 A sequence of AST nodes to run.
3257 A sequence of AST nodes to run.
3258 cell_name : str
3258 cell_name : str
3259 Will be passed to the compiler as the filename of the cell. Typically
3259 Will be passed to the compiler as the filename of the cell. Typically
3260 the value returned by ip.compile.cache(cell).
3260 the value returned by ip.compile.cache(cell).
3261 interactivity : str
3261 interactivity : str
3262 'all', 'last', 'last_expr' , 'last_expr_or_assign' or 'none',
3262 'all', 'last', 'last_expr' , 'last_expr_or_assign' or 'none',
3263 specifying which nodes should be run interactively (displaying output
3263 specifying which nodes should be run interactively (displaying output
3264 from expressions). 'last_expr' will run the last node interactively
3264 from expressions). 'last_expr' will run the last node interactively
3265 only if it is an expression (i.e. expressions in loops or other blocks
3265 only if it is an expression (i.e. expressions in loops or other blocks
3266 are not displayed) 'last_expr_or_assign' will run the last expression
3266 are not displayed) 'last_expr_or_assign' will run the last expression
3267 or the last assignment. Other values for this parameter will raise a
3267 or the last assignment. Other values for this parameter will raise a
3268 ValueError.
3268 ValueError.
3269
3269
3270 Experimental value: 'async' Will try to run top level interactive
3270 Experimental value: 'async' Will try to run top level interactive
3271 async/await code in default runner, this will not respect the
3271 async/await code in default runner, this will not respect the
3272 interactivity setting and will only run the last node if it is an
3272 interactivity setting and will only run the last node if it is an
3273 expression.
3273 expression.
3274
3274
3275 compiler : callable
3275 compiler : callable
3276 A function with the same interface as the built-in compile(), to turn
3276 A function with the same interface as the built-in compile(), to turn
3277 the AST nodes into code objects. Default is the built-in compile().
3277 the AST nodes into code objects. Default is the built-in compile().
3278 result : ExecutionResult, optional
3278 result : ExecutionResult, optional
3279 An object to store exceptions that occur during execution.
3279 An object to store exceptions that occur during execution.
3280
3280
3281 Returns
3281 Returns
3282 -------
3282 -------
3283 True if an exception occurred while running code, False if it finished
3283 True if an exception occurred while running code, False if it finished
3284 running.
3284 running.
3285 """
3285 """
3286 if not nodelist:
3286 if not nodelist:
3287 return
3287 return
3288
3288
3289 if interactivity == 'last_expr_or_assign':
3289 if interactivity == 'last_expr_or_assign':
3290 if isinstance(nodelist[-1], _assign_nodes):
3290 if isinstance(nodelist[-1], _assign_nodes):
3291 asg = nodelist[-1]
3291 asg = nodelist[-1]
3292 if isinstance(asg, ast.Assign) and len(asg.targets) == 1:
3292 if isinstance(asg, ast.Assign) and len(asg.targets) == 1:
3293 target = asg.targets[0]
3293 target = asg.targets[0]
3294 elif isinstance(asg, _single_targets_nodes):
3294 elif isinstance(asg, _single_targets_nodes):
3295 target = asg.target
3295 target = asg.target
3296 else:
3296 else:
3297 target = None
3297 target = None
3298 if isinstance(target, ast.Name):
3298 if isinstance(target, ast.Name):
3299 nnode = ast.Expr(ast.Name(target.id, ast.Load()))
3299 nnode = ast.Expr(ast.Name(target.id, ast.Load()))
3300 ast.fix_missing_locations(nnode)
3300 ast.fix_missing_locations(nnode)
3301 nodelist.append(nnode)
3301 nodelist.append(nnode)
3302 interactivity = 'last_expr'
3302 interactivity = 'last_expr'
3303
3303
3304 _async = False
3304 _async = False
3305 if interactivity == 'last_expr':
3305 if interactivity == 'last_expr':
3306 if isinstance(nodelist[-1], ast.Expr):
3306 if isinstance(nodelist[-1], ast.Expr):
3307 interactivity = "last"
3307 interactivity = "last"
3308 else:
3308 else:
3309 interactivity = "none"
3309 interactivity = "none"
3310
3310
3311 if interactivity == 'none':
3311 if interactivity == 'none':
3312 to_run_exec, to_run_interactive = nodelist, []
3312 to_run_exec, to_run_interactive = nodelist, []
3313 elif interactivity == 'last':
3313 elif interactivity == 'last':
3314 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
3314 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
3315 elif interactivity == 'all':
3315 elif interactivity == 'all':
3316 to_run_exec, to_run_interactive = [], nodelist
3316 to_run_exec, to_run_interactive = [], nodelist
3317 elif interactivity == 'async':
3317 elif interactivity == 'async':
3318 to_run_exec, to_run_interactive = [], nodelist
3318 to_run_exec, to_run_interactive = [], nodelist
3319 _async = True
3319 _async = True
3320 else:
3320 else:
3321 raise ValueError("Interactivity was %r" % interactivity)
3321 raise ValueError("Interactivity was %r" % interactivity)
3322
3322
3323 try:
3323 try:
3324 if _async and sys.version_info > (3,8):
3324 if _async and sys.version_info > (3,8):
3325 raise ValueError("This branch should never happen on Python 3.8 and above, "
3325 raise ValueError("This branch should never happen on Python 3.8 and above, "
3326 "please try to upgrade IPython and open a bug report with your case.")
3326 "please try to upgrade IPython and open a bug report with your case.")
3327 if _async:
3327 if _async:
3328 # If interactivity is async the semantics of run_code are
3328 # If interactivity is async the semantics of run_code are
3329 # completely different Skip usual machinery.
3329 # completely different Skip usual machinery.
3330 mod = Module(nodelist, [])
3330 mod = Module(nodelist, [])
3331 async_wrapper_code = compiler(mod, cell_name, 'exec')
3331 async_wrapper_code = compiler(mod, cell_name, 'exec')
3332 exec(async_wrapper_code, self.user_global_ns, self.user_ns)
3332 exec(async_wrapper_code, self.user_global_ns, self.user_ns)
3333 async_code = removed_co_newlocals(self.user_ns.pop('async-def-wrapper')).__code__
3333 async_code = removed_co_newlocals(self.user_ns.pop('async-def-wrapper')).__code__
3334 if (await self.run_code(async_code, result, async_=True)):
3334 if (await self.run_code(async_code, result, async_=True)):
3335 return True
3335 return True
3336 else:
3336 else:
3337 if sys.version_info > (3, 8):
3337 if sys.version_info > (3, 8):
3338 def compare(code):
3338 def compare(code):
3339 is_async = (inspect.CO_COROUTINE & code.co_flags == inspect.CO_COROUTINE)
3339 is_async = (inspect.CO_COROUTINE & code.co_flags == inspect.CO_COROUTINE)
3340 return is_async
3340 return is_async
3341 else:
3341 else:
3342 def compare(code):
3342 def compare(code):
3343 return _async
3343 return _async
3344
3344
3345 # refactor that to just change the mod constructor.
3345 # refactor that to just change the mod constructor.
3346 to_run = []
3346 to_run = []
3347 for node in to_run_exec:
3347 for node in to_run_exec:
3348 to_run.append((node, 'exec'))
3348 to_run.append((node, 'exec'))
3349
3349
3350 for node in to_run_interactive:
3350 for node in to_run_interactive:
3351 to_run.append((node, 'single'))
3351 to_run.append((node, 'single'))
3352
3352
3353 for node,mode in to_run:
3353 for node,mode in to_run:
3354 if mode == 'exec':
3354 if mode == 'exec':
3355 mod = Module([node], [])
3355 mod = Module([node], [])
3356 elif mode == 'single':
3356 elif mode == 'single':
3357 mod = ast.Interactive([node])
3357 mod = ast.Interactive([node])
3358 with compiler.extra_flags(getattr(ast, 'PyCF_ALLOW_TOP_LEVEL_AWAIT', 0x0) if self.autoawait else 0x0):
3358 with compiler.extra_flags(getattr(ast, 'PyCF_ALLOW_TOP_LEVEL_AWAIT', 0x0) if self.autoawait else 0x0):
3359 code = compiler(mod, cell_name, mode)
3359 code = compiler(mod, cell_name, mode)
3360 asy = compare(code)
3360 asy = compare(code)
3361 if (await self.run_code(code, result, async_=asy)):
3361 if (await self.run_code(code, result, async_=asy)):
3362 return True
3362 return True
3363
3363
3364 # Flush softspace
3364 # Flush softspace
3365 if softspace(sys.stdout, 0):
3365 if softspace(sys.stdout, 0):
3366 print()
3366 print()
3367
3367
3368 except:
3368 except:
3369 # It's possible to have exceptions raised here, typically by
3369 # It's possible to have exceptions raised here, typically by
3370 # compilation of odd code (such as a naked 'return' outside a
3370 # compilation of odd code (such as a naked 'return' outside a
3371 # function) that did parse but isn't valid. Typically the exception
3371 # function) that did parse but isn't valid. Typically the exception
3372 # is a SyntaxError, but it's safest just to catch anything and show
3372 # is a SyntaxError, but it's safest just to catch anything and show
3373 # the user a traceback.
3373 # the user a traceback.
3374
3374
3375 # We do only one try/except outside the loop to minimize the impact
3375 # We do only one try/except outside the loop to minimize the impact
3376 # on runtime, and also because if any node in the node list is
3376 # on runtime, and also because if any node in the node list is
3377 # broken, we should stop execution completely.
3377 # broken, we should stop execution completely.
3378 if result:
3378 if result:
3379 result.error_before_exec = sys.exc_info()[1]
3379 result.error_before_exec = sys.exc_info()[1]
3380 self.showtraceback()
3380 self.showtraceback()
3381 return True
3381 return True
3382
3382
3383 return False
3383 return False
3384
3384
3385 def _async_exec(self, code_obj: types.CodeType, user_ns: dict):
3385 def _async_exec(self, code_obj: types.CodeType, user_ns: dict):
3386 """
3386 """
3387 Evaluate an asynchronous code object using a code runner
3387 Evaluate an asynchronous code object using a code runner
3388
3388
3389 Fake asynchronous execution of code_object in a namespace via a proxy namespace.
3389 Fake asynchronous execution of code_object in a namespace via a proxy namespace.
3390
3390
3391 Returns coroutine object, which can be executed via async loop runner
3391 Returns coroutine object, which can be executed via async loop runner
3392
3392
3393 WARNING: The semantics of `async_exec` are quite different from `exec`,
3393 WARNING: The semantics of `async_exec` are quite different from `exec`,
3394 in particular you can only pass a single namespace. It also return a
3394 in particular you can only pass a single namespace. It also return a
3395 handle to the value of the last things returned by code_object.
3395 handle to the value of the last things returned by code_object.
3396 """
3396 """
3397
3397
3398 return eval(code_obj, user_ns)
3398 return eval(code_obj, user_ns)
3399
3399
3400 async def run_code(self, code_obj, result=None, *, async_=False):
3400 async def run_code(self, code_obj, result=None, *, async_=False):
3401 """Execute a code object.
3401 """Execute a code object.
3402
3402
3403 When an exception occurs, self.showtraceback() is called to display a
3403 When an exception occurs, self.showtraceback() is called to display a
3404 traceback.
3404 traceback.
3405
3405
3406 Parameters
3406 Parameters
3407 ----------
3407 ----------
3408 code_obj : code object
3408 code_obj : code object
3409 A compiled code object, to be executed
3409 A compiled code object, to be executed
3410 result : ExecutionResult, optional
3410 result : ExecutionResult, optional
3411 An object to store exceptions that occur during execution.
3411 An object to store exceptions that occur during execution.
3412 async_ : Bool (Experimental)
3412 async_ : Bool (Experimental)
3413 Attempt to run top-level asynchronous code in a default loop.
3413 Attempt to run top-level asynchronous code in a default loop.
3414
3414
3415 Returns
3415 Returns
3416 -------
3416 -------
3417 False : successful execution.
3417 False : successful execution.
3418 True : an error occurred.
3418 True : an error occurred.
3419 """
3419 """
3420 # special value to say that anything above is IPython and should be
3420 # special value to say that anything above is IPython and should be
3421 # hidden.
3421 # hidden.
3422 __tracebackhide__ = "__ipython_bottom__"
3422 __tracebackhide__ = "__ipython_bottom__"
3423 # Set our own excepthook in case the user code tries to call it
3423 # Set our own excepthook in case the user code tries to call it
3424 # directly, so that the IPython crash handler doesn't get triggered
3424 # directly, so that the IPython crash handler doesn't get triggered
3425 old_excepthook, sys.excepthook = sys.excepthook, self.excepthook
3425 old_excepthook, sys.excepthook = sys.excepthook, self.excepthook
3426
3426
3427 # we save the original sys.excepthook in the instance, in case config
3427 # we save the original sys.excepthook in the instance, in case config
3428 # code (such as magics) needs access to it.
3428 # code (such as magics) needs access to it.
3429 self.sys_excepthook = old_excepthook
3429 self.sys_excepthook = old_excepthook
3430 outflag = True # happens in more places, so it's easier as default
3430 outflag = True # happens in more places, so it's easier as default
3431 try:
3431 try:
3432 try:
3432 try:
3433 self.hooks.pre_run_code_hook()
3433 self.hooks.pre_run_code_hook()
3434 if async_ and sys.version_info < (3,8):
3434 if async_ and sys.version_info < (3,8):
3435 last_expr = (await self._async_exec(code_obj, self.user_ns))
3435 last_expr = (await self._async_exec(code_obj, self.user_ns))
3436 code = compile('last_expr', 'fake', "single")
3436 code = compile('last_expr', 'fake', "single")
3437 exec(code, {'last_expr': last_expr})
3437 exec(code, {'last_expr': last_expr})
3438 elif async_ :
3438 elif async_ :
3439 await eval(code_obj, self.user_global_ns, self.user_ns)
3439 await eval(code_obj, self.user_global_ns, self.user_ns)
3440 else:
3440 else:
3441 exec(code_obj, self.user_global_ns, self.user_ns)
3441 exec(code_obj, self.user_global_ns, self.user_ns)
3442 finally:
3442 finally:
3443 # Reset our crash handler in place
3443 # Reset our crash handler in place
3444 sys.excepthook = old_excepthook
3444 sys.excepthook = old_excepthook
3445 except SystemExit as e:
3445 except SystemExit as e:
3446 if result is not None:
3446 if result is not None:
3447 result.error_in_exec = e
3447 result.error_in_exec = e
3448 self.showtraceback(exception_only=True)
3448 self.showtraceback(exception_only=True)
3449 warn("To exit: use 'exit', 'quit', or Ctrl-D.", stacklevel=1)
3449 warn("To exit: use 'exit', 'quit', or Ctrl-D.", stacklevel=1)
3450 except self.custom_exceptions:
3450 except self.custom_exceptions:
3451 etype, value, tb = sys.exc_info()
3451 etype, value, tb = sys.exc_info()
3452 if result is not None:
3452 if result is not None:
3453 result.error_in_exec = value
3453 result.error_in_exec = value
3454 self.CustomTB(etype, value, tb)
3454 self.CustomTB(etype, value, tb)
3455 except:
3455 except:
3456 if result is not None:
3456 if result is not None:
3457 result.error_in_exec = sys.exc_info()[1]
3457 result.error_in_exec = sys.exc_info()[1]
3458 self.showtraceback(running_compiled_code=True)
3458 self.showtraceback(running_compiled_code=True)
3459 else:
3459 else:
3460 outflag = False
3460 outflag = False
3461 return outflag
3461 return outflag
3462
3462
3463 # For backwards compatibility
3463 # For backwards compatibility
3464 runcode = run_code
3464 runcode = run_code
3465
3465
3466 def check_complete(self, code: str) -> Tuple[str, str]:
3466 def check_complete(self, code: str) -> Tuple[str, str]:
3467 """Return whether a block of code is ready to execute, or should be continued
3467 """Return whether a block of code is ready to execute, or should be continued
3468
3468
3469 Parameters
3469 Parameters
3470 ----------
3470 ----------
3471 source : string
3471 source : string
3472 Python input code, which can be multiline.
3472 Python input code, which can be multiline.
3473
3473
3474 Returns
3474 Returns
3475 -------
3475 -------
3476 status : str
3476 status : str
3477 One of 'complete', 'incomplete', or 'invalid' if source is not a
3477 One of 'complete', 'incomplete', or 'invalid' if source is not a
3478 prefix of valid code.
3478 prefix of valid code.
3479 indent : str
3479 indent : str
3480 When status is 'incomplete', this is some whitespace to insert on
3480 When status is 'incomplete', this is some whitespace to insert on
3481 the next line of the prompt.
3481 the next line of the prompt.
3482 """
3482 """
3483 status, nspaces = self.input_transformer_manager.check_complete(code)
3483 status, nspaces = self.input_transformer_manager.check_complete(code)
3484 return status, ' ' * (nspaces or 0)
3484 return status, ' ' * (nspaces or 0)
3485
3485
3486 #-------------------------------------------------------------------------
3486 #-------------------------------------------------------------------------
3487 # Things related to GUI support and pylab
3487 # Things related to GUI support and pylab
3488 #-------------------------------------------------------------------------
3488 #-------------------------------------------------------------------------
3489
3489
3490 active_eventloop = None
3490 active_eventloop = None
3491
3491
3492 def enable_gui(self, gui=None):
3492 def enable_gui(self, gui=None):
3493 raise NotImplementedError('Implement enable_gui in a subclass')
3493 raise NotImplementedError('Implement enable_gui in a subclass')
3494
3494
3495 def enable_matplotlib(self, gui=None):
3495 def enable_matplotlib(self, gui=None):
3496 """Enable interactive matplotlib and inline figure support.
3496 """Enable interactive matplotlib and inline figure support.
3497
3497
3498 This takes the following steps:
3498 This takes the following steps:
3499
3499
3500 1. select the appropriate eventloop and matplotlib backend
3500 1. select the appropriate eventloop and matplotlib backend
3501 2. set up matplotlib for interactive use with that backend
3501 2. set up matplotlib for interactive use with that backend
3502 3. configure formatters for inline figure display
3502 3. configure formatters for inline figure display
3503 4. enable the selected gui eventloop
3503 4. enable the selected gui eventloop
3504
3504
3505 Parameters
3505 Parameters
3506 ----------
3506 ----------
3507 gui : optional, string
3507 gui : optional, string
3508 If given, dictates the choice of matplotlib GUI backend to use
3508 If given, dictates the choice of matplotlib GUI backend to use
3509 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
3509 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
3510 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
3510 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
3511 matplotlib (as dictated by the matplotlib build-time options plus the
3511 matplotlib (as dictated by the matplotlib build-time options plus the
3512 user's matplotlibrc configuration file). Note that not all backends
3512 user's matplotlibrc configuration file). Note that not all backends
3513 make sense in all contexts, for example a terminal ipython can't
3513 make sense in all contexts, for example a terminal ipython can't
3514 display figures inline.
3514 display figures inline.
3515 """
3515 """
3516 from IPython.core import pylabtools as pt
3516 from IPython.core import pylabtools as pt
3517 from matplotlib_inline.backend_inline import configure_inline_support
3517 gui, backend = pt.find_gui_and_backend(gui, self.pylab_gui_select)
3518 gui, backend = pt.find_gui_and_backend(gui, self.pylab_gui_select)
3518
3519
3519 if gui != 'inline':
3520 if gui != 'inline':
3520 # If we have our first gui selection, store it
3521 # If we have our first gui selection, store it
3521 if self.pylab_gui_select is None:
3522 if self.pylab_gui_select is None:
3522 self.pylab_gui_select = gui
3523 self.pylab_gui_select = gui
3523 # Otherwise if they are different
3524 # Otherwise if they are different
3524 elif gui != self.pylab_gui_select:
3525 elif gui != self.pylab_gui_select:
3525 print('Warning: Cannot change to a different GUI toolkit: %s.'
3526 print('Warning: Cannot change to a different GUI toolkit: %s.'
3526 ' Using %s instead.' % (gui, self.pylab_gui_select))
3527 ' Using %s instead.' % (gui, self.pylab_gui_select))
3527 gui, backend = pt.find_gui_and_backend(self.pylab_gui_select)
3528 gui, backend = pt.find_gui_and_backend(self.pylab_gui_select)
3528
3529
3529 pt.activate_matplotlib(backend)
3530 pt.activate_matplotlib(backend)
3530 pt.configure_inline_support(self, backend)
3531 configure_inline_support(self, backend)
3531
3532
3532 # Now we must activate the gui pylab wants to use, and fix %run to take
3533 # Now we must activate the gui pylab wants to use, and fix %run to take
3533 # plot updates into account
3534 # plot updates into account
3534 self.enable_gui(gui)
3535 self.enable_gui(gui)
3535 self.magics_manager.registry['ExecutionMagics'].default_runner = \
3536 self.magics_manager.registry['ExecutionMagics'].default_runner = \
3536 pt.mpl_runner(self.safe_execfile)
3537 pt.mpl_runner(self.safe_execfile)
3537
3538
3538 return gui, backend
3539 return gui, backend
3539
3540
3540 def enable_pylab(self, gui=None, import_all=True, welcome_message=False):
3541 def enable_pylab(self, gui=None, import_all=True, welcome_message=False):
3541 """Activate pylab support at runtime.
3542 """Activate pylab support at runtime.
3542
3543
3543 This turns on support for matplotlib, preloads into the interactive
3544 This turns on support for matplotlib, preloads into the interactive
3544 namespace all of numpy and pylab, and configures IPython to correctly
3545 namespace all of numpy and pylab, and configures IPython to correctly
3545 interact with the GUI event loop. The GUI backend to be used can be
3546 interact with the GUI event loop. The GUI backend to be used can be
3546 optionally selected with the optional ``gui`` argument.
3547 optionally selected with the optional ``gui`` argument.
3547
3548
3548 This method only adds preloading the namespace to InteractiveShell.enable_matplotlib.
3549 This method only adds preloading the namespace to InteractiveShell.enable_matplotlib.
3549
3550
3550 Parameters
3551 Parameters
3551 ----------
3552 ----------
3552 gui : optional, string
3553 gui : optional, string
3553 If given, dictates the choice of matplotlib GUI backend to use
3554 If given, dictates the choice of matplotlib GUI backend to use
3554 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
3555 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
3555 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
3556 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
3556 matplotlib (as dictated by the matplotlib build-time options plus the
3557 matplotlib (as dictated by the matplotlib build-time options plus the
3557 user's matplotlibrc configuration file). Note that not all backends
3558 user's matplotlibrc configuration file). Note that not all backends
3558 make sense in all contexts, for example a terminal ipython can't
3559 make sense in all contexts, for example a terminal ipython can't
3559 display figures inline.
3560 display figures inline.
3560 import_all : optional, bool, default: True
3561 import_all : optional, bool, default: True
3561 Whether to do `from numpy import *` and `from pylab import *`
3562 Whether to do `from numpy import *` and `from pylab import *`
3562 in addition to module imports.
3563 in addition to module imports.
3563 welcome_message : deprecated
3564 welcome_message : deprecated
3564 This argument is ignored, no welcome message will be displayed.
3565 This argument is ignored, no welcome message will be displayed.
3565 """
3566 """
3566 from IPython.core.pylabtools import import_pylab
3567 from IPython.core.pylabtools import import_pylab
3567
3568
3568 gui, backend = self.enable_matplotlib(gui)
3569 gui, backend = self.enable_matplotlib(gui)
3569
3570
3570 # We want to prevent the loading of pylab to pollute the user's
3571 # We want to prevent the loading of pylab to pollute the user's
3571 # namespace as shown by the %who* magics, so we execute the activation
3572 # namespace as shown by the %who* magics, so we execute the activation
3572 # code in an empty namespace, and we update *both* user_ns and
3573 # code in an empty namespace, and we update *both* user_ns and
3573 # user_ns_hidden with this information.
3574 # user_ns_hidden with this information.
3574 ns = {}
3575 ns = {}
3575 import_pylab(ns, import_all)
3576 import_pylab(ns, import_all)
3576 # warn about clobbered names
3577 # warn about clobbered names
3577 ignored = {"__builtins__"}
3578 ignored = {"__builtins__"}
3578 both = set(ns).intersection(self.user_ns).difference(ignored)
3579 both = set(ns).intersection(self.user_ns).difference(ignored)
3579 clobbered = [ name for name in both if self.user_ns[name] is not ns[name] ]
3580 clobbered = [ name for name in both if self.user_ns[name] is not ns[name] ]
3580 self.user_ns.update(ns)
3581 self.user_ns.update(ns)
3581 self.user_ns_hidden.update(ns)
3582 self.user_ns_hidden.update(ns)
3582 return gui, backend, clobbered
3583 return gui, backend, clobbered
3583
3584
3584 #-------------------------------------------------------------------------
3585 #-------------------------------------------------------------------------
3585 # Utilities
3586 # Utilities
3586 #-------------------------------------------------------------------------
3587 #-------------------------------------------------------------------------
3587
3588
3588 def var_expand(self, cmd, depth=0, formatter=DollarFormatter()):
3589 def var_expand(self, cmd, depth=0, formatter=DollarFormatter()):
3589 """Expand python variables in a string.
3590 """Expand python variables in a string.
3590
3591
3591 The depth argument indicates how many frames above the caller should
3592 The depth argument indicates how many frames above the caller should
3592 be walked to look for the local namespace where to expand variables.
3593 be walked to look for the local namespace where to expand variables.
3593
3594
3594 The global namespace for expansion is always the user's interactive
3595 The global namespace for expansion is always the user's interactive
3595 namespace.
3596 namespace.
3596 """
3597 """
3597 ns = self.user_ns.copy()
3598 ns = self.user_ns.copy()
3598 try:
3599 try:
3599 frame = sys._getframe(depth+1)
3600 frame = sys._getframe(depth+1)
3600 except ValueError:
3601 except ValueError:
3601 # This is thrown if there aren't that many frames on the stack,
3602 # This is thrown if there aren't that many frames on the stack,
3602 # e.g. if a script called run_line_magic() directly.
3603 # e.g. if a script called run_line_magic() directly.
3603 pass
3604 pass
3604 else:
3605 else:
3605 ns.update(frame.f_locals)
3606 ns.update(frame.f_locals)
3606
3607
3607 try:
3608 try:
3608 # We have to use .vformat() here, because 'self' is a valid and common
3609 # We have to use .vformat() here, because 'self' is a valid and common
3609 # name, and expanding **ns for .format() would make it collide with
3610 # name, and expanding **ns for .format() would make it collide with
3610 # the 'self' argument of the method.
3611 # the 'self' argument of the method.
3611 cmd = formatter.vformat(cmd, args=[], kwargs=ns)
3612 cmd = formatter.vformat(cmd, args=[], kwargs=ns)
3612 except Exception:
3613 except Exception:
3613 # if formatter couldn't format, just let it go untransformed
3614 # if formatter couldn't format, just let it go untransformed
3614 pass
3615 pass
3615 return cmd
3616 return cmd
3616
3617
3617 def mktempfile(self, data=None, prefix='ipython_edit_'):
3618 def mktempfile(self, data=None, prefix='ipython_edit_'):
3618 """Make a new tempfile and return its filename.
3619 """Make a new tempfile and return its filename.
3619
3620
3620 This makes a call to tempfile.mkstemp (created in a tempfile.mkdtemp),
3621 This makes a call to tempfile.mkstemp (created in a tempfile.mkdtemp),
3621 but it registers the created filename internally so ipython cleans it up
3622 but it registers the created filename internally so ipython cleans it up
3622 at exit time.
3623 at exit time.
3623
3624
3624 Optional inputs:
3625 Optional inputs:
3625
3626
3626 - data(None): if data is given, it gets written out to the temp file
3627 - data(None): if data is given, it gets written out to the temp file
3627 immediately, and the file is closed again."""
3628 immediately, and the file is closed again."""
3628
3629
3629 dirname = tempfile.mkdtemp(prefix=prefix)
3630 dirname = tempfile.mkdtemp(prefix=prefix)
3630 self.tempdirs.append(dirname)
3631 self.tempdirs.append(dirname)
3631
3632
3632 handle, filename = tempfile.mkstemp('.py', prefix, dir=dirname)
3633 handle, filename = tempfile.mkstemp('.py', prefix, dir=dirname)
3633 os.close(handle) # On Windows, there can only be one open handle on a file
3634 os.close(handle) # On Windows, there can only be one open handle on a file
3634 self.tempfiles.append(filename)
3635 self.tempfiles.append(filename)
3635
3636
3636 if data:
3637 if data:
3637 with open(filename, 'w') as tmp_file:
3638 with open(filename, 'w') as tmp_file:
3638 tmp_file.write(data)
3639 tmp_file.write(data)
3639 return filename
3640 return filename
3640
3641
3641 @undoc
3642 @undoc
3642 def write(self,data):
3643 def write(self,data):
3643 """DEPRECATED: Write a string to the default output"""
3644 """DEPRECATED: Write a string to the default output"""
3644 warn('InteractiveShell.write() is deprecated, use sys.stdout instead',
3645 warn('InteractiveShell.write() is deprecated, use sys.stdout instead',
3645 DeprecationWarning, stacklevel=2)
3646 DeprecationWarning, stacklevel=2)
3646 sys.stdout.write(data)
3647 sys.stdout.write(data)
3647
3648
3648 @undoc
3649 @undoc
3649 def write_err(self,data):
3650 def write_err(self,data):
3650 """DEPRECATED: Write a string to the default error output"""
3651 """DEPRECATED: Write a string to the default error output"""
3651 warn('InteractiveShell.write_err() is deprecated, use sys.stderr instead',
3652 warn('InteractiveShell.write_err() is deprecated, use sys.stderr instead',
3652 DeprecationWarning, stacklevel=2)
3653 DeprecationWarning, stacklevel=2)
3653 sys.stderr.write(data)
3654 sys.stderr.write(data)
3654
3655
3655 def ask_yes_no(self, prompt, default=None, interrupt=None):
3656 def ask_yes_no(self, prompt, default=None, interrupt=None):
3656 if self.quiet:
3657 if self.quiet:
3657 return True
3658 return True
3658 return ask_yes_no(prompt,default,interrupt)
3659 return ask_yes_no(prompt,default,interrupt)
3659
3660
3660 def show_usage(self):
3661 def show_usage(self):
3661 """Show a usage message"""
3662 """Show a usage message"""
3662 page.page(IPython.core.usage.interactive_usage)
3663 page.page(IPython.core.usage.interactive_usage)
3663
3664
3664 def extract_input_lines(self, range_str, raw=False):
3665 def extract_input_lines(self, range_str, raw=False):
3665 """Return as a string a set of input history slices.
3666 """Return as a string a set of input history slices.
3666
3667
3667 Parameters
3668 Parameters
3668 ----------
3669 ----------
3669 range_str : string
3670 range_str : string
3670 The set of slices is given as a string, like "~5/6-~4/2 4:8 9",
3671 The set of slices is given as a string, like "~5/6-~4/2 4:8 9",
3671 since this function is for use by magic functions which get their
3672 since this function is for use by magic functions which get their
3672 arguments as strings. The number before the / is the session
3673 arguments as strings. The number before the / is the session
3673 number: ~n goes n back from the current session.
3674 number: ~n goes n back from the current session.
3674
3675
3675 raw : bool, optional
3676 raw : bool, optional
3676 By default, the processed input is used. If this is true, the raw
3677 By default, the processed input is used. If this is true, the raw
3677 input history is used instead.
3678 input history is used instead.
3678
3679
3679 Notes
3680 Notes
3680 -----
3681 -----
3681
3682
3682 Slices can be described with two notations:
3683 Slices can be described with two notations:
3683
3684
3684 * ``N:M`` -> standard python form, means including items N...(M-1).
3685 * ``N:M`` -> standard python form, means including items N...(M-1).
3685 * ``N-M`` -> include items N..M (closed endpoint).
3686 * ``N-M`` -> include items N..M (closed endpoint).
3686 """
3687 """
3687 lines = self.history_manager.get_range_by_str(range_str, raw=raw)
3688 lines = self.history_manager.get_range_by_str(range_str, raw=raw)
3688 return "\n".join(x for _, _, x in lines)
3689 return "\n".join(x for _, _, x in lines)
3689
3690
3690 def find_user_code(self, target, raw=True, py_only=False, skip_encoding_cookie=True, search_ns=False):
3691 def find_user_code(self, target, raw=True, py_only=False, skip_encoding_cookie=True, search_ns=False):
3691 """Get a code string from history, file, url, or a string or macro.
3692 """Get a code string from history, file, url, or a string or macro.
3692
3693
3693 This is mainly used by magic functions.
3694 This is mainly used by magic functions.
3694
3695
3695 Parameters
3696 Parameters
3696 ----------
3697 ----------
3697
3698
3698 target : str
3699 target : str
3699
3700
3700 A string specifying code to retrieve. This will be tried respectively
3701 A string specifying code to retrieve. This will be tried respectively
3701 as: ranges of input history (see %history for syntax), url,
3702 as: ranges of input history (see %history for syntax), url,
3702 corresponding .py file, filename, or an expression evaluating to a
3703 corresponding .py file, filename, or an expression evaluating to a
3703 string or Macro in the user namespace.
3704 string or Macro in the user namespace.
3704
3705
3705 raw : bool
3706 raw : bool
3706 If true (default), retrieve raw history. Has no effect on the other
3707 If true (default), retrieve raw history. Has no effect on the other
3707 retrieval mechanisms.
3708 retrieval mechanisms.
3708
3709
3709 py_only : bool (default False)
3710 py_only : bool (default False)
3710 Only try to fetch python code, do not try alternative methods to decode file
3711 Only try to fetch python code, do not try alternative methods to decode file
3711 if unicode fails.
3712 if unicode fails.
3712
3713
3713 Returns
3714 Returns
3714 -------
3715 -------
3715 A string of code.
3716 A string of code.
3716
3717
3717 ValueError is raised if nothing is found, and TypeError if it evaluates
3718 ValueError is raised if nothing is found, and TypeError if it evaluates
3718 to an object of another type. In each case, .args[0] is a printable
3719 to an object of another type. In each case, .args[0] is a printable
3719 message.
3720 message.
3720 """
3721 """
3721 code = self.extract_input_lines(target, raw=raw) # Grab history
3722 code = self.extract_input_lines(target, raw=raw) # Grab history
3722 if code:
3723 if code:
3723 return code
3724 return code
3724 try:
3725 try:
3725 if target.startswith(('http://', 'https://')):
3726 if target.startswith(('http://', 'https://')):
3726 return openpy.read_py_url(target, skip_encoding_cookie=skip_encoding_cookie)
3727 return openpy.read_py_url(target, skip_encoding_cookie=skip_encoding_cookie)
3727 except UnicodeDecodeError:
3728 except UnicodeDecodeError:
3728 if not py_only :
3729 if not py_only :
3729 # Deferred import
3730 # Deferred import
3730 from urllib.request import urlopen
3731 from urllib.request import urlopen
3731 response = urlopen(target)
3732 response = urlopen(target)
3732 return response.read().decode('latin1')
3733 return response.read().decode('latin1')
3733 raise ValueError(("'%s' seem to be unreadable.") % target)
3734 raise ValueError(("'%s' seem to be unreadable.") % target)
3734
3735
3735 potential_target = [target]
3736 potential_target = [target]
3736 try :
3737 try :
3737 potential_target.insert(0,get_py_filename(target))
3738 potential_target.insert(0,get_py_filename(target))
3738 except IOError:
3739 except IOError:
3739 pass
3740 pass
3740
3741
3741 for tgt in potential_target :
3742 for tgt in potential_target :
3742 if os.path.isfile(tgt): # Read file
3743 if os.path.isfile(tgt): # Read file
3743 try :
3744 try :
3744 return openpy.read_py_file(tgt, skip_encoding_cookie=skip_encoding_cookie)
3745 return openpy.read_py_file(tgt, skip_encoding_cookie=skip_encoding_cookie)
3745 except UnicodeDecodeError :
3746 except UnicodeDecodeError :
3746 if not py_only :
3747 if not py_only :
3747 with io_open(tgt,'r', encoding='latin1') as f :
3748 with io_open(tgt,'r', encoding='latin1') as f :
3748 return f.read()
3749 return f.read()
3749 raise ValueError(("'%s' seem to be unreadable.") % target)
3750 raise ValueError(("'%s' seem to be unreadable.") % target)
3750 elif os.path.isdir(os.path.expanduser(tgt)):
3751 elif os.path.isdir(os.path.expanduser(tgt)):
3751 raise ValueError("'%s' is a directory, not a regular file." % target)
3752 raise ValueError("'%s' is a directory, not a regular file." % target)
3752
3753
3753 if search_ns:
3754 if search_ns:
3754 # Inspect namespace to load object source
3755 # Inspect namespace to load object source
3755 object_info = self.object_inspect(target, detail_level=1)
3756 object_info = self.object_inspect(target, detail_level=1)
3756 if object_info['found'] and object_info['source']:
3757 if object_info['found'] and object_info['source']:
3757 return object_info['source']
3758 return object_info['source']
3758
3759
3759 try: # User namespace
3760 try: # User namespace
3760 codeobj = eval(target, self.user_ns)
3761 codeobj = eval(target, self.user_ns)
3761 except Exception:
3762 except Exception:
3762 raise ValueError(("'%s' was not found in history, as a file, url, "
3763 raise ValueError(("'%s' was not found in history, as a file, url, "
3763 "nor in the user namespace.") % target)
3764 "nor in the user namespace.") % target)
3764
3765
3765 if isinstance(codeobj, str):
3766 if isinstance(codeobj, str):
3766 return codeobj
3767 return codeobj
3767 elif isinstance(codeobj, Macro):
3768 elif isinstance(codeobj, Macro):
3768 return codeobj.value
3769 return codeobj.value
3769
3770
3770 raise TypeError("%s is neither a string nor a macro." % target,
3771 raise TypeError("%s is neither a string nor a macro." % target,
3771 codeobj)
3772 codeobj)
3772
3773
3773 #-------------------------------------------------------------------------
3774 #-------------------------------------------------------------------------
3774 # Things related to IPython exiting
3775 # Things related to IPython exiting
3775 #-------------------------------------------------------------------------
3776 #-------------------------------------------------------------------------
3776 def atexit_operations(self):
3777 def atexit_operations(self):
3777 """This will be executed at the time of exit.
3778 """This will be executed at the time of exit.
3778
3779
3779 Cleanup operations and saving of persistent data that is done
3780 Cleanup operations and saving of persistent data that is done
3780 unconditionally by IPython should be performed here.
3781 unconditionally by IPython should be performed here.
3781
3782
3782 For things that may depend on startup flags or platform specifics (such
3783 For things that may depend on startup flags or platform specifics (such
3783 as having readline or not), register a separate atexit function in the
3784 as having readline or not), register a separate atexit function in the
3784 code that has the appropriate information, rather than trying to
3785 code that has the appropriate information, rather than trying to
3785 clutter
3786 clutter
3786 """
3787 """
3787 # Close the history session (this stores the end time and line count)
3788 # Close the history session (this stores the end time and line count)
3788 # this must be *before* the tempfile cleanup, in case of temporary
3789 # this must be *before* the tempfile cleanup, in case of temporary
3789 # history db
3790 # history db
3790 self.history_manager.end_session()
3791 self.history_manager.end_session()
3791
3792
3792 # Cleanup all tempfiles and folders left around
3793 # Cleanup all tempfiles and folders left around
3793 for tfile in self.tempfiles:
3794 for tfile in self.tempfiles:
3794 try:
3795 try:
3795 os.unlink(tfile)
3796 os.unlink(tfile)
3796 except OSError:
3797 except OSError:
3797 pass
3798 pass
3798
3799
3799 for tdir in self.tempdirs:
3800 for tdir in self.tempdirs:
3800 try:
3801 try:
3801 os.rmdir(tdir)
3802 os.rmdir(tdir)
3802 except OSError:
3803 except OSError:
3803 pass
3804 pass
3804
3805
3805 # Clear all user namespaces to release all references cleanly.
3806 # Clear all user namespaces to release all references cleanly.
3806 self.reset(new_session=False)
3807 self.reset(new_session=False)
3807
3808
3808 # Run user hooks
3809 # Run user hooks
3809 self.hooks.shutdown_hook()
3810 self.hooks.shutdown_hook()
3810
3811
3811 def cleanup(self):
3812 def cleanup(self):
3812 self.restore_sys_module_state()
3813 self.restore_sys_module_state()
3813
3814
3814
3815
3815 # Overridden in terminal subclass to change prompts
3816 # Overridden in terminal subclass to change prompts
3816 def switch_doctest_mode(self, mode):
3817 def switch_doctest_mode(self, mode):
3817 pass
3818 pass
3818
3819
3819
3820
3820 class InteractiveShellABC(metaclass=abc.ABCMeta):
3821 class InteractiveShellABC(metaclass=abc.ABCMeta):
3821 """An abstract base class for InteractiveShell."""
3822 """An abstract base class for InteractiveShell."""
3822
3823
3823 InteractiveShellABC.register(InteractiveShell)
3824 InteractiveShellABC.register(InteractiveShell)
@@ -1,419 +1,388 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 import warnings
8
9
9 from IPython.core.display import _pngxy
10 from IPython.core.display import _pngxy
10 from IPython.utils.decorators import flag_calls
11 from IPython.utils.decorators import flag_calls
11
12
12 # If user specifies a GUI, that dictates the backend, otherwise we read the
13 # If user specifies a GUI, that dictates the backend, otherwise we read the
13 # user's mpl default from the mpl rc structure
14 # user's mpl default from the mpl rc structure
14 backends = {'tk': 'TkAgg',
15 backends = {
15 'gtk': 'GTKAgg',
16 "tk": "TkAgg",
16 'gtk3': 'GTK3Agg',
17 "gtk": "GTKAgg",
17 'wx': 'WXAgg',
18 "gtk3": "GTK3Agg",
18 'qt4': 'Qt4Agg',
19 "wx": "WXAgg",
19 'qt5': 'Qt5Agg',
20 "qt4": "Qt4Agg",
20 'qt': 'Qt5Agg',
21 "qt5": "Qt5Agg",
21 'osx': 'MacOSX',
22 "qt": "Qt5Agg",
22 'nbagg': 'nbAgg',
23 "osx": "MacOSX",
23 'notebook': 'nbAgg',
24 "nbagg": "nbAgg",
24 'agg': 'agg',
25 "notebook": "nbAgg",
25 'svg': 'svg',
26 "agg": "agg",
26 'pdf': 'pdf',
27 "svg": "svg",
27 'ps': 'ps',
28 "pdf": "pdf",
28 'inline': 'module://ipykernel.pylab.backend_inline',
29 "ps": "ps",
29 'ipympl': 'module://ipympl.backend_nbagg',
30 "inline": "module://matplotlib_inline.backend_inline",
30 'widget': 'module://ipympl.backend_nbagg',
31 "ipympl": "module://ipympl.backend_nbagg",
31 }
32 "widget": "module://ipympl.backend_nbagg",
33 }
32
34
33 # We also need a reverse backends2guis mapping that will properly choose which
35 # We also need a reverse backends2guis mapping that will properly choose which
34 # GUI support to activate based on the desired matplotlib backend. For the
36 # GUI support to activate based on the desired matplotlib backend. For the
35 # most part it's just a reverse of the above dict, but we also need to add a
37 # most part it's just a reverse of the above dict, but we also need to add a
36 # few others that map to the same GUI manually:
38 # few others that map to the same GUI manually:
37 backend2gui = dict(zip(backends.values(), backends.keys()))
39 backend2gui = dict(zip(backends.values(), backends.keys()))
38 # Our tests expect backend2gui to just return 'qt'
40 # Our tests expect backend2gui to just return 'qt'
39 backend2gui['Qt4Agg'] = 'qt'
41 backend2gui['Qt4Agg'] = 'qt'
40 # In the reverse mapping, there are a few extra valid matplotlib backends that
42 # In the reverse mapping, there are a few extra valid matplotlib backends that
41 # map to the same GUI support
43 # map to the same GUI support
42 backend2gui['GTK'] = backend2gui['GTKCairo'] = 'gtk'
44 backend2gui['GTK'] = backend2gui['GTKCairo'] = 'gtk'
43 backend2gui['GTK3Cairo'] = 'gtk3'
45 backend2gui['GTK3Cairo'] = 'gtk3'
44 backend2gui['WX'] = 'wx'
46 backend2gui['WX'] = 'wx'
45 backend2gui['CocoaAgg'] = 'osx'
47 backend2gui['CocoaAgg'] = 'osx'
46 # And some backends that don't need GUI integration
48 # And some backends that don't need GUI integration
47 del backend2gui['nbAgg']
49 del backend2gui["nbAgg"]
48 del backend2gui['agg']
50 del backend2gui["agg"]
49 del backend2gui['svg']
51 del backend2gui["svg"]
50 del backend2gui['pdf']
52 del backend2gui["pdf"]
51 del backend2gui['ps']
53 del backend2gui["ps"]
52 del backend2gui['module://ipykernel.pylab.backend_inline']
54 del backend2gui["module://matplotlib_inline.backend_inline"]
53
55
54 #-----------------------------------------------------------------------------
56 #-----------------------------------------------------------------------------
55 # Matplotlib utilities
57 # Matplotlib utilities
56 #-----------------------------------------------------------------------------
58 #-----------------------------------------------------------------------------
57
59
58
60
59 def getfigs(*fig_nums):
61 def getfigs(*fig_nums):
60 """Get a list of matplotlib figures by figure numbers.
62 """Get a list of matplotlib figures by figure numbers.
61
63
62 If no arguments are given, all available figures are returned. If the
64 If no arguments are given, all available figures are returned. If the
63 argument list contains references to invalid figures, a warning is printed
65 argument list contains references to invalid figures, a warning is printed
64 but the function continues pasting further figures.
66 but the function continues pasting further figures.
65
67
66 Parameters
68 Parameters
67 ----------
69 ----------
68 figs : tuple
70 figs : tuple
69 A tuple of ints giving the figure numbers of the figures to return.
71 A tuple of ints giving the figure numbers of the figures to return.
70 """
72 """
71 from matplotlib._pylab_helpers import Gcf
73 from matplotlib._pylab_helpers import Gcf
72 if not fig_nums:
74 if not fig_nums:
73 fig_managers = Gcf.get_all_fig_managers()
75 fig_managers = Gcf.get_all_fig_managers()
74 return [fm.canvas.figure for fm in fig_managers]
76 return [fm.canvas.figure for fm in fig_managers]
75 else:
77 else:
76 figs = []
78 figs = []
77 for num in fig_nums:
79 for num in fig_nums:
78 f = Gcf.figs.get(num)
80 f = Gcf.figs.get(num)
79 if f is None:
81 if f is None:
80 print('Warning: figure %s not available.' % num)
82 print('Warning: figure %s not available.' % num)
81 else:
83 else:
82 figs.append(f.canvas.figure)
84 figs.append(f.canvas.figure)
83 return figs
85 return figs
84
86
85
87
86 def figsize(sizex, sizey):
88 def figsize(sizex, sizey):
87 """Set the default figure size to be [sizex, sizey].
89 """Set the default figure size to be [sizex, sizey].
88
90
89 This is just an easy to remember, convenience wrapper that sets::
91 This is just an easy to remember, convenience wrapper that sets::
90
92
91 matplotlib.rcParams['figure.figsize'] = [sizex, sizey]
93 matplotlib.rcParams['figure.figsize'] = [sizex, sizey]
92 """
94 """
93 import matplotlib
95 import matplotlib
94 matplotlib.rcParams['figure.figsize'] = [sizex, sizey]
96 matplotlib.rcParams['figure.figsize'] = [sizex, sizey]
95
97
96
98
97 def print_figure(fig, fmt='png', bbox_inches='tight', **kwargs):
99 def print_figure(fig, fmt='png', bbox_inches='tight', **kwargs):
98 """Print a figure to an image, and return the resulting file data
100 """Print a figure to an image, and return the resulting file data
99
101
100 Returned data will be bytes unless ``fmt='svg'``,
102 Returned data will be bytes unless ``fmt='svg'``,
101 in which case it will be unicode.
103 in which case it will be unicode.
102
104
103 Any keyword args are passed to fig.canvas.print_figure,
105 Any keyword args are passed to fig.canvas.print_figure,
104 such as ``quality`` or ``bbox_inches``.
106 such as ``quality`` or ``bbox_inches``.
105 """
107 """
106 # When there's an empty figure, we shouldn't return anything, otherwise we
108 # When there's an empty figure, we shouldn't return anything, otherwise we
107 # get big blank areas in the qt console.
109 # get big blank areas in the qt console.
108 if not fig.axes and not fig.lines:
110 if not fig.axes and not fig.lines:
109 return
111 return
110
112
111 dpi = fig.dpi
113 dpi = fig.dpi
112 if fmt == 'retina':
114 if fmt == 'retina':
113 dpi = dpi * 2
115 dpi = dpi * 2
114 fmt = 'png'
116 fmt = 'png'
115
117
116 # build keyword args
118 # build keyword args
117 kw = {
119 kw = {
118 "format":fmt,
120 "format":fmt,
119 "facecolor":fig.get_facecolor(),
121 "facecolor":fig.get_facecolor(),
120 "edgecolor":fig.get_edgecolor(),
122 "edgecolor":fig.get_edgecolor(),
121 "dpi":dpi,
123 "dpi":dpi,
122 "bbox_inches":bbox_inches,
124 "bbox_inches":bbox_inches,
123 }
125 }
124 # **kwargs get higher priority
126 # **kwargs get higher priority
125 kw.update(kwargs)
127 kw.update(kwargs)
126
128
127 bytes_io = BytesIO()
129 bytes_io = BytesIO()
128 if fig.canvas is None:
130 if fig.canvas is None:
129 from matplotlib.backend_bases import FigureCanvasBase
131 from matplotlib.backend_bases import FigureCanvasBase
130 FigureCanvasBase(fig)
132 FigureCanvasBase(fig)
131
133
132 fig.canvas.print_figure(bytes_io, **kw)
134 fig.canvas.print_figure(bytes_io, **kw)
133 data = bytes_io.getvalue()
135 data = bytes_io.getvalue()
134 if fmt == 'svg':
136 if fmt == 'svg':
135 data = data.decode('utf-8')
137 data = data.decode('utf-8')
136 return data
138 return data
137
139
138 def retina_figure(fig, **kwargs):
140 def retina_figure(fig, **kwargs):
139 """format a figure as a pixel-doubled (retina) PNG"""
141 """format a figure as a pixel-doubled (retina) PNG"""
140 pngdata = print_figure(fig, fmt='retina', **kwargs)
142 pngdata = print_figure(fig, fmt='retina', **kwargs)
141 # Make sure that retina_figure acts just like print_figure and returns
143 # Make sure that retina_figure acts just like print_figure and returns
142 # None when the figure is empty.
144 # None when the figure is empty.
143 if pngdata is None:
145 if pngdata is None:
144 return
146 return
145 w, h = _pngxy(pngdata)
147 w, h = _pngxy(pngdata)
146 metadata = {"width": w//2, "height":h//2}
148 metadata = {"width": w//2, "height":h//2}
147 return pngdata, metadata
149 return pngdata, metadata
148
150
149 # We need a little factory function here to create the closure where
151 # We need a little factory function here to create the closure where
150 # safe_execfile can live.
152 # safe_execfile can live.
151 def mpl_runner(safe_execfile):
153 def mpl_runner(safe_execfile):
152 """Factory to return a matplotlib-enabled runner for %run.
154 """Factory to return a matplotlib-enabled runner for %run.
153
155
154 Parameters
156 Parameters
155 ----------
157 ----------
156 safe_execfile : function
158 safe_execfile : function
157 This must be a function with the same interface as the
159 This must be a function with the same interface as the
158 :meth:`safe_execfile` method of IPython.
160 :meth:`safe_execfile` method of IPython.
159
161
160 Returns
162 Returns
161 -------
163 -------
162 A function suitable for use as the ``runner`` argument of the %run magic
164 A function suitable for use as the ``runner`` argument of the %run magic
163 function.
165 function.
164 """
166 """
165
167
166 def mpl_execfile(fname,*where,**kw):
168 def mpl_execfile(fname,*where,**kw):
167 """matplotlib-aware wrapper around safe_execfile.
169 """matplotlib-aware wrapper around safe_execfile.
168
170
169 Its interface is identical to that of the :func:`execfile` builtin.
171 Its interface is identical to that of the :func:`execfile` builtin.
170
172
171 This is ultimately a call to execfile(), but wrapped in safeties to
173 This is ultimately a call to execfile(), but wrapped in safeties to
172 properly handle interactive rendering."""
174 properly handle interactive rendering."""
173
175
174 import matplotlib
176 import matplotlib
175 import matplotlib.pyplot as plt
177 import matplotlib.pyplot as plt
176
178
177 #print '*** Matplotlib runner ***' # dbg
179 #print '*** Matplotlib runner ***' # dbg
178 # turn off rendering until end of script
180 # turn off rendering until end of script
179 is_interactive = matplotlib.rcParams['interactive']
181 is_interactive = matplotlib.rcParams['interactive']
180 matplotlib.interactive(False)
182 matplotlib.interactive(False)
181 safe_execfile(fname,*where,**kw)
183 safe_execfile(fname,*where,**kw)
182 matplotlib.interactive(is_interactive)
184 matplotlib.interactive(is_interactive)
183 # make rendering call now, if the user tried to do it
185 # make rendering call now, if the user tried to do it
184 if plt.draw_if_interactive.called:
186 if plt.draw_if_interactive.called:
185 plt.draw()
187 plt.draw()
186 plt.draw_if_interactive.called = False
188 plt.draw_if_interactive.called = False
187
189
188 # re-draw everything that is stale
190 # re-draw everything that is stale
189 try:
191 try:
190 da = plt.draw_all
192 da = plt.draw_all
191 except AttributeError:
193 except AttributeError:
192 pass
194 pass
193 else:
195 else:
194 da()
196 da()
195
197
196 return mpl_execfile
198 return mpl_execfile
197
199
198
200
199 def _reshow_nbagg_figure(fig):
201 def _reshow_nbagg_figure(fig):
200 """reshow an nbagg figure"""
202 """reshow an nbagg figure"""
201 try:
203 try:
202 reshow = fig.canvas.manager.reshow
204 reshow = fig.canvas.manager.reshow
203 except AttributeError:
205 except AttributeError:
204 raise NotImplementedError()
206 raise NotImplementedError()
205 else:
207 else:
206 reshow()
208 reshow()
207
209
208
210
209 def select_figure_formats(shell, formats, **kwargs):
211 def select_figure_formats(shell, formats, **kwargs):
210 """Select figure formats for the inline backend.
212 """Select figure formats for the inline backend.
211
213
212 Parameters
214 Parameters
213 ==========
215 ==========
214 shell : InteractiveShell
216 shell : InteractiveShell
215 The main IPython instance.
217 The main IPython instance.
216 formats : str or set
218 formats : str or set
217 One or a set of figure formats to enable: 'png', 'retina', 'jpeg', 'svg', 'pdf'.
219 One or a set of figure formats to enable: 'png', 'retina', 'jpeg', 'svg', 'pdf'.
218 **kwargs : any
220 **kwargs : any
219 Extra keyword arguments to be passed to fig.canvas.print_figure.
221 Extra keyword arguments to be passed to fig.canvas.print_figure.
220 """
222 """
221 import matplotlib
223 import matplotlib
222 from matplotlib.figure import Figure
224 from matplotlib.figure import Figure
223
225
224 svg_formatter = shell.display_formatter.formatters['image/svg+xml']
226 svg_formatter = shell.display_formatter.formatters['image/svg+xml']
225 png_formatter = shell.display_formatter.formatters['image/png']
227 png_formatter = shell.display_formatter.formatters['image/png']
226 jpg_formatter = shell.display_formatter.formatters['image/jpeg']
228 jpg_formatter = shell.display_formatter.formatters['image/jpeg']
227 pdf_formatter = shell.display_formatter.formatters['application/pdf']
229 pdf_formatter = shell.display_formatter.formatters['application/pdf']
228
230
229 if isinstance(formats, str):
231 if isinstance(formats, str):
230 formats = {formats}
232 formats = {formats}
231 # cast in case of list / tuple
233 # cast in case of list / tuple
232 formats = set(formats)
234 formats = set(formats)
233
235
234 [ f.pop(Figure, None) for f in shell.display_formatter.formatters.values() ]
236 [ f.pop(Figure, None) for f in shell.display_formatter.formatters.values() ]
235 mplbackend = matplotlib.get_backend().lower()
237 mplbackend = matplotlib.get_backend().lower()
236 if mplbackend == 'nbagg' or mplbackend == 'module://ipympl.backend_nbagg':
238 if mplbackend == 'nbagg' or mplbackend == 'module://ipympl.backend_nbagg':
237 formatter = shell.display_formatter.ipython_display_formatter
239 formatter = shell.display_formatter.ipython_display_formatter
238 formatter.for_type(Figure, _reshow_nbagg_figure)
240 formatter.for_type(Figure, _reshow_nbagg_figure)
239
241
240 supported = {'png', 'png2x', 'retina', 'jpg', 'jpeg', 'svg', 'pdf'}
242 supported = {'png', 'png2x', 'retina', 'jpg', 'jpeg', 'svg', 'pdf'}
241 bad = formats.difference(supported)
243 bad = formats.difference(supported)
242 if bad:
244 if bad:
243 bs = "%s" % ','.join([repr(f) for f in bad])
245 bs = "%s" % ','.join([repr(f) for f in bad])
244 gs = "%s" % ','.join([repr(f) for f in supported])
246 gs = "%s" % ','.join([repr(f) for f in supported])
245 raise ValueError("supported formats are: %s not %s" % (gs, bs))
247 raise ValueError("supported formats are: %s not %s" % (gs, bs))
246
248
247 if 'png' in formats:
249 if 'png' in formats:
248 png_formatter.for_type(Figure, lambda fig: print_figure(fig, 'png', **kwargs))
250 png_formatter.for_type(Figure, lambda fig: print_figure(fig, 'png', **kwargs))
249 if 'retina' in formats or 'png2x' in formats:
251 if 'retina' in formats or 'png2x' in formats:
250 png_formatter.for_type(Figure, lambda fig: retina_figure(fig, **kwargs))
252 png_formatter.for_type(Figure, lambda fig: retina_figure(fig, **kwargs))
251 if 'jpg' in formats or 'jpeg' in formats:
253 if 'jpg' in formats or 'jpeg' in formats:
252 jpg_formatter.for_type(Figure, lambda fig: print_figure(fig, 'jpg', **kwargs))
254 jpg_formatter.for_type(Figure, lambda fig: print_figure(fig, 'jpg', **kwargs))
253 if 'svg' in formats:
255 if 'svg' in formats:
254 svg_formatter.for_type(Figure, lambda fig: print_figure(fig, 'svg', **kwargs))
256 svg_formatter.for_type(Figure, lambda fig: print_figure(fig, 'svg', **kwargs))
255 if 'pdf' in formats:
257 if 'pdf' in formats:
256 pdf_formatter.for_type(Figure, lambda fig: print_figure(fig, 'pdf', **kwargs))
258 pdf_formatter.for_type(Figure, lambda fig: print_figure(fig, 'pdf', **kwargs))
257
259
258 #-----------------------------------------------------------------------------
260 #-----------------------------------------------------------------------------
259 # Code for initializing matplotlib and importing pylab
261 # Code for initializing matplotlib and importing pylab
260 #-----------------------------------------------------------------------------
262 #-----------------------------------------------------------------------------
261
263
262
264
263 def find_gui_and_backend(gui=None, gui_select=None):
265 def find_gui_and_backend(gui=None, gui_select=None):
264 """Given a gui string return the gui and mpl backend.
266 """Given a gui string return the gui and mpl backend.
265
267
266 Parameters
268 Parameters
267 ----------
269 ----------
268 gui : str
270 gui : str
269 Can be one of ('tk','gtk','wx','qt','qt4','inline','agg').
271 Can be one of ('tk','gtk','wx','qt','qt4','inline','agg').
270 gui_select : str
272 gui_select : str
271 Can be one of ('tk','gtk','wx','qt','qt4','inline').
273 Can be one of ('tk','gtk','wx','qt','qt4','inline').
272 This is any gui already selected by the shell.
274 This is any gui already selected by the shell.
273
275
274 Returns
276 Returns
275 -------
277 -------
276 A tuple of (gui, backend) where backend is one of ('TkAgg','GTKAgg',
278 A tuple of (gui, backend) where backend is one of ('TkAgg','GTKAgg',
277 'WXAgg','Qt4Agg','module://ipykernel.pylab.backend_inline','agg').
279 'WXAgg','Qt4Agg','module://matplotlib_inline.backend_inline','agg').
278 """
280 """
279
281
280 import matplotlib
282 import matplotlib
281
283
282 if gui and gui != 'auto':
284 if gui and gui != 'auto':
283 # select backend based on requested gui
285 # select backend based on requested gui
284 backend = backends[gui]
286 backend = backends[gui]
285 if gui == 'agg':
287 if gui == 'agg':
286 gui = None
288 gui = None
287 else:
289 else:
288 # We need to read the backend from the original data structure, *not*
290 # We need to read the backend from the original data structure, *not*
289 # from mpl.rcParams, since a prior invocation of %matplotlib may have
291 # from mpl.rcParams, since a prior invocation of %matplotlib may have
290 # overwritten that.
292 # overwritten that.
291 # WARNING: this assumes matplotlib 1.1 or newer!!
293 # WARNING: this assumes matplotlib 1.1 or newer!!
292 backend = matplotlib.rcParamsOrig['backend']
294 backend = matplotlib.rcParamsOrig['backend']
293 # In this case, we need to find what the appropriate gui selection call
295 # In this case, we need to find what the appropriate gui selection call
294 # should be for IPython, so we can activate inputhook accordingly
296 # should be for IPython, so we can activate inputhook accordingly
295 gui = backend2gui.get(backend, None)
297 gui = backend2gui.get(backend, None)
296
298
297 # If we have already had a gui active, we need it and inline are the
299 # If we have already had a gui active, we need it and inline are the
298 # ones allowed.
300 # ones allowed.
299 if gui_select and gui != gui_select:
301 if gui_select and gui != gui_select:
300 gui = gui_select
302 gui = gui_select
301 backend = backends[gui]
303 backend = backends[gui]
302
304
303 return gui, backend
305 return gui, backend
304
306
305
307
306 def activate_matplotlib(backend):
308 def activate_matplotlib(backend):
307 """Activate the given backend and set interactive to True."""
309 """Activate the given backend and set interactive to True."""
308
310
309 import matplotlib
311 import matplotlib
310 matplotlib.interactive(True)
312 matplotlib.interactive(True)
311
313
312 # Matplotlib had a bug where even switch_backend could not force
314 # Matplotlib had a bug where even switch_backend could not force
313 # the rcParam to update. This needs to be set *before* the module
315 # the rcParam to update. This needs to be set *before* the module
314 # magic of switch_backend().
316 # magic of switch_backend().
315 matplotlib.rcParams['backend'] = backend
317 matplotlib.rcParams['backend'] = backend
316
318
317 # Due to circular imports, pyplot may be only partially initialised
319 # Due to circular imports, pyplot may be only partially initialised
318 # when this function runs.
320 # when this function runs.
319 # So avoid needing matplotlib attribute-lookup to access pyplot.
321 # So avoid needing matplotlib attribute-lookup to access pyplot.
320 from matplotlib import pyplot as plt
322 from matplotlib import pyplot as plt
321
323
322 plt.switch_backend(backend)
324 plt.switch_backend(backend)
323
325
324 plt.show._needmain = False
326 plt.show._needmain = False
325 # We need to detect at runtime whether show() is called by the user.
327 # We need to detect at runtime whether show() is called by the user.
326 # For this, we wrap it into a decorator which adds a 'called' flag.
328 # For this, we wrap it into a decorator which adds a 'called' flag.
327 plt.draw_if_interactive = flag_calls(plt.draw_if_interactive)
329 plt.draw_if_interactive = flag_calls(plt.draw_if_interactive)
328
330
329
331
330 def import_pylab(user_ns, import_all=True):
332 def import_pylab(user_ns, import_all=True):
331 """Populate the namespace with pylab-related values.
333 """Populate the namespace with pylab-related values.
332
334
333 Imports matplotlib, pylab, numpy, and everything from pylab and numpy.
335 Imports matplotlib, pylab, numpy, and everything from pylab and numpy.
334
336
335 Also imports a few names from IPython (figsize, display, getfigs)
337 Also imports a few names from IPython (figsize, display, getfigs)
336
338
337 """
339 """
338
340
339 # Import numpy as np/pyplot as plt are conventions we're trying to
341 # Import numpy as np/pyplot as plt are conventions we're trying to
340 # somewhat standardize on. Making them available to users by default
342 # somewhat standardize on. Making them available to users by default
341 # will greatly help this.
343 # will greatly help this.
342 s = ("import numpy\n"
344 s = ("import numpy\n"
343 "import matplotlib\n"
345 "import matplotlib\n"
344 "from matplotlib import pylab, mlab, pyplot\n"
346 "from matplotlib import pylab, mlab, pyplot\n"
345 "np = numpy\n"
347 "np = numpy\n"
346 "plt = pyplot\n"
348 "plt = pyplot\n"
347 )
349 )
348 exec(s, user_ns)
350 exec(s, user_ns)
349
351
350 if import_all:
352 if import_all:
351 s = ("from matplotlib.pylab import *\n"
353 s = ("from matplotlib.pylab import *\n"
352 "from numpy import *\n")
354 "from numpy import *\n")
353 exec(s, user_ns)
355 exec(s, user_ns)
354
356
355 # IPython symbols to add
357 # IPython symbols to add
356 user_ns['figsize'] = figsize
358 user_ns['figsize'] = figsize
357 from IPython.core.display import display
359 from IPython.core.display import display
358 # Add display and getfigs to the user's namespace
360 # Add display and getfigs to the user's namespace
359 user_ns['display'] = display
361 user_ns['display'] = display
360 user_ns['getfigs'] = getfigs
362 user_ns['getfigs'] = getfigs
361
363
362
364
363 def configure_inline_support(shell, backend):
365 def configure_inline_support(shell, backend):
364 """Configure an IPython shell object for matplotlib use.
366 """
367 .. deprecated: 7.23
368
369 use `matplotlib_inline.backend_inline.configure_inline_support()`
370
371 Configure an IPython shell object for matplotlib use.
365
372
366 Parameters
373 Parameters
367 ----------
374 ----------
368 shell : InteractiveShell instance
375 shell : InteractiveShell instance
369
376
370 backend : matplotlib backend
377 backend : matplotlib backend
371 """
378 """
372 # If using our svg payload backend, register the post-execution
379 warnings.warn(
373 # function that will pick up the results for display. This can only be
380 "`configure_inline_support` is deprecated since IPython 7.23, directly "
374 # done with access to the real shell object.
381 "use `matplotlib_inline.backend_inline.configure_inline_support()`",
382 DeprecationWarning,
383 stacklevel=2,
384 )
375
385
376 # Note: if we can't load the inline backend, then there's no point
386 from matplotlib_inline.backend_inline import configure_inline_support_orig
377 # continuing (such as in terminal-only shells in environments without
378 # zeromq available).
379 try:
380 from ipykernel.pylab.backend_inline import InlineBackend
381 except ImportError:
382 return
383 import matplotlib
384
387
385 cfg = InlineBackend.instance(parent=shell)
388 configure_inline_support_orig(shell, backend)
386 cfg.shell = shell
387 if cfg not in shell.configurables:
388 shell.configurables.append(cfg)
389
390 if backend == backends['inline']:
391 from ipykernel.pylab.backend_inline import flush_figures
392 shell.events.register('post_execute', flush_figures)
393
394 # Save rcParams that will be overwrittern
395 shell._saved_rcParams = {}
396 for k in cfg.rc:
397 shell._saved_rcParams[k] = matplotlib.rcParams[k]
398 # load inline_rc
399 matplotlib.rcParams.update(cfg.rc)
400 new_backend_name = "inline"
401 else:
402 from ipykernel.pylab.backend_inline import flush_figures
403 try:
404 shell.events.unregister('post_execute', flush_figures)
405 except ValueError:
406 pass
407 if hasattr(shell, '_saved_rcParams'):
408 matplotlib.rcParams.update(shell._saved_rcParams)
409 del shell._saved_rcParams
410 new_backend_name = "other"
411
412 # only enable the formats once -> don't change the enabled formats (which the user may
413 # has changed) when getting another "%matplotlib inline" call.
414 # See https://github.com/ipython/ipykernel/issues/29
415 cur_backend = getattr(configure_inline_support, "current_backend", "unset")
416 if new_backend_name != cur_backend:
417 # Setup the default figure format
418 select_figure_formats(shell, cfg.figure_formats, **cfg.print_figure_kwargs)
419 configure_inline_support.current_backend = new_backend_name
@@ -1,459 +1,459 b''
1 # Copyright (c) IPython Development Team.
1 # Copyright (c) IPython Development Team.
2 # Distributed under the terms of the Modified BSD License.
2 # Distributed under the terms of the Modified BSD License.
3
3
4 import json
4 import json
5 import os
5 import os
6 import warnings
6 import warnings
7
7
8 from unittest import mock
8 from unittest import mock
9
9
10 import nose.tools as nt
10 import nose.tools as nt
11
11
12 from IPython.core import display
12 from IPython.core import display
13 from IPython.core.getipython import get_ipython
13 from IPython.core.getipython import get_ipython
14 from IPython.utils.io import capture_output
14 from IPython.utils.io import capture_output
15 from IPython.utils.tempdir import NamedFileInTemporaryDirectory
15 from IPython.utils.tempdir import NamedFileInTemporaryDirectory
16 from IPython import paths as ipath
16 from IPython import paths as ipath
17 from IPython.testing.tools import AssertNotPrints
17 from IPython.testing.tools import AssertNotPrints
18
18
19 import IPython.testing.decorators as dec
19 import IPython.testing.decorators as dec
20
20
21 def test_image_size():
21 def test_image_size():
22 """Simple test for display.Image(args, width=x,height=y)"""
22 """Simple test for display.Image(args, width=x,height=y)"""
23 thisurl = 'http://www.google.fr/images/srpr/logo3w.png'
23 thisurl = 'http://www.google.fr/images/srpr/logo3w.png'
24 img = display.Image(url=thisurl, width=200, height=200)
24 img = display.Image(url=thisurl, width=200, height=200)
25 nt.assert_equal(u'<img src="%s" width="200" height="200"/>' % (thisurl), img._repr_html_())
25 nt.assert_equal(u'<img src="%s" width="200" height="200"/>' % (thisurl), img._repr_html_())
26 img = display.Image(url=thisurl, metadata={'width':200, 'height':200})
26 img = display.Image(url=thisurl, metadata={'width':200, 'height':200})
27 nt.assert_equal(u'<img src="%s" width="200" height="200"/>' % (thisurl), img._repr_html_())
27 nt.assert_equal(u'<img src="%s" width="200" height="200"/>' % (thisurl), img._repr_html_())
28 img = display.Image(url=thisurl, width=200)
28 img = display.Image(url=thisurl, width=200)
29 nt.assert_equal(u'<img src="%s" width="200"/>' % (thisurl), img._repr_html_())
29 nt.assert_equal(u'<img src="%s" width="200"/>' % (thisurl), img._repr_html_())
30 img = display.Image(url=thisurl)
30 img = display.Image(url=thisurl)
31 nt.assert_equal(u'<img src="%s"/>' % (thisurl), img._repr_html_())
31 nt.assert_equal(u'<img src="%s"/>' % (thisurl), img._repr_html_())
32 img = display.Image(url=thisurl, unconfined=True)
32 img = display.Image(url=thisurl, unconfined=True)
33 nt.assert_equal(u'<img src="%s" class="unconfined"/>' % (thisurl), img._repr_html_())
33 nt.assert_equal(u'<img src="%s" class="unconfined"/>' % (thisurl), img._repr_html_())
34
34
35
35
36 def test_image_mimes():
36 def test_image_mimes():
37 fmt = get_ipython().display_formatter.format
37 fmt = get_ipython().display_formatter.format
38 for format in display.Image._ACCEPTABLE_EMBEDDINGS:
38 for format in display.Image._ACCEPTABLE_EMBEDDINGS:
39 mime = display.Image._MIMETYPES[format]
39 mime = display.Image._MIMETYPES[format]
40 img = display.Image(b'garbage', format=format)
40 img = display.Image(b'garbage', format=format)
41 data, metadata = fmt(img)
41 data, metadata = fmt(img)
42 nt.assert_equal(sorted(data), sorted([mime, 'text/plain']))
42 nt.assert_equal(sorted(data), sorted([mime, 'text/plain']))
43
43
44
44
45 def test_geojson():
45 def test_geojson():
46
46
47 gj = display.GeoJSON(data={
47 gj = display.GeoJSON(data={
48 "type": "Feature",
48 "type": "Feature",
49 "geometry": {
49 "geometry": {
50 "type": "Point",
50 "type": "Point",
51 "coordinates": [-81.327, 296.038]
51 "coordinates": [-81.327, 296.038]
52 },
52 },
53 "properties": {
53 "properties": {
54 "name": "Inca City"
54 "name": "Inca City"
55 }
55 }
56 },
56 },
57 url_template="http://s3-eu-west-1.amazonaws.com/whereonmars.cartodb.net/{basemap_id}/{z}/{x}/{y}.png",
57 url_template="http://s3-eu-west-1.amazonaws.com/whereonmars.cartodb.net/{basemap_id}/{z}/{x}/{y}.png",
58 layer_options={
58 layer_options={
59 "basemap_id": "celestia_mars-shaded-16k_global",
59 "basemap_id": "celestia_mars-shaded-16k_global",
60 "attribution": "Celestia/praesepe",
60 "attribution": "Celestia/praesepe",
61 "minZoom": 0,
61 "minZoom": 0,
62 "maxZoom": 18,
62 "maxZoom": 18,
63 })
63 })
64 nt.assert_equal(u'<IPython.core.display.GeoJSON object>', str(gj))
64 nt.assert_equal(u'<IPython.core.display.GeoJSON object>', str(gj))
65
65
66 def test_retina_png():
66 def test_retina_png():
67 here = os.path.dirname(__file__)
67 here = os.path.dirname(__file__)
68 img = display.Image(os.path.join(here, "2x2.png"), retina=True)
68 img = display.Image(os.path.join(here, "2x2.png"), retina=True)
69 nt.assert_equal(img.height, 1)
69 nt.assert_equal(img.height, 1)
70 nt.assert_equal(img.width, 1)
70 nt.assert_equal(img.width, 1)
71 data, md = img._repr_png_()
71 data, md = img._repr_png_()
72 nt.assert_equal(md['width'], 1)
72 nt.assert_equal(md['width'], 1)
73 nt.assert_equal(md['height'], 1)
73 nt.assert_equal(md['height'], 1)
74
74
75 def test_embed_svg_url():
75 def test_embed_svg_url():
76 import gzip
76 import gzip
77 from io import BytesIO
77 from io import BytesIO
78 svg_data = b'<svg><circle x="0" y="0" r="1"/></svg>'
78 svg_data = b'<svg><circle x="0" y="0" r="1"/></svg>'
79 url = 'http://test.com/circle.svg'
79 url = 'http://test.com/circle.svg'
80
80
81 gzip_svg = BytesIO()
81 gzip_svg = BytesIO()
82 with gzip.open(gzip_svg, 'wb') as fp:
82 with gzip.open(gzip_svg, 'wb') as fp:
83 fp.write(svg_data)
83 fp.write(svg_data)
84 gzip_svg = gzip_svg.getvalue()
84 gzip_svg = gzip_svg.getvalue()
85
85
86 def mocked_urlopen(*args, **kwargs):
86 def mocked_urlopen(*args, **kwargs):
87 class MockResponse:
87 class MockResponse:
88 def __init__(self, svg):
88 def __init__(self, svg):
89 self._svg_data = svg
89 self._svg_data = svg
90 self.headers = {'content-type': 'image/svg+xml'}
90 self.headers = {'content-type': 'image/svg+xml'}
91
91
92 def read(self):
92 def read(self):
93 return self._svg_data
93 return self._svg_data
94
94
95 if args[0] == url:
95 if args[0] == url:
96 return MockResponse(svg_data)
96 return MockResponse(svg_data)
97 elif args[0] == url + 'z':
97 elif args[0] == url + 'z':
98 ret= MockResponse(gzip_svg)
98 ret= MockResponse(gzip_svg)
99 ret.headers['content-encoding']= 'gzip'
99 ret.headers['content-encoding']= 'gzip'
100 return ret
100 return ret
101 return MockResponse(None)
101 return MockResponse(None)
102
102
103 with mock.patch('urllib.request.urlopen', side_effect=mocked_urlopen):
103 with mock.patch('urllib.request.urlopen', side_effect=mocked_urlopen):
104 svg = display.SVG(url=url)
104 svg = display.SVG(url=url)
105 nt.assert_true(svg._repr_svg_().startswith('<svg'))
105 nt.assert_true(svg._repr_svg_().startswith('<svg'))
106 svg = display.SVG(url=url + 'z')
106 svg = display.SVG(url=url + 'z')
107 nt.assert_true(svg._repr_svg_().startswith('<svg'))
107 nt.assert_true(svg._repr_svg_().startswith('<svg'))
108
108
109 def test_retina_jpeg():
109 def test_retina_jpeg():
110 here = os.path.dirname(__file__)
110 here = os.path.dirname(__file__)
111 img = display.Image(os.path.join(here, "2x2.jpg"), retina=True)
111 img = display.Image(os.path.join(here, "2x2.jpg"), retina=True)
112 nt.assert_equal(img.height, 1)
112 nt.assert_equal(img.height, 1)
113 nt.assert_equal(img.width, 1)
113 nt.assert_equal(img.width, 1)
114 data, md = img._repr_jpeg_()
114 data, md = img._repr_jpeg_()
115 nt.assert_equal(md['width'], 1)
115 nt.assert_equal(md['width'], 1)
116 nt.assert_equal(md['height'], 1)
116 nt.assert_equal(md['height'], 1)
117
117
118 def test_base64image():
118 def test_base64image():
119 display.Image("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABAQMAAAAl21bKAAAAA1BMVEUAAACnej3aAAAAAWJLR0QAiAUdSAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB94BCRQnOqNu0b4AAAAKSURBVAjXY2AAAAACAAHiIbwzAAAAAElFTkSuQmCC")
119 display.Image("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABAQMAAAAl21bKAAAAA1BMVEUAAACnej3aAAAAAWJLR0QAiAUdSAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB94BCRQnOqNu0b4AAAAKSURBVAjXY2AAAAACAAHiIbwzAAAAAElFTkSuQmCC")
120
120
121 def test_image_filename_defaults():
121 def test_image_filename_defaults():
122 '''test format constraint, and validity of jpeg and png'''
122 '''test format constraint, and validity of jpeg and png'''
123 tpath = ipath.get_ipython_package_dir()
123 tpath = ipath.get_ipython_package_dir()
124 nt.assert_raises(ValueError, display.Image, filename=os.path.join(tpath, 'testing/tests/badformat.zip'),
124 nt.assert_raises(ValueError, display.Image, filename=os.path.join(tpath, 'testing/tests/badformat.zip'),
125 embed=True)
125 embed=True)
126 nt.assert_raises(ValueError, display.Image)
126 nt.assert_raises(ValueError, display.Image)
127 nt.assert_raises(ValueError, display.Image, data='this is not an image', format='badformat', embed=True)
127 nt.assert_raises(ValueError, display.Image, data='this is not an image', format='badformat', embed=True)
128 # check boths paths to allow packages to test at build and install time
128 # check boths paths to allow packages to test at build and install time
129 imgfile = os.path.join(tpath, 'core/tests/2x2.png')
129 imgfile = os.path.join(tpath, 'core/tests/2x2.png')
130 img = display.Image(filename=imgfile)
130 img = display.Image(filename=imgfile)
131 nt.assert_equal('png', img.format)
131 nt.assert_equal('png', img.format)
132 nt.assert_is_not_none(img._repr_png_())
132 nt.assert_is_not_none(img._repr_png_())
133 img = display.Image(filename=os.path.join(tpath, 'testing/tests/logo.jpg'), embed=False)
133 img = display.Image(filename=os.path.join(tpath, 'testing/tests/logo.jpg'), embed=False)
134 nt.assert_equal('jpeg', img.format)
134 nt.assert_equal('jpeg', img.format)
135 nt.assert_is_none(img._repr_jpeg_())
135 nt.assert_is_none(img._repr_jpeg_())
136
136
137 def _get_inline_config():
137 def _get_inline_config():
138 from ipykernel.pylab.config import InlineBackend
138 from matplotlib_inline.config import InlineBackend
139 return InlineBackend.instance()
139 return InlineBackend.instance()
140
140
141
141
142 @dec.skip_without("ipykernel")
142 @dec.skip_without("ipykernel")
143 @dec.skip_without("matplotlib")
143 @dec.skip_without("matplotlib")
144 def test_set_matplotlib_close():
144 def test_set_matplotlib_close():
145 cfg = _get_inline_config()
145 cfg = _get_inline_config()
146 cfg.close_figures = False
146 cfg.close_figures = False
147 display.set_matplotlib_close()
147 display.set_matplotlib_close()
148 assert cfg.close_figures
148 assert cfg.close_figures
149 display.set_matplotlib_close(False)
149 display.set_matplotlib_close(False)
150 assert not cfg.close_figures
150 assert not cfg.close_figures
151
151
152 _fmt_mime_map = {
152 _fmt_mime_map = {
153 'png': 'image/png',
153 'png': 'image/png',
154 'jpeg': 'image/jpeg',
154 'jpeg': 'image/jpeg',
155 'pdf': 'application/pdf',
155 'pdf': 'application/pdf',
156 'retina': 'image/png',
156 'retina': 'image/png',
157 'svg': 'image/svg+xml',
157 'svg': 'image/svg+xml',
158 }
158 }
159
159
160 @dec.skip_without('matplotlib')
160 @dec.skip_without('matplotlib')
161 def test_set_matplotlib_formats():
161 def test_set_matplotlib_formats():
162 from matplotlib.figure import Figure
162 from matplotlib.figure import Figure
163 formatters = get_ipython().display_formatter.formatters
163 formatters = get_ipython().display_formatter.formatters
164 for formats in [
164 for formats in [
165 ('png',),
165 ('png',),
166 ('pdf', 'svg'),
166 ('pdf', 'svg'),
167 ('jpeg', 'retina', 'png'),
167 ('jpeg', 'retina', 'png'),
168 (),
168 (),
169 ]:
169 ]:
170 active_mimes = {_fmt_mime_map[fmt] for fmt in formats}
170 active_mimes = {_fmt_mime_map[fmt] for fmt in formats}
171 display.set_matplotlib_formats(*formats)
171 display.set_matplotlib_formats(*formats)
172 for mime, f in formatters.items():
172 for mime, f in formatters.items():
173 if mime in active_mimes:
173 if mime in active_mimes:
174 nt.assert_in(Figure, f)
174 nt.assert_in(Figure, f)
175 else:
175 else:
176 nt.assert_not_in(Figure, f)
176 nt.assert_not_in(Figure, f)
177
177
178
178
179 @dec.skip_without("ipykernel")
179 @dec.skip_without("ipykernel")
180 @dec.skip_without("matplotlib")
180 @dec.skip_without("matplotlib")
181 def test_set_matplotlib_formats_kwargs():
181 def test_set_matplotlib_formats_kwargs():
182 from matplotlib.figure import Figure
182 from matplotlib.figure import Figure
183 ip = get_ipython()
183 ip = get_ipython()
184 cfg = _get_inline_config()
184 cfg = _get_inline_config()
185 cfg.print_figure_kwargs.update(dict(foo='bar'))
185 cfg.print_figure_kwargs.update(dict(foo='bar'))
186 kwargs = dict(dpi=150)
186 kwargs = dict(dpi=150)
187 display.set_matplotlib_formats('png', **kwargs)
187 display.set_matplotlib_formats('png', **kwargs)
188 formatter = ip.display_formatter.formatters['image/png']
188 formatter = ip.display_formatter.formatters['image/png']
189 f = formatter.lookup_by_type(Figure)
189 f = formatter.lookup_by_type(Figure)
190 cell = f.__closure__[0].cell_contents
190 cell = f.__closure__[0].cell_contents
191 expected = kwargs
191 expected = kwargs
192 expected.update(cfg.print_figure_kwargs)
192 expected.update(cfg.print_figure_kwargs)
193 nt.assert_equal(cell, expected)
193 nt.assert_equal(cell, expected)
194
194
195 def test_display_available():
195 def test_display_available():
196 """
196 """
197 Test that display is available without import
197 Test that display is available without import
198
198
199 We don't really care if it's in builtin or anything else, but it should
199 We don't really care if it's in builtin or anything else, but it should
200 always be available.
200 always be available.
201 """
201 """
202 ip = get_ipython()
202 ip = get_ipython()
203 with AssertNotPrints('NameError'):
203 with AssertNotPrints('NameError'):
204 ip.run_cell('display')
204 ip.run_cell('display')
205 try:
205 try:
206 ip.run_cell('del display')
206 ip.run_cell('del display')
207 except NameError:
207 except NameError:
208 pass # it's ok, it might be in builtins
208 pass # it's ok, it might be in builtins
209 # even if deleted it should be back
209 # even if deleted it should be back
210 with AssertNotPrints('NameError'):
210 with AssertNotPrints('NameError'):
211 ip.run_cell('display')
211 ip.run_cell('display')
212
212
213 def test_textdisplayobj_pretty_repr():
213 def test_textdisplayobj_pretty_repr():
214 p = display.Pretty("This is a simple test")
214 p = display.Pretty("This is a simple test")
215 nt.assert_equal(repr(p), '<IPython.core.display.Pretty object>')
215 nt.assert_equal(repr(p), '<IPython.core.display.Pretty object>')
216 nt.assert_equal(p.data, 'This is a simple test')
216 nt.assert_equal(p.data, 'This is a simple test')
217
217
218 p._show_mem_addr = True
218 p._show_mem_addr = True
219 nt.assert_equal(repr(p), object.__repr__(p))
219 nt.assert_equal(repr(p), object.__repr__(p))
220
220
221 def test_displayobject_repr():
221 def test_displayobject_repr():
222 h = display.HTML('<br />')
222 h = display.HTML('<br />')
223 nt.assert_equal(repr(h), '<IPython.core.display.HTML object>')
223 nt.assert_equal(repr(h), '<IPython.core.display.HTML object>')
224 h._show_mem_addr = True
224 h._show_mem_addr = True
225 nt.assert_equal(repr(h), object.__repr__(h))
225 nt.assert_equal(repr(h), object.__repr__(h))
226 h._show_mem_addr = False
226 h._show_mem_addr = False
227 nt.assert_equal(repr(h), '<IPython.core.display.HTML object>')
227 nt.assert_equal(repr(h), '<IPython.core.display.HTML object>')
228
228
229 j = display.Javascript('')
229 j = display.Javascript('')
230 nt.assert_equal(repr(j), '<IPython.core.display.Javascript object>')
230 nt.assert_equal(repr(j), '<IPython.core.display.Javascript object>')
231 j._show_mem_addr = True
231 j._show_mem_addr = True
232 nt.assert_equal(repr(j), object.__repr__(j))
232 nt.assert_equal(repr(j), object.__repr__(j))
233 j._show_mem_addr = False
233 j._show_mem_addr = False
234 nt.assert_equal(repr(j), '<IPython.core.display.Javascript object>')
234 nt.assert_equal(repr(j), '<IPython.core.display.Javascript object>')
235
235
236 @mock.patch('warnings.warn')
236 @mock.patch('warnings.warn')
237 def test_encourage_iframe_over_html(m_warn):
237 def test_encourage_iframe_over_html(m_warn):
238 display.HTML()
238 display.HTML()
239 m_warn.assert_not_called()
239 m_warn.assert_not_called()
240
240
241 display.HTML('<br />')
241 display.HTML('<br />')
242 m_warn.assert_not_called()
242 m_warn.assert_not_called()
243
243
244 display.HTML('<html><p>Lots of content here</p><iframe src="http://a.com"></iframe>')
244 display.HTML('<html><p>Lots of content here</p><iframe src="http://a.com"></iframe>')
245 m_warn.assert_not_called()
245 m_warn.assert_not_called()
246
246
247 display.HTML('<iframe src="http://a.com"></iframe>')
247 display.HTML('<iframe src="http://a.com"></iframe>')
248 m_warn.assert_called_with('Consider using IPython.display.IFrame instead')
248 m_warn.assert_called_with('Consider using IPython.display.IFrame instead')
249
249
250 m_warn.reset_mock()
250 m_warn.reset_mock()
251 display.HTML('<IFRAME SRC="http://a.com"></IFRAME>')
251 display.HTML('<IFRAME SRC="http://a.com"></IFRAME>')
252 m_warn.assert_called_with('Consider using IPython.display.IFrame instead')
252 m_warn.assert_called_with('Consider using IPython.display.IFrame instead')
253
253
254 def test_progress():
254 def test_progress():
255 p = display.ProgressBar(10)
255 p = display.ProgressBar(10)
256 nt.assert_in('0/10',repr(p))
256 nt.assert_in('0/10',repr(p))
257 p.html_width = '100%'
257 p.html_width = '100%'
258 p.progress = 5
258 p.progress = 5
259 nt.assert_equal(p._repr_html_(), "<progress style='width:100%' max='10' value='5'></progress>")
259 nt.assert_equal(p._repr_html_(), "<progress style='width:100%' max='10' value='5'></progress>")
260
260
261 def test_progress_iter():
261 def test_progress_iter():
262 with capture_output(display=False) as captured:
262 with capture_output(display=False) as captured:
263 for i in display.ProgressBar(5):
263 for i in display.ProgressBar(5):
264 out = captured.stdout
264 out = captured.stdout
265 nt.assert_in('{0}/5'.format(i), out)
265 nt.assert_in('{0}/5'.format(i), out)
266 out = captured.stdout
266 out = captured.stdout
267 nt.assert_in('5/5', out)
267 nt.assert_in('5/5', out)
268
268
269 def test_json():
269 def test_json():
270 d = {'a': 5}
270 d = {'a': 5}
271 lis = [d]
271 lis = [d]
272 metadata = [
272 metadata = [
273 {'expanded': False, 'root': 'root'},
273 {'expanded': False, 'root': 'root'},
274 {'expanded': True, 'root': 'root'},
274 {'expanded': True, 'root': 'root'},
275 {'expanded': False, 'root': 'custom'},
275 {'expanded': False, 'root': 'custom'},
276 {'expanded': True, 'root': 'custom'},
276 {'expanded': True, 'root': 'custom'},
277 ]
277 ]
278 json_objs = [
278 json_objs = [
279 display.JSON(d),
279 display.JSON(d),
280 display.JSON(d, expanded=True),
280 display.JSON(d, expanded=True),
281 display.JSON(d, root='custom'),
281 display.JSON(d, root='custom'),
282 display.JSON(d, expanded=True, root='custom'),
282 display.JSON(d, expanded=True, root='custom'),
283 ]
283 ]
284 for j, md in zip(json_objs, metadata):
284 for j, md in zip(json_objs, metadata):
285 nt.assert_equal(j._repr_json_(), (d, md))
285 nt.assert_equal(j._repr_json_(), (d, md))
286
286
287 with warnings.catch_warnings(record=True) as w:
287 with warnings.catch_warnings(record=True) as w:
288 warnings.simplefilter("always")
288 warnings.simplefilter("always")
289 j = display.JSON(json.dumps(d))
289 j = display.JSON(json.dumps(d))
290 nt.assert_equal(len(w), 1)
290 nt.assert_equal(len(w), 1)
291 nt.assert_equal(j._repr_json_(), (d, metadata[0]))
291 nt.assert_equal(j._repr_json_(), (d, metadata[0]))
292
292
293 json_objs = [
293 json_objs = [
294 display.JSON(lis),
294 display.JSON(lis),
295 display.JSON(lis, expanded=True),
295 display.JSON(lis, expanded=True),
296 display.JSON(lis, root='custom'),
296 display.JSON(lis, root='custom'),
297 display.JSON(lis, expanded=True, root='custom'),
297 display.JSON(lis, expanded=True, root='custom'),
298 ]
298 ]
299 for j, md in zip(json_objs, metadata):
299 for j, md in zip(json_objs, metadata):
300 nt.assert_equal(j._repr_json_(), (lis, md))
300 nt.assert_equal(j._repr_json_(), (lis, md))
301
301
302 with warnings.catch_warnings(record=True) as w:
302 with warnings.catch_warnings(record=True) as w:
303 warnings.simplefilter("always")
303 warnings.simplefilter("always")
304 j = display.JSON(json.dumps(lis))
304 j = display.JSON(json.dumps(lis))
305 nt.assert_equal(len(w), 1)
305 nt.assert_equal(len(w), 1)
306 nt.assert_equal(j._repr_json_(), (lis, metadata[0]))
306 nt.assert_equal(j._repr_json_(), (lis, metadata[0]))
307
307
308 def test_video_embedding():
308 def test_video_embedding():
309 """use a tempfile, with dummy-data, to ensure that video embedding doesn't crash"""
309 """use a tempfile, with dummy-data, to ensure that video embedding doesn't crash"""
310 v = display.Video("http://ignored")
310 v = display.Video("http://ignored")
311 assert not v.embed
311 assert not v.embed
312 html = v._repr_html_()
312 html = v._repr_html_()
313 nt.assert_not_in('src="data:', html)
313 nt.assert_not_in('src="data:', html)
314 nt.assert_in('src="http://ignored"', html)
314 nt.assert_in('src="http://ignored"', html)
315
315
316 with nt.assert_raises(ValueError):
316 with nt.assert_raises(ValueError):
317 v = display.Video(b'abc')
317 v = display.Video(b'abc')
318
318
319 with NamedFileInTemporaryDirectory('test.mp4') as f:
319 with NamedFileInTemporaryDirectory('test.mp4') as f:
320 f.write(b'abc')
320 f.write(b'abc')
321 f.close()
321 f.close()
322
322
323 v = display.Video(f.name)
323 v = display.Video(f.name)
324 assert not v.embed
324 assert not v.embed
325 html = v._repr_html_()
325 html = v._repr_html_()
326 nt.assert_not_in('src="data:', html)
326 nt.assert_not_in('src="data:', html)
327
327
328 v = display.Video(f.name, embed=True)
328 v = display.Video(f.name, embed=True)
329 html = v._repr_html_()
329 html = v._repr_html_()
330 nt.assert_in('src="data:video/mp4;base64,YWJj"',html)
330 nt.assert_in('src="data:video/mp4;base64,YWJj"',html)
331
331
332 v = display.Video(f.name, embed=True, mimetype='video/other')
332 v = display.Video(f.name, embed=True, mimetype='video/other')
333 html = v._repr_html_()
333 html = v._repr_html_()
334 nt.assert_in('src="data:video/other;base64,YWJj"',html)
334 nt.assert_in('src="data:video/other;base64,YWJj"',html)
335
335
336 v = display.Video(b'abc', embed=True, mimetype='video/mp4')
336 v = display.Video(b'abc', embed=True, mimetype='video/mp4')
337 html = v._repr_html_()
337 html = v._repr_html_()
338 nt.assert_in('src="data:video/mp4;base64,YWJj"',html)
338 nt.assert_in('src="data:video/mp4;base64,YWJj"',html)
339
339
340 v = display.Video(u'YWJj', embed=True, mimetype='video/xyz')
340 v = display.Video(u'YWJj', embed=True, mimetype='video/xyz')
341 html = v._repr_html_()
341 html = v._repr_html_()
342 nt.assert_in('src="data:video/xyz;base64,YWJj"',html)
342 nt.assert_in('src="data:video/xyz;base64,YWJj"',html)
343
343
344 def test_html_metadata():
344 def test_html_metadata():
345 s = "<h1>Test</h1>"
345 s = "<h1>Test</h1>"
346 h = display.HTML(s, metadata={"isolated": True})
346 h = display.HTML(s, metadata={"isolated": True})
347 nt.assert_equal(h._repr_html_(), (s, {"isolated": True}))
347 nt.assert_equal(h._repr_html_(), (s, {"isolated": True}))
348
348
349 def test_display_id():
349 def test_display_id():
350 ip = get_ipython()
350 ip = get_ipython()
351 with mock.patch.object(ip.display_pub, 'publish') as pub:
351 with mock.patch.object(ip.display_pub, 'publish') as pub:
352 handle = display.display('x')
352 handle = display.display('x')
353 nt.assert_is(handle, None)
353 nt.assert_is(handle, None)
354 handle = display.display('y', display_id='secret')
354 handle = display.display('y', display_id='secret')
355 nt.assert_is_instance(handle, display.DisplayHandle)
355 nt.assert_is_instance(handle, display.DisplayHandle)
356 handle2 = display.display('z', display_id=True)
356 handle2 = display.display('z', display_id=True)
357 nt.assert_is_instance(handle2, display.DisplayHandle)
357 nt.assert_is_instance(handle2, display.DisplayHandle)
358 nt.assert_not_equal(handle.display_id, handle2.display_id)
358 nt.assert_not_equal(handle.display_id, handle2.display_id)
359
359
360 nt.assert_equal(pub.call_count, 3)
360 nt.assert_equal(pub.call_count, 3)
361 args, kwargs = pub.call_args_list[0]
361 args, kwargs = pub.call_args_list[0]
362 nt.assert_equal(args, ())
362 nt.assert_equal(args, ())
363 nt.assert_equal(kwargs, {
363 nt.assert_equal(kwargs, {
364 'data': {
364 'data': {
365 'text/plain': repr('x')
365 'text/plain': repr('x')
366 },
366 },
367 'metadata': {},
367 'metadata': {},
368 })
368 })
369 args, kwargs = pub.call_args_list[1]
369 args, kwargs = pub.call_args_list[1]
370 nt.assert_equal(args, ())
370 nt.assert_equal(args, ())
371 nt.assert_equal(kwargs, {
371 nt.assert_equal(kwargs, {
372 'data': {
372 'data': {
373 'text/plain': repr('y')
373 'text/plain': repr('y')
374 },
374 },
375 'metadata': {},
375 'metadata': {},
376 'transient': {
376 'transient': {
377 'display_id': handle.display_id,
377 'display_id': handle.display_id,
378 },
378 },
379 })
379 })
380 args, kwargs = pub.call_args_list[2]
380 args, kwargs = pub.call_args_list[2]
381 nt.assert_equal(args, ())
381 nt.assert_equal(args, ())
382 nt.assert_equal(kwargs, {
382 nt.assert_equal(kwargs, {
383 'data': {
383 'data': {
384 'text/plain': repr('z')
384 'text/plain': repr('z')
385 },
385 },
386 'metadata': {},
386 'metadata': {},
387 'transient': {
387 'transient': {
388 'display_id': handle2.display_id,
388 'display_id': handle2.display_id,
389 },
389 },
390 })
390 })
391
391
392
392
393 def test_update_display():
393 def test_update_display():
394 ip = get_ipython()
394 ip = get_ipython()
395 with mock.patch.object(ip.display_pub, 'publish') as pub:
395 with mock.patch.object(ip.display_pub, 'publish') as pub:
396 with nt.assert_raises(TypeError):
396 with nt.assert_raises(TypeError):
397 display.update_display('x')
397 display.update_display('x')
398 display.update_display('x', display_id='1')
398 display.update_display('x', display_id='1')
399 display.update_display('y', display_id='2')
399 display.update_display('y', display_id='2')
400 args, kwargs = pub.call_args_list[0]
400 args, kwargs = pub.call_args_list[0]
401 nt.assert_equal(args, ())
401 nt.assert_equal(args, ())
402 nt.assert_equal(kwargs, {
402 nt.assert_equal(kwargs, {
403 'data': {
403 'data': {
404 'text/plain': repr('x')
404 'text/plain': repr('x')
405 },
405 },
406 'metadata': {},
406 'metadata': {},
407 'transient': {
407 'transient': {
408 'display_id': '1',
408 'display_id': '1',
409 },
409 },
410 'update': True,
410 'update': True,
411 })
411 })
412 args, kwargs = pub.call_args_list[1]
412 args, kwargs = pub.call_args_list[1]
413 nt.assert_equal(args, ())
413 nt.assert_equal(args, ())
414 nt.assert_equal(kwargs, {
414 nt.assert_equal(kwargs, {
415 'data': {
415 'data': {
416 'text/plain': repr('y')
416 'text/plain': repr('y')
417 },
417 },
418 'metadata': {},
418 'metadata': {},
419 'transient': {
419 'transient': {
420 'display_id': '2',
420 'display_id': '2',
421 },
421 },
422 'update': True,
422 'update': True,
423 })
423 })
424
424
425
425
426 def test_display_handle():
426 def test_display_handle():
427 ip = get_ipython()
427 ip = get_ipython()
428 handle = display.DisplayHandle()
428 handle = display.DisplayHandle()
429 nt.assert_is_instance(handle.display_id, str)
429 nt.assert_is_instance(handle.display_id, str)
430 handle = display.DisplayHandle('my-id')
430 handle = display.DisplayHandle('my-id')
431 nt.assert_equal(handle.display_id, 'my-id')
431 nt.assert_equal(handle.display_id, 'my-id')
432 with mock.patch.object(ip.display_pub, 'publish') as pub:
432 with mock.patch.object(ip.display_pub, 'publish') as pub:
433 handle.display('x')
433 handle.display('x')
434 handle.update('y')
434 handle.update('y')
435
435
436 args, kwargs = pub.call_args_list[0]
436 args, kwargs = pub.call_args_list[0]
437 nt.assert_equal(args, ())
437 nt.assert_equal(args, ())
438 nt.assert_equal(kwargs, {
438 nt.assert_equal(kwargs, {
439 'data': {
439 'data': {
440 'text/plain': repr('x')
440 'text/plain': repr('x')
441 },
441 },
442 'metadata': {},
442 'metadata': {},
443 'transient': {
443 'transient': {
444 'display_id': handle.display_id,
444 'display_id': handle.display_id,
445 }
445 }
446 })
446 })
447 args, kwargs = pub.call_args_list[1]
447 args, kwargs = pub.call_args_list[1]
448 nt.assert_equal(args, ())
448 nt.assert_equal(args, ())
449 nt.assert_equal(kwargs, {
449 nt.assert_equal(kwargs, {
450 'data': {
450 'data': {
451 'text/plain': repr('y')
451 'text/plain': repr('y')
452 },
452 },
453 'metadata': {},
453 'metadata': {},
454 'transient': {
454 'transient': {
455 'display_id': handle.display_id,
455 'display_id': handle.display_id,
456 },
456 },
457 'update': True,
457 'update': True,
458 })
458 })
459
459
@@ -1,256 +1,259 b''
1 """Tests for pylab tools module.
1 """Tests for pylab tools module.
2 """
2 """
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
7
8 from io import UnsupportedOperation, BytesIO
8 from io import UnsupportedOperation, BytesIO
9
9
10 import matplotlib
10 import matplotlib
11 matplotlib.use('Agg')
11 matplotlib.use('Agg')
12 from matplotlib.figure import Figure
12 from matplotlib.figure import Figure
13
13
14 from nose import SkipTest
14 from nose import SkipTest
15 import nose.tools as nt
15 import nose.tools as nt
16
16
17 from matplotlib import pyplot as plt
17 from matplotlib import pyplot as plt
18 import matplotlib_inline
18 import numpy as np
19 import numpy as np
19
20
20 from IPython.core.getipython import get_ipython
21 from IPython.core.getipython import get_ipython
21 from IPython.core.interactiveshell import InteractiveShell
22 from IPython.core.interactiveshell import InteractiveShell
22 from IPython.core.display import _PNG, _JPEG
23 from IPython.core.display import _PNG, _JPEG
23 from .. import pylabtools as pt
24 from .. import pylabtools as pt
24
25
25 from IPython.testing import decorators as dec
26 from IPython.testing import decorators as dec
26
27
27
28
28 def test_figure_to_svg():
29 def test_figure_to_svg():
29 # simple empty-figure test
30 # simple empty-figure test
30 fig = plt.figure()
31 fig = plt.figure()
31 nt.assert_equal(pt.print_figure(fig, 'svg'), None)
32 nt.assert_equal(pt.print_figure(fig, 'svg'), None)
32
33
33 plt.close('all')
34 plt.close('all')
34
35
35 # simple check for at least svg-looking output
36 # simple check for at least svg-looking output
36 fig = plt.figure()
37 fig = plt.figure()
37 ax = fig.add_subplot(1,1,1)
38 ax = fig.add_subplot(1,1,1)
38 ax.plot([1,2,3])
39 ax.plot([1,2,3])
39 plt.draw()
40 plt.draw()
40 svg = pt.print_figure(fig, 'svg')[:100].lower()
41 svg = pt.print_figure(fig, 'svg')[:100].lower()
41 nt.assert_in(u'doctype svg', svg)
42 nt.assert_in(u'doctype svg', svg)
42
43
43 def _check_pil_jpeg_bytes():
44 def _check_pil_jpeg_bytes():
44 """Skip if PIL can't write JPEGs to BytesIO objects"""
45 """Skip if PIL can't write JPEGs to BytesIO objects"""
45 # PIL's JPEG plugin can't write to BytesIO objects
46 # PIL's JPEG plugin can't write to BytesIO objects
46 # Pillow fixes this
47 # Pillow fixes this
47 from PIL import Image
48 from PIL import Image
48 buf = BytesIO()
49 buf = BytesIO()
49 img = Image.new("RGB", (4,4))
50 img = Image.new("RGB", (4,4))
50 try:
51 try:
51 img.save(buf, 'jpeg')
52 img.save(buf, 'jpeg')
52 except Exception as e:
53 except Exception as e:
53 ename = e.__class__.__name__
54 ename = e.__class__.__name__
54 raise SkipTest("PIL can't write JPEG to BytesIO: %s: %s" % (ename, e))
55 raise SkipTest("PIL can't write JPEG to BytesIO: %s: %s" % (ename, e))
55
56
56 @dec.skip_without("PIL.Image")
57 @dec.skip_without("PIL.Image")
57 def test_figure_to_jpeg():
58 def test_figure_to_jpeg():
58 _check_pil_jpeg_bytes()
59 _check_pil_jpeg_bytes()
59 # simple check for at least jpeg-looking output
60 # simple check for at least jpeg-looking output
60 fig = plt.figure()
61 fig = plt.figure()
61 ax = fig.add_subplot(1,1,1)
62 ax = fig.add_subplot(1,1,1)
62 ax.plot([1,2,3])
63 ax.plot([1,2,3])
63 plt.draw()
64 plt.draw()
64 jpeg = pt.print_figure(fig, 'jpeg', pil_kwargs={'optimize': 50})[:100].lower()
65 jpeg = pt.print_figure(fig, 'jpeg', pil_kwargs={'optimize': 50})[:100].lower()
65 assert jpeg.startswith(_JPEG)
66 assert jpeg.startswith(_JPEG)
66
67
67 def test_retina_figure():
68 def test_retina_figure():
68 # simple empty-figure test
69 # simple empty-figure test
69 fig = plt.figure()
70 fig = plt.figure()
70 nt.assert_equal(pt.retina_figure(fig), None)
71 nt.assert_equal(pt.retina_figure(fig), None)
71 plt.close('all')
72 plt.close('all')
72
73
73 fig = plt.figure()
74 fig = plt.figure()
74 ax = fig.add_subplot(1,1,1)
75 ax = fig.add_subplot(1,1,1)
75 ax.plot([1,2,3])
76 ax.plot([1,2,3])
76 plt.draw()
77 plt.draw()
77 png, md = pt.retina_figure(fig)
78 png, md = pt.retina_figure(fig)
78 assert png.startswith(_PNG)
79 assert png.startswith(_PNG)
79 nt.assert_in('width', md)
80 nt.assert_in('width', md)
80 nt.assert_in('height', md)
81 nt.assert_in('height', md)
81
82
82 _fmt_mime_map = {
83 _fmt_mime_map = {
83 'png': 'image/png',
84 'png': 'image/png',
84 'jpeg': 'image/jpeg',
85 'jpeg': 'image/jpeg',
85 'pdf': 'application/pdf',
86 'pdf': 'application/pdf',
86 'retina': 'image/png',
87 'retina': 'image/png',
87 'svg': 'image/svg+xml',
88 'svg': 'image/svg+xml',
88 }
89 }
89
90
90 def test_select_figure_formats_str():
91 def test_select_figure_formats_str():
91 ip = get_ipython()
92 ip = get_ipython()
92 for fmt, active_mime in _fmt_mime_map.items():
93 for fmt, active_mime in _fmt_mime_map.items():
93 pt.select_figure_formats(ip, fmt)
94 pt.select_figure_formats(ip, fmt)
94 for mime, f in ip.display_formatter.formatters.items():
95 for mime, f in ip.display_formatter.formatters.items():
95 if mime == active_mime:
96 if mime == active_mime:
96 nt.assert_in(Figure, f)
97 nt.assert_in(Figure, f)
97 else:
98 else:
98 nt.assert_not_in(Figure, f)
99 nt.assert_not_in(Figure, f)
99
100
100 def test_select_figure_formats_kwargs():
101 def test_select_figure_formats_kwargs():
101 ip = get_ipython()
102 ip = get_ipython()
102 kwargs = dict(quality=10, bbox_inches='tight')
103 kwargs = dict(quality=10, bbox_inches='tight')
103 pt.select_figure_formats(ip, 'png', **kwargs)
104 pt.select_figure_formats(ip, 'png', **kwargs)
104 formatter = ip.display_formatter.formatters['image/png']
105 formatter = ip.display_formatter.formatters['image/png']
105 f = formatter.lookup_by_type(Figure)
106 f = formatter.lookup_by_type(Figure)
106 cell = f.__closure__[0].cell_contents
107 cell = f.__closure__[0].cell_contents
107 nt.assert_equal(cell, kwargs)
108 nt.assert_equal(cell, kwargs)
108
109
109 # check that the formatter doesn't raise
110 # check that the formatter doesn't raise
110 fig = plt.figure()
111 fig = plt.figure()
111 ax = fig.add_subplot(1,1,1)
112 ax = fig.add_subplot(1,1,1)
112 ax.plot([1,2,3])
113 ax.plot([1,2,3])
113 plt.draw()
114 plt.draw()
114 formatter.enabled = True
115 formatter.enabled = True
115 png = formatter(fig)
116 png = formatter(fig)
116 assert png.startswith(_PNG)
117 assert png.startswith(_PNG)
117
118
118 def test_select_figure_formats_set():
119 def test_select_figure_formats_set():
119 ip = get_ipython()
120 ip = get_ipython()
120 for fmts in [
121 for fmts in [
121 {'png', 'svg'},
122 {'png', 'svg'},
122 ['png'],
123 ['png'],
123 ('jpeg', 'pdf', 'retina'),
124 ('jpeg', 'pdf', 'retina'),
124 {'svg'},
125 {'svg'},
125 ]:
126 ]:
126 active_mimes = {_fmt_mime_map[fmt] for fmt in fmts}
127 active_mimes = {_fmt_mime_map[fmt] for fmt in fmts}
127 pt.select_figure_formats(ip, fmts)
128 pt.select_figure_formats(ip, fmts)
128 for mime, f in ip.display_formatter.formatters.items():
129 for mime, f in ip.display_formatter.formatters.items():
129 if mime in active_mimes:
130 if mime in active_mimes:
130 nt.assert_in(Figure, f)
131 nt.assert_in(Figure, f)
131 else:
132 else:
132 nt.assert_not_in(Figure, f)
133 nt.assert_not_in(Figure, f)
133
134
134 def test_select_figure_formats_bad():
135 def test_select_figure_formats_bad():
135 ip = get_ipython()
136 ip = get_ipython()
136 with nt.assert_raises(ValueError):
137 with nt.assert_raises(ValueError):
137 pt.select_figure_formats(ip, 'foo')
138 pt.select_figure_formats(ip, 'foo')
138 with nt.assert_raises(ValueError):
139 with nt.assert_raises(ValueError):
139 pt.select_figure_formats(ip, {'png', 'foo'})
140 pt.select_figure_formats(ip, {'png', 'foo'})
140 with nt.assert_raises(ValueError):
141 with nt.assert_raises(ValueError):
141 pt.select_figure_formats(ip, ['retina', 'pdf', 'bar', 'bad'])
142 pt.select_figure_formats(ip, ['retina', 'pdf', 'bar', 'bad'])
142
143
143 def test_import_pylab():
144 def test_import_pylab():
144 ns = {}
145 ns = {}
145 pt.import_pylab(ns, import_all=False)
146 pt.import_pylab(ns, import_all=False)
146 nt.assert_true('plt' in ns)
147 nt.assert_true('plt' in ns)
147 nt.assert_equal(ns['np'], np)
148 nt.assert_equal(ns['np'], np)
148
149
149 class TestPylabSwitch(object):
150 class TestPylabSwitch(object):
150 class Shell(InteractiveShell):
151 class Shell(InteractiveShell):
151 def enable_gui(self, gui):
152 def enable_gui(self, gui):
152 pass
153 pass
153
154
154 def setup(self):
155 def setup(self):
155 import matplotlib
156 import matplotlib
156 def act_mpl(backend):
157 def act_mpl(backend):
157 matplotlib.rcParams['backend'] = backend
158 matplotlib.rcParams['backend'] = backend
158
159
159 # Save rcParams since they get modified
160 # Save rcParams since they get modified
160 self._saved_rcParams = matplotlib.rcParams
161 self._saved_rcParams = matplotlib.rcParams
161 self._saved_rcParamsOrig = matplotlib.rcParamsOrig
162 self._saved_rcParamsOrig = matplotlib.rcParamsOrig
162 matplotlib.rcParams = dict(backend='Qt4Agg')
163 matplotlib.rcParams = dict(backend='Qt4Agg')
163 matplotlib.rcParamsOrig = dict(backend='Qt4Agg')
164 matplotlib.rcParamsOrig = dict(backend='Qt4Agg')
164
165
165 # Mock out functions
166 # Mock out functions
166 self._save_am = pt.activate_matplotlib
167 self._save_am = pt.activate_matplotlib
167 pt.activate_matplotlib = act_mpl
168 pt.activate_matplotlib = act_mpl
168 self._save_ip = pt.import_pylab
169 self._save_ip = pt.import_pylab
169 pt.import_pylab = lambda *a,**kw:None
170 pt.import_pylab = lambda *a,**kw:None
170 self._save_cis = pt.configure_inline_support
171 self._save_cis = matplotlib_inline.backend_inline.configure_inline_support
171 pt.configure_inline_support = lambda *a,**kw:None
172 matplotlib_inline.backend_inline.configure_inline_support = (
173 lambda *a, **kw: None
174 )
172
175
173 def teardown(self):
176 def teardown(self):
174 pt.activate_matplotlib = self._save_am
177 pt.activate_matplotlib = self._save_am
175 pt.import_pylab = self._save_ip
178 pt.import_pylab = self._save_ip
176 pt.configure_inline_support = self._save_cis
179 matplotlib_inline.backend_inline.configure_inline_support = self._save_cis
177 import matplotlib
180 import matplotlib
178 matplotlib.rcParams = self._saved_rcParams
181 matplotlib.rcParams = self._saved_rcParams
179 matplotlib.rcParamsOrig = self._saved_rcParamsOrig
182 matplotlib.rcParamsOrig = self._saved_rcParamsOrig
180
183
181 def test_qt(self):
184 def test_qt(self):
182 s = self.Shell()
185 s = self.Shell()
183 gui, backend = s.enable_matplotlib(None)
186 gui, backend = s.enable_matplotlib(None)
184 nt.assert_equal(gui, 'qt')
187 nt.assert_equal(gui, 'qt')
185 nt.assert_equal(s.pylab_gui_select, 'qt')
188 nt.assert_equal(s.pylab_gui_select, 'qt')
186
189
187 gui, backend = s.enable_matplotlib('inline')
190 gui, backend = s.enable_matplotlib('inline')
188 nt.assert_equal(gui, 'inline')
191 nt.assert_equal(gui, 'inline')
189 nt.assert_equal(s.pylab_gui_select, 'qt')
192 nt.assert_equal(s.pylab_gui_select, 'qt')
190
193
191 gui, backend = s.enable_matplotlib('qt')
194 gui, backend = s.enable_matplotlib('qt')
192 nt.assert_equal(gui, 'qt')
195 nt.assert_equal(gui, 'qt')
193 nt.assert_equal(s.pylab_gui_select, 'qt')
196 nt.assert_equal(s.pylab_gui_select, 'qt')
194
197
195 gui, backend = s.enable_matplotlib('inline')
198 gui, backend = s.enable_matplotlib('inline')
196 nt.assert_equal(gui, 'inline')
199 nt.assert_equal(gui, 'inline')
197 nt.assert_equal(s.pylab_gui_select, 'qt')
200 nt.assert_equal(s.pylab_gui_select, 'qt')
198
201
199 gui, backend = s.enable_matplotlib()
202 gui, backend = s.enable_matplotlib()
200 nt.assert_equal(gui, 'qt')
203 nt.assert_equal(gui, 'qt')
201 nt.assert_equal(s.pylab_gui_select, 'qt')
204 nt.assert_equal(s.pylab_gui_select, 'qt')
202
205
203 def test_inline(self):
206 def test_inline(self):
204 s = self.Shell()
207 s = self.Shell()
205 gui, backend = s.enable_matplotlib('inline')
208 gui, backend = s.enable_matplotlib('inline')
206 nt.assert_equal(gui, 'inline')
209 nt.assert_equal(gui, 'inline')
207 nt.assert_equal(s.pylab_gui_select, None)
210 nt.assert_equal(s.pylab_gui_select, None)
208
211
209 gui, backend = s.enable_matplotlib('inline')
212 gui, backend = s.enable_matplotlib('inline')
210 nt.assert_equal(gui, 'inline')
213 nt.assert_equal(gui, 'inline')
211 nt.assert_equal(s.pylab_gui_select, None)
214 nt.assert_equal(s.pylab_gui_select, None)
212
215
213 gui, backend = s.enable_matplotlib('qt')
216 gui, backend = s.enable_matplotlib('qt')
214 nt.assert_equal(gui, 'qt')
217 nt.assert_equal(gui, 'qt')
215 nt.assert_equal(s.pylab_gui_select, 'qt')
218 nt.assert_equal(s.pylab_gui_select, 'qt')
216
219
217 def test_inline_twice(self):
220 def test_inline_twice(self):
218 "Using '%matplotlib inline' twice should not reset formatters"
221 "Using '%matplotlib inline' twice should not reset formatters"
219
222
220 ip = self.Shell()
223 ip = self.Shell()
221 gui, backend = ip.enable_matplotlib('inline')
224 gui, backend = ip.enable_matplotlib('inline')
222 nt.assert_equal(gui, 'inline')
225 nt.assert_equal(gui, 'inline')
223
226
224 fmts = {'png'}
227 fmts = {'png'}
225 active_mimes = {_fmt_mime_map[fmt] for fmt in fmts}
228 active_mimes = {_fmt_mime_map[fmt] for fmt in fmts}
226 pt.select_figure_formats(ip, fmts)
229 pt.select_figure_formats(ip, fmts)
227
230
228 gui, backend = ip.enable_matplotlib('inline')
231 gui, backend = ip.enable_matplotlib('inline')
229 nt.assert_equal(gui, 'inline')
232 nt.assert_equal(gui, 'inline')
230
233
231 for mime, f in ip.display_formatter.formatters.items():
234 for mime, f in ip.display_formatter.formatters.items():
232 if mime in active_mimes:
235 if mime in active_mimes:
233 nt.assert_in(Figure, f)
236 nt.assert_in(Figure, f)
234 else:
237 else:
235 nt.assert_not_in(Figure, f)
238 nt.assert_not_in(Figure, f)
236
239
237 def test_qt_gtk(self):
240 def test_qt_gtk(self):
238 s = self.Shell()
241 s = self.Shell()
239 gui, backend = s.enable_matplotlib('qt')
242 gui, backend = s.enable_matplotlib('qt')
240 nt.assert_equal(gui, 'qt')
243 nt.assert_equal(gui, 'qt')
241 nt.assert_equal(s.pylab_gui_select, 'qt')
244 nt.assert_equal(s.pylab_gui_select, 'qt')
242
245
243 gui, backend = s.enable_matplotlib('gtk')
246 gui, backend = s.enable_matplotlib('gtk')
244 nt.assert_equal(gui, 'qt')
247 nt.assert_equal(gui, 'qt')
245 nt.assert_equal(s.pylab_gui_select, 'qt')
248 nt.assert_equal(s.pylab_gui_select, 'qt')
246
249
247
250
248 def test_no_gui_backends():
251 def test_no_gui_backends():
249 for k in ['agg', 'svg', 'pdf', 'ps']:
252 for k in ['agg', 'svg', 'pdf', 'ps']:
250 assert k not in pt.backend2gui
253 assert k not in pt.backend2gui
251
254
252
255
253 def test_figure_no_canvas():
256 def test_figure_no_canvas():
254 fig = Figure()
257 fig = Figure()
255 fig.canvas = None
258 fig.canvas = None
256 pt.print_figure(fig)
259 pt.print_figure(fig)
@@ -1,273 +1,274 b''
1 #!/usr/bin/env python3
1 #!/usr/bin/env python3
2 # -*- coding: utf-8 -*-
2 # -*- coding: utf-8 -*-
3 """Setup script for IPython.
3 """Setup script for IPython.
4
4
5 Under Posix environments it works like a typical setup.py script.
5 Under Posix environments it works like a typical setup.py script.
6 Under Windows, the command sdist is not supported, since IPython
6 Under Windows, the command sdist is not supported, since IPython
7 requires utilities which are not available under Windows."""
7 requires utilities which are not available under Windows."""
8
8
9 #-----------------------------------------------------------------------------
9 #-----------------------------------------------------------------------------
10 # Copyright (c) 2008-2011, IPython Development Team.
10 # Copyright (c) 2008-2011, IPython Development Team.
11 # Copyright (c) 2001-2007, Fernando Perez <fernando.perez@colorado.edu>
11 # Copyright (c) 2001-2007, Fernando Perez <fernando.perez@colorado.edu>
12 # Copyright (c) 2001, Janko Hauser <jhauser@zscout.de>
12 # Copyright (c) 2001, Janko Hauser <jhauser@zscout.de>
13 # Copyright (c) 2001, Nathaniel Gray <n8gray@caltech.edu>
13 # Copyright (c) 2001, Nathaniel Gray <n8gray@caltech.edu>
14 #
14 #
15 # Distributed under the terms of the Modified BSD License.
15 # Distributed under the terms of the Modified BSD License.
16 #
16 #
17 # The full license is in the file COPYING.rst, distributed with this software.
17 # The full license is in the file COPYING.rst, distributed with this software.
18 #-----------------------------------------------------------------------------
18 #-----------------------------------------------------------------------------
19
19
20 from __future__ import print_function
20 from __future__ import print_function
21
21
22 import os
22 import os
23 import sys
23 import sys
24
24
25 # **Python version check**
25 # **Python version check**
26 #
26 #
27 # This check is also made in IPython/__init__, don't forget to update both when
27 # This check is also made in IPython/__init__, don't forget to update both when
28 # changing Python version requirements.
28 # changing Python version requirements.
29 if sys.version_info < (3, 7):
29 if sys.version_info < (3, 7):
30 pip_message = 'This may be due to an out of date pip. Make sure you have pip >= 9.0.1.'
30 pip_message = 'This may be due to an out of date pip. Make sure you have pip >= 9.0.1.'
31 try:
31 try:
32 import pip
32 import pip
33 pip_version = tuple([int(x) for x in pip.__version__.split('.')[:3]])
33 pip_version = tuple([int(x) for x in pip.__version__.split('.')[:3]])
34 if pip_version < (9, 0, 1) :
34 if pip_version < (9, 0, 1) :
35 pip_message = 'Your pip version is out of date, please install pip >= 9.0.1. '\
35 pip_message = 'Your pip version is out of date, please install pip >= 9.0.1. '\
36 'pip {} detected.'.format(pip.__version__)
36 'pip {} detected.'.format(pip.__version__)
37 else:
37 else:
38 # pip is new enough - it must be something else
38 # pip is new enough - it must be something else
39 pip_message = ''
39 pip_message = ''
40 except Exception:
40 except Exception:
41 pass
41 pass
42
42
43
43
44 error = """
44 error = """
45 IPython 7.17+ supports Python 3.7 and above, following NEP 29.
45 IPython 7.17+ supports Python 3.7 and above, following NEP 29.
46 When using Python 2.7, please install IPython 5.x LTS Long Term Support version.
46 When using Python 2.7, please install IPython 5.x LTS Long Term Support version.
47 Python 3.3 and 3.4 were supported up to IPython 6.x.
47 Python 3.3 and 3.4 were supported up to IPython 6.x.
48 Python 3.5 was supported with IPython 7.0 to 7.9.
48 Python 3.5 was supported with IPython 7.0 to 7.9.
49 Python 3.6 was supported with IPython up to 7.16.
49 Python 3.6 was supported with IPython up to 7.16.
50
50
51 See IPython `README.rst` file for more information:
51 See IPython `README.rst` file for more information:
52
52
53 https://github.com/ipython/ipython/blob/master/README.rst
53 https://github.com/ipython/ipython/blob/master/README.rst
54
54
55 Python {py} detected.
55 Python {py} detected.
56 {pip}
56 {pip}
57 """.format(py=sys.version_info, pip=pip_message )
57 """.format(py=sys.version_info, pip=pip_message )
58
58
59 print(error, file=sys.stderr)
59 print(error, file=sys.stderr)
60 sys.exit(1)
60 sys.exit(1)
61
61
62 # At least we're on the python version we need, move on.
62 # At least we're on the python version we need, move on.
63
63
64 # BEFORE importing distutils, remove MANIFEST. distutils doesn't properly
64 # BEFORE importing distutils, remove MANIFEST. distutils doesn't properly
65 # update it when the contents of directories change.
65 # update it when the contents of directories change.
66 if os.path.exists('MANIFEST'): os.remove('MANIFEST')
66 if os.path.exists('MANIFEST'): os.remove('MANIFEST')
67
67
68 from distutils.core import setup
68 from distutils.core import setup
69
69
70 # Our own imports
70 # Our own imports
71 from setupbase import target_update
71 from setupbase import target_update
72
72
73 from setupbase import (
73 from setupbase import (
74 setup_args,
74 setup_args,
75 find_packages,
75 find_packages,
76 find_package_data,
76 find_package_data,
77 check_package_data_first,
77 check_package_data_first,
78 find_entry_points,
78 find_entry_points,
79 build_scripts_entrypt,
79 build_scripts_entrypt,
80 find_data_files,
80 find_data_files,
81 git_prebuild,
81 git_prebuild,
82 install_symlinked,
82 install_symlinked,
83 install_lib_symlink,
83 install_lib_symlink,
84 install_scripts_for_symlink,
84 install_scripts_for_symlink,
85 unsymlink,
85 unsymlink,
86 )
86 )
87
87
88 isfile = os.path.isfile
88 isfile = os.path.isfile
89 pjoin = os.path.join
89 pjoin = os.path.join
90
90
91 #-------------------------------------------------------------------------------
91 #-------------------------------------------------------------------------------
92 # Handle OS specific things
92 # Handle OS specific things
93 #-------------------------------------------------------------------------------
93 #-------------------------------------------------------------------------------
94
94
95 if os.name in ('nt','dos'):
95 if os.name in ('nt','dos'):
96 os_name = 'windows'
96 os_name = 'windows'
97 else:
97 else:
98 os_name = os.name
98 os_name = os.name
99
99
100 # Under Windows, 'sdist' has not been supported. Now that the docs build with
100 # Under Windows, 'sdist' has not been supported. Now that the docs build with
101 # Sphinx it might work, but let's not turn it on until someone confirms that it
101 # Sphinx it might work, but let's not turn it on until someone confirms that it
102 # actually works.
102 # actually works.
103 if os_name == 'windows' and 'sdist' in sys.argv:
103 if os_name == 'windows' and 'sdist' in sys.argv:
104 print('The sdist command is not available under Windows. Exiting.')
104 print('The sdist command is not available under Windows. Exiting.')
105 sys.exit(1)
105 sys.exit(1)
106
106
107
107
108 #-------------------------------------------------------------------------------
108 #-------------------------------------------------------------------------------
109 # Things related to the IPython documentation
109 # Things related to the IPython documentation
110 #-------------------------------------------------------------------------------
110 #-------------------------------------------------------------------------------
111
111
112 # update the manuals when building a source dist
112 # update the manuals when building a source dist
113 if len(sys.argv) >= 2 and sys.argv[1] in ('sdist','bdist_rpm'):
113 if len(sys.argv) >= 2 and sys.argv[1] in ('sdist','bdist_rpm'):
114
114
115 # List of things to be updated. Each entry is a triplet of args for
115 # List of things to be updated. Each entry is a triplet of args for
116 # target_update()
116 # target_update()
117 to_update = [
117 to_update = [
118 ('docs/man/ipython.1.gz',
118 ('docs/man/ipython.1.gz',
119 ['docs/man/ipython.1'],
119 ['docs/man/ipython.1'],
120 'cd docs/man && gzip -9c ipython.1 > ipython.1.gz'),
120 'cd docs/man && gzip -9c ipython.1 > ipython.1.gz'),
121 ]
121 ]
122
122
123
123
124 [ target_update(*t) for t in to_update ]
124 [ target_update(*t) for t in to_update ]
125
125
126 #---------------------------------------------------------------------------
126 #---------------------------------------------------------------------------
127 # Find all the packages, package data, and data_files
127 # Find all the packages, package data, and data_files
128 #---------------------------------------------------------------------------
128 #---------------------------------------------------------------------------
129
129
130 packages = find_packages()
130 packages = find_packages()
131 package_data = find_package_data()
131 package_data = find_package_data()
132
132
133 data_files = find_data_files()
133 data_files = find_data_files()
134
134
135 setup_args['packages'] = packages
135 setup_args['packages'] = packages
136 setup_args['package_data'] = package_data
136 setup_args['package_data'] = package_data
137 setup_args['data_files'] = data_files
137 setup_args['data_files'] = data_files
138
138
139 #---------------------------------------------------------------------------
139 #---------------------------------------------------------------------------
140 # custom distutils commands
140 # custom distutils commands
141 #---------------------------------------------------------------------------
141 #---------------------------------------------------------------------------
142 # imports here, so they are after setuptools import if there was one
142 # imports here, so they are after setuptools import if there was one
143 from distutils.command.sdist import sdist
143 from distutils.command.sdist import sdist
144
144
145 setup_args['cmdclass'] = {
145 setup_args['cmdclass'] = {
146 'build_py': \
146 'build_py': \
147 check_package_data_first(git_prebuild('IPython')),
147 check_package_data_first(git_prebuild('IPython')),
148 'sdist' : git_prebuild('IPython', sdist),
148 'sdist' : git_prebuild('IPython', sdist),
149 'symlink': install_symlinked,
149 'symlink': install_symlinked,
150 'install_lib_symlink': install_lib_symlink,
150 'install_lib_symlink': install_lib_symlink,
151 'install_scripts_sym': install_scripts_for_symlink,
151 'install_scripts_sym': install_scripts_for_symlink,
152 'unsymlink': unsymlink,
152 'unsymlink': unsymlink,
153 }
153 }
154
154
155
155
156 #---------------------------------------------------------------------------
156 #---------------------------------------------------------------------------
157 # Handle scripts, dependencies, and setuptools specific things
157 # Handle scripts, dependencies, and setuptools specific things
158 #---------------------------------------------------------------------------
158 #---------------------------------------------------------------------------
159
159
160 # For some commands, use setuptools. Note that we do NOT list install here!
160 # For some commands, use setuptools. Note that we do NOT list install here!
161 # If you want a setuptools-enhanced install, just run 'setupegg.py install'
161 # If you want a setuptools-enhanced install, just run 'setupegg.py install'
162 needs_setuptools = {'develop', 'release', 'bdist_egg', 'bdist_rpm',
162 needs_setuptools = {'develop', 'release', 'bdist_egg', 'bdist_rpm',
163 'bdist', 'bdist_dumb', 'bdist_wininst', 'bdist_wheel',
163 'bdist', 'bdist_dumb', 'bdist_wininst', 'bdist_wheel',
164 'egg_info', 'easy_install', 'upload', 'install_egg_info',
164 'egg_info', 'easy_install', 'upload', 'install_egg_info',
165 }
165 }
166
166
167 if len(needs_setuptools.intersection(sys.argv)) > 0:
167 if len(needs_setuptools.intersection(sys.argv)) > 0:
168 import setuptools
168 import setuptools
169
169
170 # This dict is used for passing extra arguments that are setuptools
170 # This dict is used for passing extra arguments that are setuptools
171 # specific to setup
171 # specific to setup
172 setuptools_extra_args = {}
172 setuptools_extra_args = {}
173
173
174 # setuptools requirements
174 # setuptools requirements
175
175
176 extras_require = dict(
176 extras_require = dict(
177 parallel=["ipyparallel"],
177 parallel=["ipyparallel"],
178 qtconsole=["qtconsole"],
178 qtconsole=["qtconsole"],
179 doc=["Sphinx>=1.3"],
179 doc=["Sphinx>=1.3"],
180 test=[
180 test=[
181 "nose>=0.10.1",
181 "nose>=0.10.1",
182 "requests",
182 "requests",
183 "testpath",
183 "testpath",
184 "pygments",
184 "pygments",
185 "nbformat",
185 "nbformat",
186 "ipykernel",
186 "ipykernel",
187 "numpy>=1.16",
187 "numpy>=1.16",
188 ],
188 ],
189 terminal=[],
189 terminal=[],
190 kernel=["ipykernel"],
190 kernel=["ipykernel"],
191 nbformat=["nbformat"],
191 nbformat=["nbformat"],
192 notebook=["notebook", "ipywidgets"],
192 notebook=["notebook", "ipywidgets"],
193 nbconvert=["nbconvert"],
193 nbconvert=["nbconvert"],
194 )
194 )
195
195
196 install_requires = [
196 install_requires = [
197 "setuptools>=18.5",
197 "setuptools>=18.5",
198 "jedi>=0.16",
198 "jedi>=0.16",
199 "decorator",
199 "decorator",
200 "pickleshare",
200 "pickleshare",
201 "traitlets>=4.2",
201 "traitlets>=4.2",
202 "prompt_toolkit>=2.0.0,<3.1.0,!=3.0.0,!=3.0.1",
202 "prompt_toolkit>=2.0.0,<3.1.0,!=3.0.0,!=3.0.1",
203 "pygments",
203 "pygments",
204 "backcall",
204 "backcall",
205 "matplotlib-inline",
205 ]
206 ]
206
207
207 # Platform-specific dependencies:
208 # Platform-specific dependencies:
208 # This is the correct way to specify these,
209 # This is the correct way to specify these,
209 # but requires pip >= 6. pip < 6 ignores these.
210 # but requires pip >= 6. pip < 6 ignores these.
210
211
211 extras_require.update(
212 extras_require.update(
212 {
213 {
213 ':sys_platform != "win32"': ["pexpect>4.3"],
214 ':sys_platform != "win32"': ["pexpect>4.3"],
214 ':sys_platform == "darwin"': ["appnope"],
215 ':sys_platform == "darwin"': ["appnope"],
215 ':sys_platform == "win32"': ["colorama"],
216 ':sys_platform == "win32"': ["colorama"],
216 }
217 }
217 )
218 )
218 # FIXME: re-specify above platform dependencies for pip < 6
219 # FIXME: re-specify above platform dependencies for pip < 6
219 # These would result in non-portable bdists.
220 # These would result in non-portable bdists.
220 if not any(arg.startswith('bdist') for arg in sys.argv):
221 if not any(arg.startswith('bdist') for arg in sys.argv):
221 if sys.platform == 'darwin':
222 if sys.platform == 'darwin':
222 install_requires.extend(['appnope'])
223 install_requires.extend(['appnope'])
223
224
224 if not sys.platform.startswith("win"):
225 if not sys.platform.startswith("win"):
225 install_requires.append("pexpect>4.3")
226 install_requires.append("pexpect>4.3")
226
227
227 # workaround pypa/setuptools#147, where setuptools misspells
228 # workaround pypa/setuptools#147, where setuptools misspells
228 # platform_python_implementation as python_implementation
229 # platform_python_implementation as python_implementation
229 if 'setuptools' in sys.modules:
230 if 'setuptools' in sys.modules:
230 for key in list(extras_require):
231 for key in list(extras_require):
231 if 'platform_python_implementation' in key:
232 if 'platform_python_implementation' in key:
232 new_key = key.replace('platform_python_implementation', 'python_implementation')
233 new_key = key.replace('platform_python_implementation', 'python_implementation')
233 extras_require[new_key] = extras_require.pop(key)
234 extras_require[new_key] = extras_require.pop(key)
234
235
235 everything = set()
236 everything = set()
236 for key, deps in extras_require.items():
237 for key, deps in extras_require.items():
237 if ':' not in key:
238 if ':' not in key:
238 everything.update(deps)
239 everything.update(deps)
239 extras_require['all'] = list(sorted(everything))
240 extras_require['all'] = list(sorted(everything))
240
241
241 if 'setuptools' in sys.modules:
242 if 'setuptools' in sys.modules:
242 setuptools_extra_args['python_requires'] = '>=3.7'
243 setuptools_extra_args['python_requires'] = '>=3.7'
243 setuptools_extra_args['zip_safe'] = False
244 setuptools_extra_args['zip_safe'] = False
244 setuptools_extra_args['entry_points'] = {
245 setuptools_extra_args['entry_points'] = {
245 'console_scripts': find_entry_points(),
246 'console_scripts': find_entry_points(),
246 'pygments.lexers': [
247 'pygments.lexers': [
247 'ipythonconsole = IPython.lib.lexers:IPythonConsoleLexer',
248 'ipythonconsole = IPython.lib.lexers:IPythonConsoleLexer',
248 'ipython = IPython.lib.lexers:IPythonLexer',
249 'ipython = IPython.lib.lexers:IPythonLexer',
249 'ipython3 = IPython.lib.lexers:IPython3Lexer',
250 'ipython3 = IPython.lib.lexers:IPython3Lexer',
250 ],
251 ],
251 }
252 }
252 setup_args['extras_require'] = extras_require
253 setup_args['extras_require'] = extras_require
253 setup_args['install_requires'] = install_requires
254 setup_args['install_requires'] = install_requires
254
255
255 else:
256 else:
256 # scripts has to be a non-empty list, or install_scripts isn't called
257 # scripts has to be a non-empty list, or install_scripts isn't called
257 setup_args['scripts'] = [e.split('=')[0].strip() for e in find_entry_points()]
258 setup_args['scripts'] = [e.split('=')[0].strip() for e in find_entry_points()]
258
259
259 setup_args['cmdclass']['build_scripts'] = build_scripts_entrypt
260 setup_args['cmdclass']['build_scripts'] = build_scripts_entrypt
260
261
261 #---------------------------------------------------------------------------
262 #---------------------------------------------------------------------------
262 # Do the actual setup now
263 # Do the actual setup now
263 #---------------------------------------------------------------------------
264 #---------------------------------------------------------------------------
264
265
265 setup_args.update(setuptools_extra_args)
266 setup_args.update(setuptools_extra_args)
266
267
267
268
268
269
269 def main():
270 def main():
270 setup(**setup_args)
271 setup(**setup_args)
271
272
272 if __name__ == '__main__':
273 if __name__ == '__main__':
273 main()
274 main()
General Comments 0
You need to be logged in to leave comments. Login now