##// END OF EJS Templates
Print exception instead of "KeyboardInterrupt"...
Jeroen Demeyer -
Show More
@@ -1,591 +1,591 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """
2 """
3 Pdb debugger class.
3 Pdb debugger class.
4
4
5 Modified from the standard pdb.Pdb class to avoid including readline, so that
5 Modified from the standard pdb.Pdb class to avoid including readline, so that
6 the command line completion of other programs which include this isn't
6 the command line completion of other programs which include this isn't
7 damaged.
7 damaged.
8
8
9 In the future, this class will be expanded with improvements over the standard
9 In the future, this class will be expanded with improvements over the standard
10 pdb.
10 pdb.
11
11
12 The code in this file is mainly lifted out of cmd.py in Python 2.2, with minor
12 The code in this file is mainly lifted out of cmd.py in Python 2.2, with minor
13 changes. Licensing should therefore be under the standard Python terms. For
13 changes. Licensing should therefore be under the standard Python terms. For
14 details on the PSF (Python Software Foundation) standard license, see:
14 details on the PSF (Python Software Foundation) standard license, see:
15
15
16 http://www.python.org/2.2.3/license.html"""
16 http://www.python.org/2.2.3/license.html"""
17
17
18 #*****************************************************************************
18 #*****************************************************************************
19 #
19 #
20 # This file is licensed under the PSF license.
20 # This file is licensed under the PSF license.
21 #
21 #
22 # Copyright (C) 2001 Python Software Foundation, www.python.org
22 # Copyright (C) 2001 Python Software Foundation, www.python.org
23 # Copyright (C) 2005-2006 Fernando Perez. <fperez@colorado.edu>
23 # Copyright (C) 2005-2006 Fernando Perez. <fperez@colorado.edu>
24 #
24 #
25 #
25 #
26 #*****************************************************************************
26 #*****************************************************************************
27 from __future__ import print_function
27 from __future__ import print_function
28
28
29 import bdb
29 import bdb
30 import functools
30 import functools
31 import linecache
31 import linecache
32 import sys
32 import sys
33
33
34 from IPython import get_ipython
34 from IPython import get_ipython
35 from IPython.utils import PyColorize, ulinecache
35 from IPython.utils import PyColorize, ulinecache
36 from IPython.utils import coloransi, io, py3compat
36 from IPython.utils import coloransi, io, py3compat
37 from IPython.core.excolors import exception_colors
37 from IPython.core.excolors import exception_colors
38 from IPython.testing.skipdoctest import skip_doctest
38 from IPython.testing.skipdoctest import skip_doctest
39
39
40 # See if we can use pydb.
40 # See if we can use pydb.
41 has_pydb = False
41 has_pydb = False
42 prompt = 'ipdb> '
42 prompt = 'ipdb> '
43 #We have to check this directly from sys.argv, config struct not yet available
43 #We have to check this directly from sys.argv, config struct not yet available
44 if '--pydb' in sys.argv:
44 if '--pydb' in sys.argv:
45 try:
45 try:
46 import pydb
46 import pydb
47 if hasattr(pydb.pydb, "runl") and pydb.version>'1.17':
47 if hasattr(pydb.pydb, "runl") and pydb.version>'1.17':
48 # Version 1.17 is broken, and that's what ships with Ubuntu Edgy, so we
48 # Version 1.17 is broken, and that's what ships with Ubuntu Edgy, so we
49 # better protect against it.
49 # better protect against it.
50 has_pydb = True
50 has_pydb = True
51 except ImportError:
51 except ImportError:
52 print("Pydb (http://bashdb.sourceforge.net/pydb/) does not seem to be available")
52 print("Pydb (http://bashdb.sourceforge.net/pydb/) does not seem to be available")
53
53
54 if has_pydb:
54 if has_pydb:
55 from pydb import Pdb as OldPdb
55 from pydb import Pdb as OldPdb
56 #print "Using pydb for %run -d and post-mortem" #dbg
56 #print "Using pydb for %run -d and post-mortem" #dbg
57 prompt = 'ipydb> '
57 prompt = 'ipydb> '
58 else:
58 else:
59 from pdb import Pdb as OldPdb
59 from pdb import Pdb as OldPdb
60
60
61 # Allow the set_trace code to operate outside of an ipython instance, even if
61 # Allow the set_trace code to operate outside of an ipython instance, even if
62 # it does so with some limitations. The rest of this support is implemented in
62 # it does so with some limitations. The rest of this support is implemented in
63 # the Tracer constructor.
63 # the Tracer constructor.
64 def BdbQuit_excepthook(et, ev, tb, excepthook=None):
64 def BdbQuit_excepthook(et, ev, tb, excepthook=None):
65 """Exception hook which handles `BdbQuit` exceptions.
65 """Exception hook which handles `BdbQuit` exceptions.
66
66
67 All other exceptions are processed using the `excepthook`
67 All other exceptions are processed using the `excepthook`
68 parameter.
68 parameter.
69 """
69 """
70 if et==bdb.BdbQuit:
70 if et==bdb.BdbQuit:
71 print('Exiting Debugger.')
71 print('Exiting Debugger.')
72 elif excepthook is not None:
72 elif excepthook is not None:
73 excepthook(et, ev, tb)
73 excepthook(et, ev, tb)
74 else:
74 else:
75 # Backwards compatibility. Raise deprecation warning?
75 # Backwards compatibility. Raise deprecation warning?
76 BdbQuit_excepthook.excepthook_ori(et,ev,tb)
76 BdbQuit_excepthook.excepthook_ori(et,ev,tb)
77
77
78 def BdbQuit_IPython_excepthook(self,et,ev,tb,tb_offset=None):
78 def BdbQuit_IPython_excepthook(self,et,ev,tb,tb_offset=None):
79 print('Exiting Debugger.')
79 print('Exiting Debugger.')
80
80
81
81
82 class Tracer(object):
82 class Tracer(object):
83 """Class for local debugging, similar to pdb.set_trace.
83 """Class for local debugging, similar to pdb.set_trace.
84
84
85 Instances of this class, when called, behave like pdb.set_trace, but
85 Instances of this class, when called, behave like pdb.set_trace, but
86 providing IPython's enhanced capabilities.
86 providing IPython's enhanced capabilities.
87
87
88 This is implemented as a class which must be initialized in your own code
88 This is implemented as a class which must be initialized in your own code
89 and not as a standalone function because we need to detect at runtime
89 and not as a standalone function because we need to detect at runtime
90 whether IPython is already active or not. That detection is done in the
90 whether IPython is already active or not. That detection is done in the
91 constructor, ensuring that this code plays nicely with a running IPython,
91 constructor, ensuring that this code plays nicely with a running IPython,
92 while functioning acceptably (though with limitations) if outside of it.
92 while functioning acceptably (though with limitations) if outside of it.
93 """
93 """
94
94
95 @skip_doctest
95 @skip_doctest
96 def __init__(self,colors=None):
96 def __init__(self,colors=None):
97 """Create a local debugger instance.
97 """Create a local debugger instance.
98
98
99 Parameters
99 Parameters
100 ----------
100 ----------
101
101
102 colors : str, optional
102 colors : str, optional
103 The name of the color scheme to use, it must be one of IPython's
103 The name of the color scheme to use, it must be one of IPython's
104 valid color schemes. If not given, the function will default to
104 valid color schemes. If not given, the function will default to
105 the current IPython scheme when running inside IPython, and to
105 the current IPython scheme when running inside IPython, and to
106 'NoColor' otherwise.
106 'NoColor' otherwise.
107
107
108 Examples
108 Examples
109 --------
109 --------
110 ::
110 ::
111
111
112 from IPython.core.debugger import Tracer; debug_here = Tracer()
112 from IPython.core.debugger import Tracer; debug_here = Tracer()
113
113
114 Later in your code::
114 Later in your code::
115
115
116 debug_here() # -> will open up the debugger at that point.
116 debug_here() # -> will open up the debugger at that point.
117
117
118 Once the debugger activates, you can use all of its regular commands to
118 Once the debugger activates, you can use all of its regular commands to
119 step through code, set breakpoints, etc. See the pdb documentation
119 step through code, set breakpoints, etc. See the pdb documentation
120 from the Python standard library for usage details.
120 from the Python standard library for usage details.
121 """
121 """
122
122
123 ip = get_ipython()
123 ip = get_ipython()
124 if ip is None:
124 if ip is None:
125 # Outside of ipython, we set our own exception hook manually
125 # Outside of ipython, we set our own exception hook manually
126 sys.excepthook = functools.partial(BdbQuit_excepthook,
126 sys.excepthook = functools.partial(BdbQuit_excepthook,
127 excepthook=sys.excepthook)
127 excepthook=sys.excepthook)
128 def_colors = 'NoColor'
128 def_colors = 'NoColor'
129 try:
129 try:
130 # Limited tab completion support
130 # Limited tab completion support
131 import readline
131 import readline
132 readline.parse_and_bind('tab: complete')
132 readline.parse_and_bind('tab: complete')
133 except ImportError:
133 except ImportError:
134 pass
134 pass
135 else:
135 else:
136 # In ipython, we use its custom exception handler mechanism
136 # In ipython, we use its custom exception handler mechanism
137 def_colors = ip.colors
137 def_colors = ip.colors
138 ip.set_custom_exc((bdb.BdbQuit,), BdbQuit_IPython_excepthook)
138 ip.set_custom_exc((bdb.BdbQuit,), BdbQuit_IPython_excepthook)
139
139
140 if colors is None:
140 if colors is None:
141 colors = def_colors
141 colors = def_colors
142
142
143 # The stdlib debugger internally uses a modified repr from the `repr`
143 # The stdlib debugger internally uses a modified repr from the `repr`
144 # module, that limits the length of printed strings to a hardcoded
144 # module, that limits the length of printed strings to a hardcoded
145 # limit of 30 characters. That much trimming is too aggressive, let's
145 # limit of 30 characters. That much trimming is too aggressive, let's
146 # at least raise that limit to 80 chars, which should be enough for
146 # at least raise that limit to 80 chars, which should be enough for
147 # most interactive uses.
147 # most interactive uses.
148 try:
148 try:
149 try:
149 try:
150 from reprlib import aRepr # Py 3
150 from reprlib import aRepr # Py 3
151 except ImportError:
151 except ImportError:
152 from repr import aRepr # Py 2
152 from repr import aRepr # Py 2
153 aRepr.maxstring = 80
153 aRepr.maxstring = 80
154 except:
154 except:
155 # This is only a user-facing convenience, so any error we encounter
155 # This is only a user-facing convenience, so any error we encounter
156 # here can be warned about but can be otherwise ignored. These
156 # here can be warned about but can be otherwise ignored. These
157 # printouts will tell us about problems if this API changes
157 # printouts will tell us about problems if this API changes
158 import traceback
158 import traceback
159 traceback.print_exc()
159 traceback.print_exc()
160
160
161 self.debugger = Pdb(colors)
161 self.debugger = Pdb(colors)
162
162
163 def __call__(self):
163 def __call__(self):
164 """Starts an interactive debugger at the point where called.
164 """Starts an interactive debugger at the point where called.
165
165
166 This is similar to the pdb.set_trace() function from the std lib, but
166 This is similar to the pdb.set_trace() function from the std lib, but
167 using IPython's enhanced debugger."""
167 using IPython's enhanced debugger."""
168
168
169 self.debugger.set_trace(sys._getframe().f_back)
169 self.debugger.set_trace(sys._getframe().f_back)
170
170
171
171
172 def decorate_fn_with_doc(new_fn, old_fn, additional_text=""):
172 def decorate_fn_with_doc(new_fn, old_fn, additional_text=""):
173 """Make new_fn have old_fn's doc string. This is particularly useful
173 """Make new_fn have old_fn's doc string. This is particularly useful
174 for the ``do_...`` commands that hook into the help system.
174 for the ``do_...`` commands that hook into the help system.
175 Adapted from from a comp.lang.python posting
175 Adapted from from a comp.lang.python posting
176 by Duncan Booth."""
176 by Duncan Booth."""
177 def wrapper(*args, **kw):
177 def wrapper(*args, **kw):
178 return new_fn(*args, **kw)
178 return new_fn(*args, **kw)
179 if old_fn.__doc__:
179 if old_fn.__doc__:
180 wrapper.__doc__ = old_fn.__doc__ + additional_text
180 wrapper.__doc__ = old_fn.__doc__ + additional_text
181 return wrapper
181 return wrapper
182
182
183
183
184 def _file_lines(fname):
184 def _file_lines(fname):
185 """Return the contents of a named file as a list of lines.
185 """Return the contents of a named file as a list of lines.
186
186
187 This function never raises an IOError exception: if the file can't be
187 This function never raises an IOError exception: if the file can't be
188 read, it simply returns an empty list."""
188 read, it simply returns an empty list."""
189
189
190 try:
190 try:
191 outfile = open(fname)
191 outfile = open(fname)
192 except IOError:
192 except IOError:
193 return []
193 return []
194 else:
194 else:
195 out = outfile.readlines()
195 out = outfile.readlines()
196 outfile.close()
196 outfile.close()
197 return out
197 return out
198
198
199
199
200 class Pdb(OldPdb):
200 class Pdb(OldPdb):
201 """Modified Pdb class, does not load readline."""
201 """Modified Pdb class, does not load readline."""
202
202
203 def __init__(self,color_scheme='NoColor',completekey=None,
203 def __init__(self,color_scheme='NoColor',completekey=None,
204 stdin=None, stdout=None):
204 stdin=None, stdout=None):
205
205
206 # Parent constructor:
206 # Parent constructor:
207 if has_pydb and completekey is None:
207 if has_pydb and completekey is None:
208 OldPdb.__init__(self,stdin=stdin,stdout=io.stdout)
208 OldPdb.__init__(self,stdin=stdin,stdout=io.stdout)
209 else:
209 else:
210 OldPdb.__init__(self,completekey,stdin,stdout)
210 OldPdb.__init__(self,completekey,stdin,stdout)
211
211
212 self.prompt = prompt # The default prompt is '(Pdb)'
212 self.prompt = prompt # The default prompt is '(Pdb)'
213
213
214 # IPython changes...
214 # IPython changes...
215 self.is_pydb = has_pydb
215 self.is_pydb = has_pydb
216
216
217 self.shell = get_ipython()
217 self.shell = get_ipython()
218
218
219 if self.shell is None:
219 if self.shell is None:
220 # No IPython instance running, we must create one
220 # No IPython instance running, we must create one
221 from IPython.terminal.interactiveshell import \
221 from IPython.terminal.interactiveshell import \
222 TerminalInteractiveShell
222 TerminalInteractiveShell
223 self.shell = TerminalInteractiveShell.instance()
223 self.shell = TerminalInteractiveShell.instance()
224
224
225 if self.is_pydb:
225 if self.is_pydb:
226
226
227 # interactiveshell.py's ipalias seems to want pdb's checkline
227 # interactiveshell.py's ipalias seems to want pdb's checkline
228 # which located in pydb.fn
228 # which located in pydb.fn
229 import pydb.fns
229 import pydb.fns
230 self.checkline = lambda filename, lineno: \
230 self.checkline = lambda filename, lineno: \
231 pydb.fns.checkline(self, filename, lineno)
231 pydb.fns.checkline(self, filename, lineno)
232
232
233 self.curframe = None
233 self.curframe = None
234 self.do_restart = self.new_do_restart
234 self.do_restart = self.new_do_restart
235
235
236 self.old_all_completions = self.shell.Completer.all_completions
236 self.old_all_completions = self.shell.Completer.all_completions
237 self.shell.Completer.all_completions=self.all_completions
237 self.shell.Completer.all_completions=self.all_completions
238
238
239 self.do_list = decorate_fn_with_doc(self.list_command_pydb,
239 self.do_list = decorate_fn_with_doc(self.list_command_pydb,
240 OldPdb.do_list)
240 OldPdb.do_list)
241 self.do_l = self.do_list
241 self.do_l = self.do_list
242 self.do_frame = decorate_fn_with_doc(self.new_do_frame,
242 self.do_frame = decorate_fn_with_doc(self.new_do_frame,
243 OldPdb.do_frame)
243 OldPdb.do_frame)
244
244
245 self.aliases = {}
245 self.aliases = {}
246
246
247 # Create color table: we copy the default one from the traceback
247 # Create color table: we copy the default one from the traceback
248 # module and add a few attributes needed for debugging
248 # module and add a few attributes needed for debugging
249 self.color_scheme_table = exception_colors()
249 self.color_scheme_table = exception_colors()
250
250
251 # shorthands
251 # shorthands
252 C = coloransi.TermColors
252 C = coloransi.TermColors
253 cst = self.color_scheme_table
253 cst = self.color_scheme_table
254
254
255 cst['NoColor'].colors.breakpoint_enabled = C.NoColor
255 cst['NoColor'].colors.breakpoint_enabled = C.NoColor
256 cst['NoColor'].colors.breakpoint_disabled = C.NoColor
256 cst['NoColor'].colors.breakpoint_disabled = C.NoColor
257
257
258 cst['Linux'].colors.breakpoint_enabled = C.LightRed
258 cst['Linux'].colors.breakpoint_enabled = C.LightRed
259 cst['Linux'].colors.breakpoint_disabled = C.Red
259 cst['Linux'].colors.breakpoint_disabled = C.Red
260
260
261 cst['LightBG'].colors.breakpoint_enabled = C.LightRed
261 cst['LightBG'].colors.breakpoint_enabled = C.LightRed
262 cst['LightBG'].colors.breakpoint_disabled = C.Red
262 cst['LightBG'].colors.breakpoint_disabled = C.Red
263
263
264 self.set_colors(color_scheme)
264 self.set_colors(color_scheme)
265
265
266 # Add a python parser so we can syntax highlight source while
266 # Add a python parser so we can syntax highlight source while
267 # debugging.
267 # debugging.
268 self.parser = PyColorize.Parser()
268 self.parser = PyColorize.Parser()
269
269
270 def set_colors(self, scheme):
270 def set_colors(self, scheme):
271 """Shorthand access to the color table scheme selector method."""
271 """Shorthand access to the color table scheme selector method."""
272 self.color_scheme_table.set_active_scheme(scheme)
272 self.color_scheme_table.set_active_scheme(scheme)
273
273
274 def interaction(self, frame, traceback):
274 def interaction(self, frame, traceback):
275 self.shell.set_completer_frame(frame)
275 self.shell.set_completer_frame(frame)
276 while True:
276 while True:
277 try:
277 try:
278 OldPdb.interaction(self, frame, traceback)
278 OldPdb.interaction(self, frame, traceback)
279 except KeyboardInterrupt:
279 except KeyboardInterrupt:
280 self.shell.write("\nKeyboardInterrupt\n")
280 self.shell.write('\n' + self.shell.get_exception_only())
281 break
281 break
282 else:
282 else:
283 break
283 break
284
284
285 def new_do_up(self, arg):
285 def new_do_up(self, arg):
286 OldPdb.do_up(self, arg)
286 OldPdb.do_up(self, arg)
287 self.shell.set_completer_frame(self.curframe)
287 self.shell.set_completer_frame(self.curframe)
288 do_u = do_up = decorate_fn_with_doc(new_do_up, OldPdb.do_up)
288 do_u = do_up = decorate_fn_with_doc(new_do_up, OldPdb.do_up)
289
289
290 def new_do_down(self, arg):
290 def new_do_down(self, arg):
291 OldPdb.do_down(self, arg)
291 OldPdb.do_down(self, arg)
292 self.shell.set_completer_frame(self.curframe)
292 self.shell.set_completer_frame(self.curframe)
293
293
294 do_d = do_down = decorate_fn_with_doc(new_do_down, OldPdb.do_down)
294 do_d = do_down = decorate_fn_with_doc(new_do_down, OldPdb.do_down)
295
295
296 def new_do_frame(self, arg):
296 def new_do_frame(self, arg):
297 OldPdb.do_frame(self, arg)
297 OldPdb.do_frame(self, arg)
298 self.shell.set_completer_frame(self.curframe)
298 self.shell.set_completer_frame(self.curframe)
299
299
300 def new_do_quit(self, arg):
300 def new_do_quit(self, arg):
301
301
302 if hasattr(self, 'old_all_completions'):
302 if hasattr(self, 'old_all_completions'):
303 self.shell.Completer.all_completions=self.old_all_completions
303 self.shell.Completer.all_completions=self.old_all_completions
304
304
305
305
306 return OldPdb.do_quit(self, arg)
306 return OldPdb.do_quit(self, arg)
307
307
308 do_q = do_quit = decorate_fn_with_doc(new_do_quit, OldPdb.do_quit)
308 do_q = do_quit = decorate_fn_with_doc(new_do_quit, OldPdb.do_quit)
309
309
310 def new_do_restart(self, arg):
310 def new_do_restart(self, arg):
311 """Restart command. In the context of ipython this is exactly the same
311 """Restart command. In the context of ipython this is exactly the same
312 thing as 'quit'."""
312 thing as 'quit'."""
313 self.msg("Restart doesn't make sense here. Using 'quit' instead.")
313 self.msg("Restart doesn't make sense here. Using 'quit' instead.")
314 return self.do_quit(arg)
314 return self.do_quit(arg)
315
315
316 def postloop(self):
316 def postloop(self):
317 self.shell.set_completer_frame(None)
317 self.shell.set_completer_frame(None)
318
318
319 def print_stack_trace(self):
319 def print_stack_trace(self):
320 try:
320 try:
321 for frame_lineno in self.stack:
321 for frame_lineno in self.stack:
322 self.print_stack_entry(frame_lineno, context = 5)
322 self.print_stack_entry(frame_lineno, context = 5)
323 except KeyboardInterrupt:
323 except KeyboardInterrupt:
324 pass
324 pass
325
325
326 def print_stack_entry(self,frame_lineno,prompt_prefix='\n-> ',
326 def print_stack_entry(self,frame_lineno,prompt_prefix='\n-> ',
327 context = 3):
327 context = 3):
328 #frame, lineno = frame_lineno
328 #frame, lineno = frame_lineno
329 print(self.format_stack_entry(frame_lineno, '', context), file=io.stdout)
329 print(self.format_stack_entry(frame_lineno, '', context), file=io.stdout)
330
330
331 # vds: >>
331 # vds: >>
332 frame, lineno = frame_lineno
332 frame, lineno = frame_lineno
333 filename = frame.f_code.co_filename
333 filename = frame.f_code.co_filename
334 self.shell.hooks.synchronize_with_editor(filename, lineno, 0)
334 self.shell.hooks.synchronize_with_editor(filename, lineno, 0)
335 # vds: <<
335 # vds: <<
336
336
337 def format_stack_entry(self, frame_lineno, lprefix=': ', context = 3):
337 def format_stack_entry(self, frame_lineno, lprefix=': ', context = 3):
338 try:
338 try:
339 import reprlib # Py 3
339 import reprlib # Py 3
340 except ImportError:
340 except ImportError:
341 import repr as reprlib # Py 2
341 import repr as reprlib # Py 2
342
342
343 ret = []
343 ret = []
344
344
345 Colors = self.color_scheme_table.active_colors
345 Colors = self.color_scheme_table.active_colors
346 ColorsNormal = Colors.Normal
346 ColorsNormal = Colors.Normal
347 tpl_link = u'%s%%s%s' % (Colors.filenameEm, ColorsNormal)
347 tpl_link = u'%s%%s%s' % (Colors.filenameEm, ColorsNormal)
348 tpl_call = u'%s%%s%s%%s%s' % (Colors.vName, Colors.valEm, ColorsNormal)
348 tpl_call = u'%s%%s%s%%s%s' % (Colors.vName, Colors.valEm, ColorsNormal)
349 tpl_line = u'%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
349 tpl_line = u'%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
350 tpl_line_em = u'%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line,
350 tpl_line_em = u'%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line,
351 ColorsNormal)
351 ColorsNormal)
352
352
353 frame, lineno = frame_lineno
353 frame, lineno = frame_lineno
354
354
355 return_value = ''
355 return_value = ''
356 if '__return__' in frame.f_locals:
356 if '__return__' in frame.f_locals:
357 rv = frame.f_locals['__return__']
357 rv = frame.f_locals['__return__']
358 #return_value += '->'
358 #return_value += '->'
359 return_value += reprlib.repr(rv) + '\n'
359 return_value += reprlib.repr(rv) + '\n'
360 ret.append(return_value)
360 ret.append(return_value)
361
361
362 #s = filename + '(' + `lineno` + ')'
362 #s = filename + '(' + `lineno` + ')'
363 filename = self.canonic(frame.f_code.co_filename)
363 filename = self.canonic(frame.f_code.co_filename)
364 link = tpl_link % py3compat.cast_unicode(filename)
364 link = tpl_link % py3compat.cast_unicode(filename)
365
365
366 if frame.f_code.co_name:
366 if frame.f_code.co_name:
367 func = frame.f_code.co_name
367 func = frame.f_code.co_name
368 else:
368 else:
369 func = "<lambda>"
369 func = "<lambda>"
370
370
371 call = ''
371 call = ''
372 if func != '?':
372 if func != '?':
373 if '__args__' in frame.f_locals:
373 if '__args__' in frame.f_locals:
374 args = reprlib.repr(frame.f_locals['__args__'])
374 args = reprlib.repr(frame.f_locals['__args__'])
375 else:
375 else:
376 args = '()'
376 args = '()'
377 call = tpl_call % (func, args)
377 call = tpl_call % (func, args)
378
378
379 # The level info should be generated in the same format pdb uses, to
379 # The level info should be generated in the same format pdb uses, to
380 # avoid breaking the pdbtrack functionality of python-mode in *emacs.
380 # avoid breaking the pdbtrack functionality of python-mode in *emacs.
381 if frame is self.curframe:
381 if frame is self.curframe:
382 ret.append('> ')
382 ret.append('> ')
383 else:
383 else:
384 ret.append(' ')
384 ret.append(' ')
385 ret.append(u'%s(%s)%s\n' % (link,lineno,call))
385 ret.append(u'%s(%s)%s\n' % (link,lineno,call))
386
386
387 start = lineno - 1 - context//2
387 start = lineno - 1 - context//2
388 lines = ulinecache.getlines(filename)
388 lines = ulinecache.getlines(filename)
389 start = min(start, len(lines) - context)
389 start = min(start, len(lines) - context)
390 start = max(start, 0)
390 start = max(start, 0)
391 lines = lines[start : start + context]
391 lines = lines[start : start + context]
392
392
393 for i,line in enumerate(lines):
393 for i,line in enumerate(lines):
394 show_arrow = (start + 1 + i == lineno)
394 show_arrow = (start + 1 + i == lineno)
395 linetpl = (frame is self.curframe or show_arrow) \
395 linetpl = (frame is self.curframe or show_arrow) \
396 and tpl_line_em \
396 and tpl_line_em \
397 or tpl_line
397 or tpl_line
398 ret.append(self.__format_line(linetpl, filename,
398 ret.append(self.__format_line(linetpl, filename,
399 start + 1 + i, line,
399 start + 1 + i, line,
400 arrow = show_arrow) )
400 arrow = show_arrow) )
401 return ''.join(ret)
401 return ''.join(ret)
402
402
403 def __format_line(self, tpl_line, filename, lineno, line, arrow = False):
403 def __format_line(self, tpl_line, filename, lineno, line, arrow = False):
404 bp_mark = ""
404 bp_mark = ""
405 bp_mark_color = ""
405 bp_mark_color = ""
406
406
407 scheme = self.color_scheme_table.active_scheme_name
407 scheme = self.color_scheme_table.active_scheme_name
408 new_line, err = self.parser.format2(line, 'str', scheme)
408 new_line, err = self.parser.format2(line, 'str', scheme)
409 if not err: line = new_line
409 if not err: line = new_line
410
410
411 bp = None
411 bp = None
412 if lineno in self.get_file_breaks(filename):
412 if lineno in self.get_file_breaks(filename):
413 bps = self.get_breaks(filename, lineno)
413 bps = self.get_breaks(filename, lineno)
414 bp = bps[-1]
414 bp = bps[-1]
415
415
416 if bp:
416 if bp:
417 Colors = self.color_scheme_table.active_colors
417 Colors = self.color_scheme_table.active_colors
418 bp_mark = str(bp.number)
418 bp_mark = str(bp.number)
419 bp_mark_color = Colors.breakpoint_enabled
419 bp_mark_color = Colors.breakpoint_enabled
420 if not bp.enabled:
420 if not bp.enabled:
421 bp_mark_color = Colors.breakpoint_disabled
421 bp_mark_color = Colors.breakpoint_disabled
422
422
423 numbers_width = 7
423 numbers_width = 7
424 if arrow:
424 if arrow:
425 # This is the line with the error
425 # This is the line with the error
426 pad = numbers_width - len(str(lineno)) - len(bp_mark)
426 pad = numbers_width - len(str(lineno)) - len(bp_mark)
427 if pad >= 3:
427 if pad >= 3:
428 marker = '-'*(pad-3) + '-> '
428 marker = '-'*(pad-3) + '-> '
429 elif pad == 2:
429 elif pad == 2:
430 marker = '> '
430 marker = '> '
431 elif pad == 1:
431 elif pad == 1:
432 marker = '>'
432 marker = '>'
433 else:
433 else:
434 marker = ''
434 marker = ''
435 num = '%s%s' % (marker, str(lineno))
435 num = '%s%s' % (marker, str(lineno))
436 line = tpl_line % (bp_mark_color + bp_mark, num, line)
436 line = tpl_line % (bp_mark_color + bp_mark, num, line)
437 else:
437 else:
438 num = '%*s' % (numbers_width - len(bp_mark), str(lineno))
438 num = '%*s' % (numbers_width - len(bp_mark), str(lineno))
439 line = tpl_line % (bp_mark_color + bp_mark, num, line)
439 line = tpl_line % (bp_mark_color + bp_mark, num, line)
440
440
441 return line
441 return line
442
442
443 def list_command_pydb(self, arg):
443 def list_command_pydb(self, arg):
444 """List command to use if we have a newer pydb installed"""
444 """List command to use if we have a newer pydb installed"""
445 filename, first, last = OldPdb.parse_list_cmd(self, arg)
445 filename, first, last = OldPdb.parse_list_cmd(self, arg)
446 if filename is not None:
446 if filename is not None:
447 self.print_list_lines(filename, first, last)
447 self.print_list_lines(filename, first, last)
448
448
449 def print_list_lines(self, filename, first, last):
449 def print_list_lines(self, filename, first, last):
450 """The printing (as opposed to the parsing part of a 'list'
450 """The printing (as opposed to the parsing part of a 'list'
451 command."""
451 command."""
452 try:
452 try:
453 Colors = self.color_scheme_table.active_colors
453 Colors = self.color_scheme_table.active_colors
454 ColorsNormal = Colors.Normal
454 ColorsNormal = Colors.Normal
455 tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
455 tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
456 tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line, ColorsNormal)
456 tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line, ColorsNormal)
457 src = []
457 src = []
458 if filename == "<string>" and hasattr(self, "_exec_filename"):
458 if filename == "<string>" and hasattr(self, "_exec_filename"):
459 filename = self._exec_filename
459 filename = self._exec_filename
460
460
461 for lineno in range(first, last+1):
461 for lineno in range(first, last+1):
462 line = ulinecache.getline(filename, lineno)
462 line = ulinecache.getline(filename, lineno)
463 if not line:
463 if not line:
464 break
464 break
465
465
466 if lineno == self.curframe.f_lineno:
466 if lineno == self.curframe.f_lineno:
467 line = self.__format_line(tpl_line_em, filename, lineno, line, arrow = True)
467 line = self.__format_line(tpl_line_em, filename, lineno, line, arrow = True)
468 else:
468 else:
469 line = self.__format_line(tpl_line, filename, lineno, line, arrow = False)
469 line = self.__format_line(tpl_line, filename, lineno, line, arrow = False)
470
470
471 src.append(line)
471 src.append(line)
472 self.lineno = lineno
472 self.lineno = lineno
473
473
474 print(''.join(src), file=io.stdout)
474 print(''.join(src), file=io.stdout)
475
475
476 except KeyboardInterrupt:
476 except KeyboardInterrupt:
477 pass
477 pass
478
478
479 def do_list(self, arg):
479 def do_list(self, arg):
480 self.lastcmd = 'list'
480 self.lastcmd = 'list'
481 last = None
481 last = None
482 if arg:
482 if arg:
483 try:
483 try:
484 x = eval(arg, {}, {})
484 x = eval(arg, {}, {})
485 if type(x) == type(()):
485 if type(x) == type(()):
486 first, last = x
486 first, last = x
487 first = int(first)
487 first = int(first)
488 last = int(last)
488 last = int(last)
489 if last < first:
489 if last < first:
490 # Assume it's a count
490 # Assume it's a count
491 last = first + last
491 last = first + last
492 else:
492 else:
493 first = max(1, int(x) - 5)
493 first = max(1, int(x) - 5)
494 except:
494 except:
495 print('*** Error in argument:', repr(arg))
495 print('*** Error in argument:', repr(arg))
496 return
496 return
497 elif self.lineno is None:
497 elif self.lineno is None:
498 first = max(1, self.curframe.f_lineno - 5)
498 first = max(1, self.curframe.f_lineno - 5)
499 else:
499 else:
500 first = self.lineno + 1
500 first = self.lineno + 1
501 if last is None:
501 if last is None:
502 last = first + 10
502 last = first + 10
503 self.print_list_lines(self.curframe.f_code.co_filename, first, last)
503 self.print_list_lines(self.curframe.f_code.co_filename, first, last)
504
504
505 # vds: >>
505 # vds: >>
506 lineno = first
506 lineno = first
507 filename = self.curframe.f_code.co_filename
507 filename = self.curframe.f_code.co_filename
508 self.shell.hooks.synchronize_with_editor(filename, lineno, 0)
508 self.shell.hooks.synchronize_with_editor(filename, lineno, 0)
509 # vds: <<
509 # vds: <<
510
510
511 do_l = do_list
511 do_l = do_list
512
512
513 def do_pdef(self, arg):
513 def do_pdef(self, arg):
514 """Print the call signature for any callable object.
514 """Print the call signature for any callable object.
515
515
516 The debugger interface to %pdef"""
516 The debugger interface to %pdef"""
517 namespaces = [('Locals', self.curframe.f_locals),
517 namespaces = [('Locals', self.curframe.f_locals),
518 ('Globals', self.curframe.f_globals)]
518 ('Globals', self.curframe.f_globals)]
519 self.shell.find_line_magic('pdef')(arg, namespaces=namespaces)
519 self.shell.find_line_magic('pdef')(arg, namespaces=namespaces)
520
520
521 def do_pdoc(self, arg):
521 def do_pdoc(self, arg):
522 """Print the docstring for an object.
522 """Print the docstring for an object.
523
523
524 The debugger interface to %pdoc."""
524 The debugger interface to %pdoc."""
525 namespaces = [('Locals', self.curframe.f_locals),
525 namespaces = [('Locals', self.curframe.f_locals),
526 ('Globals', self.curframe.f_globals)]
526 ('Globals', self.curframe.f_globals)]
527 self.shell.find_line_magic('pdoc')(arg, namespaces=namespaces)
527 self.shell.find_line_magic('pdoc')(arg, namespaces=namespaces)
528
528
529 def do_pfile(self, arg):
529 def do_pfile(self, arg):
530 """Print (or run through pager) the file where an object is defined.
530 """Print (or run through pager) the file where an object is defined.
531
531
532 The debugger interface to %pfile.
532 The debugger interface to %pfile.
533 """
533 """
534 namespaces = [('Locals', self.curframe.f_locals),
534 namespaces = [('Locals', self.curframe.f_locals),
535 ('Globals', self.curframe.f_globals)]
535 ('Globals', self.curframe.f_globals)]
536 self.shell.find_line_magic('pfile')(arg, namespaces=namespaces)
536 self.shell.find_line_magic('pfile')(arg, namespaces=namespaces)
537
537
538 def do_pinfo(self, arg):
538 def do_pinfo(self, arg):
539 """Provide detailed information about an object.
539 """Provide detailed information about an object.
540
540
541 The debugger interface to %pinfo, i.e., obj?."""
541 The debugger interface to %pinfo, i.e., obj?."""
542 namespaces = [('Locals', self.curframe.f_locals),
542 namespaces = [('Locals', self.curframe.f_locals),
543 ('Globals', self.curframe.f_globals)]
543 ('Globals', self.curframe.f_globals)]
544 self.shell.find_line_magic('pinfo')(arg, namespaces=namespaces)
544 self.shell.find_line_magic('pinfo')(arg, namespaces=namespaces)
545
545
546 def do_pinfo2(self, arg):
546 def do_pinfo2(self, arg):
547 """Provide extra detailed information about an object.
547 """Provide extra detailed information about an object.
548
548
549 The debugger interface to %pinfo2, i.e., obj??."""
549 The debugger interface to %pinfo2, i.e., obj??."""
550 namespaces = [('Locals', self.curframe.f_locals),
550 namespaces = [('Locals', self.curframe.f_locals),
551 ('Globals', self.curframe.f_globals)]
551 ('Globals', self.curframe.f_globals)]
552 self.shell.find_line_magic('pinfo2')(arg, namespaces=namespaces)
552 self.shell.find_line_magic('pinfo2')(arg, namespaces=namespaces)
553
553
554 def do_psource(self, arg):
554 def do_psource(self, arg):
555 """Print (or run through pager) the source code for an object."""
555 """Print (or run through pager) the source code for an object."""
556 namespaces = [('Locals', self.curframe.f_locals),
556 namespaces = [('Locals', self.curframe.f_locals),
557 ('Globals', self.curframe.f_globals)]
557 ('Globals', self.curframe.f_globals)]
558 self.shell.find_line_magic('psource')(arg, namespaces=namespaces)
558 self.shell.find_line_magic('psource')(arg, namespaces=namespaces)
559
559
560 def checkline(self, filename, lineno):
560 def checkline(self, filename, lineno):
561 """Check whether specified line seems to be executable.
561 """Check whether specified line seems to be executable.
562
562
563 Return `lineno` if it is, 0 if not (e.g. a docstring, comment, blank
563 Return `lineno` if it is, 0 if not (e.g. a docstring, comment, blank
564 line or EOF). Warning: testing is not comprehensive.
564 line or EOF). Warning: testing is not comprehensive.
565 """
565 """
566 #######################################################################
566 #######################################################################
567 # XXX Hack! Use python-2.5 compatible code for this call, because with
567 # XXX Hack! Use python-2.5 compatible code for this call, because with
568 # all of our changes, we've drifted from the pdb api in 2.6. For now,
568 # all of our changes, we've drifted from the pdb api in 2.6. For now,
569 # changing:
569 # changing:
570 #
570 #
571 #line = linecache.getline(filename, lineno, self.curframe.f_globals)
571 #line = linecache.getline(filename, lineno, self.curframe.f_globals)
572 # to:
572 # to:
573 #
573 #
574 line = linecache.getline(filename, lineno)
574 line = linecache.getline(filename, lineno)
575 #
575 #
576 # does the trick. But in reality, we need to fix this by reconciling
576 # does the trick. But in reality, we need to fix this by reconciling
577 # our updates with the new Pdb APIs in Python 2.6.
577 # our updates with the new Pdb APIs in Python 2.6.
578 #
578 #
579 # End hack. The rest of this method is copied verbatim from 2.6 pdb.py
579 # End hack. The rest of this method is copied verbatim from 2.6 pdb.py
580 #######################################################################
580 #######################################################################
581
581
582 if not line:
582 if not line:
583 print('End of file', file=self.stdout)
583 print('End of file', file=self.stdout)
584 return 0
584 return 0
585 line = line.strip()
585 line = line.strip()
586 # Don't allow setting breakpoint at a blank line
586 # Don't allow setting breakpoint at a blank line
587 if (not line or (line[0] == '#') or
587 if (not line or (line[0] == '#') or
588 (line[:3] == '"""') or line[:3] == "'''"):
588 (line[:3] == '"""') or line[:3] == "'''"):
589 print('*** Blank or comment', file=self.stdout)
589 print('*** Blank or comment', file=self.stdout)
590 return 0
590 return 0
591 return lineno
591 return lineno
@@ -1,3326 +1,3336 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 from __future__ import absolute_import, print_function
13 from __future__ import absolute_import, print_function
14
14
15 import __future__
15 import __future__
16 import abc
16 import abc
17 import ast
17 import ast
18 import atexit
18 import atexit
19 import functools
19 import functools
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 types
26 import types
26 import subprocess
27 import subprocess
27 from io import open as io_open
28 from io import open as io_open
28
29
29 from IPython.config.configurable import SingletonConfigurable
30 from IPython.config.configurable import SingletonConfigurable
30 from IPython.core import debugger, oinspect
31 from IPython.core import debugger, oinspect
31 from IPython.core import magic
32 from IPython.core import magic
32 from IPython.core import page
33 from IPython.core import page
33 from IPython.core import prefilter
34 from IPython.core import prefilter
34 from IPython.core import shadowns
35 from IPython.core import shadowns
35 from IPython.core import ultratb
36 from IPython.core import ultratb
36 from IPython.core.alias import AliasManager, AliasError
37 from IPython.core.alias import AliasManager, AliasError
37 from IPython.core.autocall import ExitAutocall
38 from IPython.core.autocall import ExitAutocall
38 from IPython.core.builtin_trap import BuiltinTrap
39 from IPython.core.builtin_trap import BuiltinTrap
39 from IPython.core.events import EventManager, available_events
40 from IPython.core.events import EventManager, available_events
40 from IPython.core.compilerop import CachingCompiler, check_linecache_ipython
41 from IPython.core.compilerop import CachingCompiler, check_linecache_ipython
41 from IPython.core.display_trap import DisplayTrap
42 from IPython.core.display_trap import DisplayTrap
42 from IPython.core.displayhook import DisplayHook
43 from IPython.core.displayhook import DisplayHook
43 from IPython.core.displaypub import DisplayPublisher
44 from IPython.core.displaypub import DisplayPublisher
44 from IPython.core.error import InputRejected, UsageError
45 from IPython.core.error import InputRejected, UsageError
45 from IPython.core.extensions import ExtensionManager
46 from IPython.core.extensions import ExtensionManager
46 from IPython.core.formatters import DisplayFormatter
47 from IPython.core.formatters import DisplayFormatter
47 from IPython.core.history import HistoryManager
48 from IPython.core.history import HistoryManager
48 from IPython.core.inputsplitter import IPythonInputSplitter, ESC_MAGIC, ESC_MAGIC2
49 from IPython.core.inputsplitter import IPythonInputSplitter, ESC_MAGIC, ESC_MAGIC2
49 from IPython.core.logger import Logger
50 from IPython.core.logger import Logger
50 from IPython.core.macro import Macro
51 from IPython.core.macro import Macro
51 from IPython.core.payload import PayloadManager
52 from IPython.core.payload import PayloadManager
52 from IPython.core.prefilter import PrefilterManager
53 from IPython.core.prefilter import PrefilterManager
53 from IPython.core.profiledir import ProfileDir
54 from IPython.core.profiledir import ProfileDir
54 from IPython.core.prompts import PromptManager
55 from IPython.core.prompts import PromptManager
55 from IPython.core.usage import default_banner
56 from IPython.core.usage import default_banner
56 from IPython.lib.latextools import LaTeXTool
57 from IPython.lib.latextools import LaTeXTool
57 from IPython.testing.skipdoctest import skip_doctest
58 from IPython.testing.skipdoctest import skip_doctest
58 from IPython.utils import PyColorize
59 from IPython.utils import PyColorize
59 from IPython.utils import io
60 from IPython.utils import io
60 from IPython.utils import py3compat
61 from IPython.utils import py3compat
61 from IPython.utils import openpy
62 from IPython.utils import openpy
62 from IPython.utils.decorators import undoc
63 from IPython.utils.decorators import undoc
63 from IPython.utils.io import ask_yes_no
64 from IPython.utils.io import ask_yes_no
64 from IPython.utils.ipstruct import Struct
65 from IPython.utils.ipstruct import Struct
65 from IPython.utils.path import get_home_dir, get_ipython_dir, get_py_filename, unquote_filename, ensure_dir_exists
66 from IPython.utils.path import get_home_dir, get_ipython_dir, get_py_filename, unquote_filename, ensure_dir_exists
66 from IPython.utils.pickleshare import PickleShareDB
67 from IPython.utils.pickleshare import PickleShareDB
67 from IPython.utils.process import system, getoutput
68 from IPython.utils.process import system, getoutput
68 from IPython.utils.py3compat import (builtin_mod, unicode_type, string_types,
69 from IPython.utils.py3compat import (builtin_mod, unicode_type, string_types,
69 with_metaclass, iteritems)
70 with_metaclass, iteritems)
70 from IPython.utils.strdispatch import StrDispatch
71 from IPython.utils.strdispatch import StrDispatch
71 from IPython.utils.syspathcontext import prepended_to_syspath
72 from IPython.utils.syspathcontext import prepended_to_syspath
72 from IPython.utils.text import (format_screen, LSString, SList,
73 from IPython.utils.text import (format_screen, LSString, SList,
73 DollarFormatter)
74 DollarFormatter)
74 from IPython.utils.traitlets import (Integer, CBool, CaselessStrEnum, Enum,
75 from IPython.utils.traitlets import (Integer, CBool, CaselessStrEnum, Enum,
75 List, Unicode, Instance, Type)
76 List, Unicode, Instance, Type)
76 from IPython.utils.warn import warn, error
77 from IPython.utils.warn import warn, error
77 import IPython.core.hooks
78 import IPython.core.hooks
78
79
79 #-----------------------------------------------------------------------------
80 #-----------------------------------------------------------------------------
80 # Globals
81 # Globals
81 #-----------------------------------------------------------------------------
82 #-----------------------------------------------------------------------------
82
83
83 # compiled regexps for autoindent management
84 # compiled regexps for autoindent management
84 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
85 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
85
86
86 #-----------------------------------------------------------------------------
87 #-----------------------------------------------------------------------------
87 # Utilities
88 # Utilities
88 #-----------------------------------------------------------------------------
89 #-----------------------------------------------------------------------------
89
90
90 @undoc
91 @undoc
91 def softspace(file, newvalue):
92 def softspace(file, newvalue):
92 """Copied from code.py, to remove the dependency"""
93 """Copied from code.py, to remove the dependency"""
93
94
94 oldvalue = 0
95 oldvalue = 0
95 try:
96 try:
96 oldvalue = file.softspace
97 oldvalue = file.softspace
97 except AttributeError:
98 except AttributeError:
98 pass
99 pass
99 try:
100 try:
100 file.softspace = newvalue
101 file.softspace = newvalue
101 except (AttributeError, TypeError):
102 except (AttributeError, TypeError):
102 # "attribute-less object" or "read-only attributes"
103 # "attribute-less object" or "read-only attributes"
103 pass
104 pass
104 return oldvalue
105 return oldvalue
105
106
106 @undoc
107 @undoc
107 def no_op(*a, **kw): pass
108 def no_op(*a, **kw): pass
108
109
109 @undoc
110 @undoc
110 class NoOpContext(object):
111 class NoOpContext(object):
111 def __enter__(self): pass
112 def __enter__(self): pass
112 def __exit__(self, type, value, traceback): pass
113 def __exit__(self, type, value, traceback): pass
113 no_op_context = NoOpContext()
114 no_op_context = NoOpContext()
114
115
115 class SpaceInInput(Exception): pass
116 class SpaceInInput(Exception): pass
116
117
117 @undoc
118 @undoc
118 class Bunch: pass
119 class Bunch: pass
119
120
120
121
121 def get_default_colors():
122 def get_default_colors():
122 if sys.platform=='darwin':
123 if sys.platform=='darwin':
123 return "LightBG"
124 return "LightBG"
124 elif os.name=='nt':
125 elif os.name=='nt':
125 return 'Linux'
126 return 'Linux'
126 else:
127 else:
127 return 'Linux'
128 return 'Linux'
128
129
129
130
130 class SeparateUnicode(Unicode):
131 class SeparateUnicode(Unicode):
131 r"""A Unicode subclass to validate separate_in, separate_out, etc.
132 r"""A Unicode subclass to validate separate_in, separate_out, etc.
132
133
133 This is a Unicode based trait that converts '0'->'' and ``'\\n'->'\n'``.
134 This is a Unicode based trait that converts '0'->'' and ``'\\n'->'\n'``.
134 """
135 """
135
136
136 def validate(self, obj, value):
137 def validate(self, obj, value):
137 if value == '0': value = ''
138 if value == '0': value = ''
138 value = value.replace('\\n','\n')
139 value = value.replace('\\n','\n')
139 return super(SeparateUnicode, self).validate(obj, value)
140 return super(SeparateUnicode, self).validate(obj, value)
140
141
141
142
142 class ReadlineNoRecord(object):
143 class ReadlineNoRecord(object):
143 """Context manager to execute some code, then reload readline history
144 """Context manager to execute some code, then reload readline history
144 so that interactive input to the code doesn't appear when pressing up."""
145 so that interactive input to the code doesn't appear when pressing up."""
145 def __init__(self, shell):
146 def __init__(self, shell):
146 self.shell = shell
147 self.shell = shell
147 self._nested_level = 0
148 self._nested_level = 0
148
149
149 def __enter__(self):
150 def __enter__(self):
150 if self._nested_level == 0:
151 if self._nested_level == 0:
151 try:
152 try:
152 self.orig_length = self.current_length()
153 self.orig_length = self.current_length()
153 self.readline_tail = self.get_readline_tail()
154 self.readline_tail = self.get_readline_tail()
154 except (AttributeError, IndexError): # Can fail with pyreadline
155 except (AttributeError, IndexError): # Can fail with pyreadline
155 self.orig_length, self.readline_tail = 999999, []
156 self.orig_length, self.readline_tail = 999999, []
156 self._nested_level += 1
157 self._nested_level += 1
157
158
158 def __exit__(self, type, value, traceback):
159 def __exit__(self, type, value, traceback):
159 self._nested_level -= 1
160 self._nested_level -= 1
160 if self._nested_level == 0:
161 if self._nested_level == 0:
161 # Try clipping the end if it's got longer
162 # Try clipping the end if it's got longer
162 try:
163 try:
163 e = self.current_length() - self.orig_length
164 e = self.current_length() - self.orig_length
164 if e > 0:
165 if e > 0:
165 for _ in range(e):
166 for _ in range(e):
166 self.shell.readline.remove_history_item(self.orig_length)
167 self.shell.readline.remove_history_item(self.orig_length)
167
168
168 # If it still doesn't match, just reload readline history.
169 # If it still doesn't match, just reload readline history.
169 if self.current_length() != self.orig_length \
170 if self.current_length() != self.orig_length \
170 or self.get_readline_tail() != self.readline_tail:
171 or self.get_readline_tail() != self.readline_tail:
171 self.shell.refill_readline_hist()
172 self.shell.refill_readline_hist()
172 except (AttributeError, IndexError):
173 except (AttributeError, IndexError):
173 pass
174 pass
174 # Returning False will cause exceptions to propagate
175 # Returning False will cause exceptions to propagate
175 return False
176 return False
176
177
177 def current_length(self):
178 def current_length(self):
178 return self.shell.readline.get_current_history_length()
179 return self.shell.readline.get_current_history_length()
179
180
180 def get_readline_tail(self, n=10):
181 def get_readline_tail(self, n=10):
181 """Get the last n items in readline history."""
182 """Get the last n items in readline history."""
182 end = self.shell.readline.get_current_history_length() + 1
183 end = self.shell.readline.get_current_history_length() + 1
183 start = max(end-n, 1)
184 start = max(end-n, 1)
184 ghi = self.shell.readline.get_history_item
185 ghi = self.shell.readline.get_history_item
185 return [ghi(x) for x in range(start, end)]
186 return [ghi(x) for x in range(start, end)]
186
187
187
188
188 @undoc
189 @undoc
189 class DummyMod(object):
190 class DummyMod(object):
190 """A dummy module used for IPython's interactive module when
191 """A dummy module used for IPython's interactive module when
191 a namespace must be assigned to the module's __dict__."""
192 a namespace must be assigned to the module's __dict__."""
192 pass
193 pass
193
194
194 #-----------------------------------------------------------------------------
195 #-----------------------------------------------------------------------------
195 # Main IPython class
196 # Main IPython class
196 #-----------------------------------------------------------------------------
197 #-----------------------------------------------------------------------------
197
198
198 class InteractiveShell(SingletonConfigurable):
199 class InteractiveShell(SingletonConfigurable):
199 """An enhanced, interactive shell for Python."""
200 """An enhanced, interactive shell for Python."""
200
201
201 _instance = None
202 _instance = None
202
203
203 ast_transformers = List([], config=True, help=
204 ast_transformers = List([], config=True, help=
204 """
205 """
205 A list of ast.NodeTransformer subclass instances, which will be applied
206 A list of ast.NodeTransformer subclass instances, which will be applied
206 to user input before code is run.
207 to user input before code is run.
207 """
208 """
208 )
209 )
209
210
210 autocall = Enum((0,1,2), default_value=0, config=True, help=
211 autocall = Enum((0,1,2), default_value=0, config=True, help=
211 """
212 """
212 Make IPython automatically call any callable object even if you didn't
213 Make IPython automatically call any callable object even if you didn't
213 type explicit parentheses. For example, 'str 43' becomes 'str(43)'
214 type explicit parentheses. For example, 'str 43' becomes 'str(43)'
214 automatically. The value can be '0' to disable the feature, '1' for
215 automatically. The value can be '0' to disable the feature, '1' for
215 'smart' autocall, where it is not applied if there are no more
216 'smart' autocall, where it is not applied if there are no more
216 arguments on the line, and '2' for 'full' autocall, where all callable
217 arguments on the line, and '2' for 'full' autocall, where all callable
217 objects are automatically called (even if no arguments are present).
218 objects are automatically called (even if no arguments are present).
218 """
219 """
219 )
220 )
220 # TODO: remove all autoindent logic and put into frontends.
221 # TODO: remove all autoindent logic and put into frontends.
221 # We can't do this yet because even runlines uses the autoindent.
222 # We can't do this yet because even runlines uses the autoindent.
222 autoindent = CBool(True, config=True, help=
223 autoindent = CBool(True, config=True, help=
223 """
224 """
224 Autoindent IPython code entered interactively.
225 Autoindent IPython code entered interactively.
225 """
226 """
226 )
227 )
227 automagic = CBool(True, config=True, help=
228 automagic = CBool(True, config=True, help=
228 """
229 """
229 Enable magic commands to be called without the leading %.
230 Enable magic commands to be called without the leading %.
230 """
231 """
231 )
232 )
232
233
233 banner = Unicode('')
234 banner = Unicode('')
234
235
235 banner1 = Unicode(default_banner, config=True,
236 banner1 = Unicode(default_banner, config=True,
236 help="""The part of the banner to be printed before the profile"""
237 help="""The part of the banner to be printed before the profile"""
237 )
238 )
238 banner2 = Unicode('', config=True,
239 banner2 = Unicode('', config=True,
239 help="""The part of the banner to be printed after the profile"""
240 help="""The part of the banner to be printed after the profile"""
240 )
241 )
241
242
242 cache_size = Integer(1000, config=True, help=
243 cache_size = Integer(1000, config=True, help=
243 """
244 """
244 Set the size of the output cache. The default is 1000, you can
245 Set the size of the output cache. The default is 1000, you can
245 change it permanently in your config file. Setting it to 0 completely
246 change it permanently in your config file. Setting it to 0 completely
246 disables the caching system, and the minimum value accepted is 20 (if
247 disables the caching system, and the minimum value accepted is 20 (if
247 you provide a value less than 20, it is reset to 0 and a warning is
248 you provide a value less than 20, it is reset to 0 and a warning is
248 issued). This limit is defined because otherwise you'll spend more
249 issued). This limit is defined because otherwise you'll spend more
249 time re-flushing a too small cache than working
250 time re-flushing a too small cache than working
250 """
251 """
251 )
252 )
252 color_info = CBool(True, config=True, help=
253 color_info = CBool(True, config=True, help=
253 """
254 """
254 Use colors for displaying information about objects. Because this
255 Use colors for displaying information about objects. Because this
255 information is passed through a pager (like 'less'), and some pagers
256 information is passed through a pager (like 'less'), and some pagers
256 get confused with color codes, this capability can be turned off.
257 get confused with color codes, this capability can be turned off.
257 """
258 """
258 )
259 )
259 colors = CaselessStrEnum(('NoColor','LightBG','Linux'),
260 colors = CaselessStrEnum(('NoColor','LightBG','Linux'),
260 default_value=get_default_colors(), config=True,
261 default_value=get_default_colors(), config=True,
261 help="Set the color scheme (NoColor, Linux, or LightBG)."
262 help="Set the color scheme (NoColor, Linux, or LightBG)."
262 )
263 )
263 colors_force = CBool(False, help=
264 colors_force = CBool(False, help=
264 """
265 """
265 Force use of ANSI color codes, regardless of OS and readline
266 Force use of ANSI color codes, regardless of OS and readline
266 availability.
267 availability.
267 """
268 """
268 # FIXME: This is essentially a hack to allow ZMQShell to show colors
269 # FIXME: This is essentially a hack to allow ZMQShell to show colors
269 # without readline on Win32. When the ZMQ formatting system is
270 # without readline on Win32. When the ZMQ formatting system is
270 # refactored, this should be removed.
271 # refactored, this should be removed.
271 )
272 )
272 debug = CBool(False, config=True)
273 debug = CBool(False, config=True)
273 deep_reload = CBool(False, config=True, help=
274 deep_reload = CBool(False, config=True, help=
274 """
275 """
275 Enable deep (recursive) reloading by default. IPython can use the
276 Enable deep (recursive) reloading by default. IPython can use the
276 deep_reload module which reloads changes in modules recursively (it
277 deep_reload module which reloads changes in modules recursively (it
277 replaces the reload() function, so you don't need to change anything to
278 replaces the reload() function, so you don't need to change anything to
278 use it). deep_reload() forces a full reload of modules whose code may
279 use it). deep_reload() forces a full reload of modules whose code may
279 have changed, which the default reload() function does not. When
280 have changed, which the default reload() function does not. When
280 deep_reload is off, IPython will use the normal reload(), but
281 deep_reload is off, IPython will use the normal reload(), but
281 deep_reload will still be available as dreload().
282 deep_reload will still be available as dreload().
282 """
283 """
283 )
284 )
284 disable_failing_post_execute = CBool(False, config=True,
285 disable_failing_post_execute = CBool(False, config=True,
285 help="Don't call post-execute functions that have failed in the past."
286 help="Don't call post-execute functions that have failed in the past."
286 )
287 )
287 display_formatter = Instance(DisplayFormatter)
288 display_formatter = Instance(DisplayFormatter)
288 displayhook_class = Type(DisplayHook)
289 displayhook_class = Type(DisplayHook)
289 display_pub_class = Type(DisplayPublisher)
290 display_pub_class = Type(DisplayPublisher)
290 data_pub_class = None
291 data_pub_class = None
291
292
292 exit_now = CBool(False)
293 exit_now = CBool(False)
293 exiter = Instance(ExitAutocall)
294 exiter = Instance(ExitAutocall)
294 def _exiter_default(self):
295 def _exiter_default(self):
295 return ExitAutocall(self)
296 return ExitAutocall(self)
296 # Monotonically increasing execution counter
297 # Monotonically increasing execution counter
297 execution_count = Integer(1)
298 execution_count = Integer(1)
298 filename = Unicode("<ipython console>")
299 filename = Unicode("<ipython console>")
299 ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__
300 ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__
300
301
301 # Input splitter, to transform input line by line and detect when a block
302 # Input splitter, to transform input line by line and detect when a block
302 # is ready to be executed.
303 # is ready to be executed.
303 input_splitter = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
304 input_splitter = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
304 (), {'line_input_checker': True})
305 (), {'line_input_checker': True})
305
306
306 # This InputSplitter instance is used to transform completed cells before
307 # This InputSplitter instance is used to transform completed cells before
307 # running them. It allows cell magics to contain blank lines.
308 # running them. It allows cell magics to contain blank lines.
308 input_transformer_manager = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
309 input_transformer_manager = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
309 (), {'line_input_checker': False})
310 (), {'line_input_checker': False})
310
311
311 logstart = CBool(False, config=True, help=
312 logstart = CBool(False, config=True, help=
312 """
313 """
313 Start logging to the default log file.
314 Start logging to the default log file.
314 """
315 """
315 )
316 )
316 logfile = Unicode('', config=True, help=
317 logfile = Unicode('', config=True, help=
317 """
318 """
318 The name of the logfile to use.
319 The name of the logfile to use.
319 """
320 """
320 )
321 )
321 logappend = Unicode('', config=True, help=
322 logappend = Unicode('', config=True, help=
322 """
323 """
323 Start logging to the given file in append mode.
324 Start logging to the given file in append mode.
324 """
325 """
325 )
326 )
326 object_info_string_level = Enum((0,1,2), default_value=0,
327 object_info_string_level = Enum((0,1,2), default_value=0,
327 config=True)
328 config=True)
328 pdb = CBool(False, config=True, help=
329 pdb = CBool(False, config=True, help=
329 """
330 """
330 Automatically call the pdb debugger after every exception.
331 Automatically call the pdb debugger after every exception.
331 """
332 """
332 )
333 )
333 multiline_history = CBool(sys.platform != 'win32', config=True,
334 multiline_history = CBool(sys.platform != 'win32', config=True,
334 help="Save multi-line entries as one entry in readline history"
335 help="Save multi-line entries as one entry in readline history"
335 )
336 )
336
337
337 # deprecated prompt traits:
338 # deprecated prompt traits:
338
339
339 prompt_in1 = Unicode('In [\\#]: ', config=True,
340 prompt_in1 = Unicode('In [\\#]: ', config=True,
340 help="Deprecated, use PromptManager.in_template")
341 help="Deprecated, use PromptManager.in_template")
341 prompt_in2 = Unicode(' .\\D.: ', config=True,
342 prompt_in2 = Unicode(' .\\D.: ', config=True,
342 help="Deprecated, use PromptManager.in2_template")
343 help="Deprecated, use PromptManager.in2_template")
343 prompt_out = Unicode('Out[\\#]: ', config=True,
344 prompt_out = Unicode('Out[\\#]: ', config=True,
344 help="Deprecated, use PromptManager.out_template")
345 help="Deprecated, use PromptManager.out_template")
345 prompts_pad_left = CBool(True, config=True,
346 prompts_pad_left = CBool(True, config=True,
346 help="Deprecated, use PromptManager.justify")
347 help="Deprecated, use PromptManager.justify")
347
348
348 def _prompt_trait_changed(self, name, old, new):
349 def _prompt_trait_changed(self, name, old, new):
349 table = {
350 table = {
350 'prompt_in1' : 'in_template',
351 'prompt_in1' : 'in_template',
351 'prompt_in2' : 'in2_template',
352 'prompt_in2' : 'in2_template',
352 'prompt_out' : 'out_template',
353 'prompt_out' : 'out_template',
353 'prompts_pad_left' : 'justify',
354 'prompts_pad_left' : 'justify',
354 }
355 }
355 warn("InteractiveShell.{name} is deprecated, use PromptManager.{newname}".format(
356 warn("InteractiveShell.{name} is deprecated, use PromptManager.{newname}".format(
356 name=name, newname=table[name])
357 name=name, newname=table[name])
357 )
358 )
358 # protect against weird cases where self.config may not exist:
359 # protect against weird cases where self.config may not exist:
359 if self.config is not None:
360 if self.config is not None:
360 # propagate to corresponding PromptManager trait
361 # propagate to corresponding PromptManager trait
361 setattr(self.config.PromptManager, table[name], new)
362 setattr(self.config.PromptManager, table[name], new)
362
363
363 _prompt_in1_changed = _prompt_trait_changed
364 _prompt_in1_changed = _prompt_trait_changed
364 _prompt_in2_changed = _prompt_trait_changed
365 _prompt_in2_changed = _prompt_trait_changed
365 _prompt_out_changed = _prompt_trait_changed
366 _prompt_out_changed = _prompt_trait_changed
366 _prompt_pad_left_changed = _prompt_trait_changed
367 _prompt_pad_left_changed = _prompt_trait_changed
367
368
368 show_rewritten_input = CBool(True, config=True,
369 show_rewritten_input = CBool(True, config=True,
369 help="Show rewritten input, e.g. for autocall."
370 help="Show rewritten input, e.g. for autocall."
370 )
371 )
371
372
372 quiet = CBool(False, config=True)
373 quiet = CBool(False, config=True)
373
374
374 history_length = Integer(10000, config=True)
375 history_length = Integer(10000, config=True)
375
376
376 # The readline stuff will eventually be moved to the terminal subclass
377 # The readline stuff will eventually be moved to the terminal subclass
377 # but for now, we can't do that as readline is welded in everywhere.
378 # but for now, we can't do that as readline is welded in everywhere.
378 readline_use = CBool(True, config=True)
379 readline_use = CBool(True, config=True)
379 readline_remove_delims = Unicode('-/~', config=True)
380 readline_remove_delims = Unicode('-/~', config=True)
380 readline_delims = Unicode() # set by init_readline()
381 readline_delims = Unicode() # set by init_readline()
381 # don't use \M- bindings by default, because they
382 # don't use \M- bindings by default, because they
382 # conflict with 8-bit encodings. See gh-58,gh-88
383 # conflict with 8-bit encodings. See gh-58,gh-88
383 readline_parse_and_bind = List([
384 readline_parse_and_bind = List([
384 'tab: complete',
385 'tab: complete',
385 '"\C-l": clear-screen',
386 '"\C-l": clear-screen',
386 'set show-all-if-ambiguous on',
387 'set show-all-if-ambiguous on',
387 '"\C-o": tab-insert',
388 '"\C-o": tab-insert',
388 '"\C-r": reverse-search-history',
389 '"\C-r": reverse-search-history',
389 '"\C-s": forward-search-history',
390 '"\C-s": forward-search-history',
390 '"\C-p": history-search-backward',
391 '"\C-p": history-search-backward',
391 '"\C-n": history-search-forward',
392 '"\C-n": history-search-forward',
392 '"\e[A": history-search-backward',
393 '"\e[A": history-search-backward',
393 '"\e[B": history-search-forward',
394 '"\e[B": history-search-forward',
394 '"\C-k": kill-line',
395 '"\C-k": kill-line',
395 '"\C-u": unix-line-discard',
396 '"\C-u": unix-line-discard',
396 ], config=True)
397 ], config=True)
397
398
398 _custom_readline_config = False
399 _custom_readline_config = False
399
400
400 def _readline_parse_and_bind_changed(self, name, old, new):
401 def _readline_parse_and_bind_changed(self, name, old, new):
401 # notice that readline config is customized
402 # notice that readline config is customized
402 # indicates that it should have higher priority than inputrc
403 # indicates that it should have higher priority than inputrc
403 self._custom_readline_config = True
404 self._custom_readline_config = True
404
405
405 ast_node_interactivity = Enum(['all', 'last', 'last_expr', 'none'],
406 ast_node_interactivity = Enum(['all', 'last', 'last_expr', 'none'],
406 default_value='last_expr', config=True,
407 default_value='last_expr', config=True,
407 help="""
408 help="""
408 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
409 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
409 run interactively (displaying output from expressions).""")
410 run interactively (displaying output from expressions).""")
410
411
411 # TODO: this part of prompt management should be moved to the frontends.
412 # TODO: this part of prompt management should be moved to the frontends.
412 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
413 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
413 separate_in = SeparateUnicode('\n', config=True)
414 separate_in = SeparateUnicode('\n', config=True)
414 separate_out = SeparateUnicode('', config=True)
415 separate_out = SeparateUnicode('', config=True)
415 separate_out2 = SeparateUnicode('', config=True)
416 separate_out2 = SeparateUnicode('', config=True)
416 wildcards_case_sensitive = CBool(True, config=True)
417 wildcards_case_sensitive = CBool(True, config=True)
417 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
418 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
418 default_value='Context', config=True)
419 default_value='Context', config=True)
419
420
420 # Subcomponents of InteractiveShell
421 # Subcomponents of InteractiveShell
421 alias_manager = Instance('IPython.core.alias.AliasManager')
422 alias_manager = Instance('IPython.core.alias.AliasManager')
422 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
423 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
423 builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap')
424 builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap')
424 display_trap = Instance('IPython.core.display_trap.DisplayTrap')
425 display_trap = Instance('IPython.core.display_trap.DisplayTrap')
425 extension_manager = Instance('IPython.core.extensions.ExtensionManager')
426 extension_manager = Instance('IPython.core.extensions.ExtensionManager')
426 payload_manager = Instance('IPython.core.payload.PayloadManager')
427 payload_manager = Instance('IPython.core.payload.PayloadManager')
427 history_manager = Instance('IPython.core.history.HistoryAccessorBase')
428 history_manager = Instance('IPython.core.history.HistoryAccessorBase')
428 magics_manager = Instance('IPython.core.magic.MagicsManager')
429 magics_manager = Instance('IPython.core.magic.MagicsManager')
429
430
430 profile_dir = Instance('IPython.core.application.ProfileDir')
431 profile_dir = Instance('IPython.core.application.ProfileDir')
431 @property
432 @property
432 def profile(self):
433 def profile(self):
433 if self.profile_dir is not None:
434 if self.profile_dir is not None:
434 name = os.path.basename(self.profile_dir.location)
435 name = os.path.basename(self.profile_dir.location)
435 return name.replace('profile_','')
436 return name.replace('profile_','')
436
437
437
438
438 # Private interface
439 # Private interface
439 _post_execute = Instance(dict)
440 _post_execute = Instance(dict)
440
441
441 # Tracks any GUI loop loaded for pylab
442 # Tracks any GUI loop loaded for pylab
442 pylab_gui_select = None
443 pylab_gui_select = None
443
444
444 def __init__(self, ipython_dir=None, profile_dir=None,
445 def __init__(self, ipython_dir=None, profile_dir=None,
445 user_module=None, user_ns=None,
446 user_module=None, user_ns=None,
446 custom_exceptions=((), None), **kwargs):
447 custom_exceptions=((), None), **kwargs):
447
448
448 # This is where traits with a config_key argument are updated
449 # This is where traits with a config_key argument are updated
449 # from the values on config.
450 # from the values on config.
450 super(InteractiveShell, self).__init__(**kwargs)
451 super(InteractiveShell, self).__init__(**kwargs)
451 self.configurables = [self]
452 self.configurables = [self]
452
453
453 # These are relatively independent and stateless
454 # These are relatively independent and stateless
454 self.init_ipython_dir(ipython_dir)
455 self.init_ipython_dir(ipython_dir)
455 self.init_profile_dir(profile_dir)
456 self.init_profile_dir(profile_dir)
456 self.init_instance_attrs()
457 self.init_instance_attrs()
457 self.init_environment()
458 self.init_environment()
458
459
459 # Check if we're in a virtualenv, and set up sys.path.
460 # Check if we're in a virtualenv, and set up sys.path.
460 self.init_virtualenv()
461 self.init_virtualenv()
461
462
462 # Create namespaces (user_ns, user_global_ns, etc.)
463 # Create namespaces (user_ns, user_global_ns, etc.)
463 self.init_create_namespaces(user_module, user_ns)
464 self.init_create_namespaces(user_module, user_ns)
464 # This has to be done after init_create_namespaces because it uses
465 # This has to be done after init_create_namespaces because it uses
465 # something in self.user_ns, but before init_sys_modules, which
466 # something in self.user_ns, but before init_sys_modules, which
466 # is the first thing to modify sys.
467 # is the first thing to modify sys.
467 # TODO: When we override sys.stdout and sys.stderr before this class
468 # TODO: When we override sys.stdout and sys.stderr before this class
468 # is created, we are saving the overridden ones here. Not sure if this
469 # is created, we are saving the overridden ones here. Not sure if this
469 # is what we want to do.
470 # is what we want to do.
470 self.save_sys_module_state()
471 self.save_sys_module_state()
471 self.init_sys_modules()
472 self.init_sys_modules()
472
473
473 # While we're trying to have each part of the code directly access what
474 # While we're trying to have each part of the code directly access what
474 # it needs without keeping redundant references to objects, we have too
475 # it needs without keeping redundant references to objects, we have too
475 # much legacy code that expects ip.db to exist.
476 # much legacy code that expects ip.db to exist.
476 self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))
477 self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))
477
478
478 self.init_history()
479 self.init_history()
479 self.init_encoding()
480 self.init_encoding()
480 self.init_prefilter()
481 self.init_prefilter()
481
482
482 self.init_syntax_highlighting()
483 self.init_syntax_highlighting()
483 self.init_hooks()
484 self.init_hooks()
484 self.init_events()
485 self.init_events()
485 self.init_pushd_popd_magic()
486 self.init_pushd_popd_magic()
486 # self.init_traceback_handlers use to be here, but we moved it below
487 # self.init_traceback_handlers use to be here, but we moved it below
487 # because it and init_io have to come after init_readline.
488 # because it and init_io have to come after init_readline.
488 self.init_user_ns()
489 self.init_user_ns()
489 self.init_logger()
490 self.init_logger()
490 self.init_builtins()
491 self.init_builtins()
491
492
492 # The following was in post_config_initialization
493 # The following was in post_config_initialization
493 self.init_inspector()
494 self.init_inspector()
494 # init_readline() must come before init_io(), because init_io uses
495 # init_readline() must come before init_io(), because init_io uses
495 # readline related things.
496 # readline related things.
496 self.init_readline()
497 self.init_readline()
497 # We save this here in case user code replaces raw_input, but it needs
498 # We save this here in case user code replaces raw_input, but it needs
498 # to be after init_readline(), because PyPy's readline works by replacing
499 # to be after init_readline(), because PyPy's readline works by replacing
499 # raw_input.
500 # raw_input.
500 if py3compat.PY3:
501 if py3compat.PY3:
501 self.raw_input_original = input
502 self.raw_input_original = input
502 else:
503 else:
503 self.raw_input_original = raw_input
504 self.raw_input_original = raw_input
504 # init_completer must come after init_readline, because it needs to
505 # init_completer must come after init_readline, because it needs to
505 # know whether readline is present or not system-wide to configure the
506 # know whether readline is present or not system-wide to configure the
506 # completers, since the completion machinery can now operate
507 # completers, since the completion machinery can now operate
507 # independently of readline (e.g. over the network)
508 # independently of readline (e.g. over the network)
508 self.init_completer()
509 self.init_completer()
509 # TODO: init_io() needs to happen before init_traceback handlers
510 # TODO: init_io() needs to happen before init_traceback handlers
510 # because the traceback handlers hardcode the stdout/stderr streams.
511 # because the traceback handlers hardcode the stdout/stderr streams.
511 # This logic in in debugger.Pdb and should eventually be changed.
512 # This logic in in debugger.Pdb and should eventually be changed.
512 self.init_io()
513 self.init_io()
513 self.init_traceback_handlers(custom_exceptions)
514 self.init_traceback_handlers(custom_exceptions)
514 self.init_prompts()
515 self.init_prompts()
515 self.init_display_formatter()
516 self.init_display_formatter()
516 self.init_display_pub()
517 self.init_display_pub()
517 self.init_data_pub()
518 self.init_data_pub()
518 self.init_displayhook()
519 self.init_displayhook()
519 self.init_latextool()
520 self.init_latextool()
520 self.init_magics()
521 self.init_magics()
521 self.init_alias()
522 self.init_alias()
522 self.init_logstart()
523 self.init_logstart()
523 self.init_pdb()
524 self.init_pdb()
524 self.init_extension_manager()
525 self.init_extension_manager()
525 self.init_payload()
526 self.init_payload()
526 self.hooks.late_startup_hook()
527 self.hooks.late_startup_hook()
527 self.events.trigger('shell_initialized', self)
528 self.events.trigger('shell_initialized', self)
528 atexit.register(self.atexit_operations)
529 atexit.register(self.atexit_operations)
529
530
530 def get_ipython(self):
531 def get_ipython(self):
531 """Return the currently running IPython instance."""
532 """Return the currently running IPython instance."""
532 return self
533 return self
533
534
534 #-------------------------------------------------------------------------
535 #-------------------------------------------------------------------------
535 # Trait changed handlers
536 # Trait changed handlers
536 #-------------------------------------------------------------------------
537 #-------------------------------------------------------------------------
537
538
538 def _ipython_dir_changed(self, name, new):
539 def _ipython_dir_changed(self, name, new):
539 ensure_dir_exists(new)
540 ensure_dir_exists(new)
540
541
541 def set_autoindent(self,value=None):
542 def set_autoindent(self,value=None):
542 """Set the autoindent flag, checking for readline support.
543 """Set the autoindent flag, checking for readline support.
543
544
544 If called with no arguments, it acts as a toggle."""
545 If called with no arguments, it acts as a toggle."""
545
546
546 if value != 0 and not self.has_readline:
547 if value != 0 and not self.has_readline:
547 if os.name == 'posix':
548 if os.name == 'posix':
548 warn("The auto-indent feature requires the readline library")
549 warn("The auto-indent feature requires the readline library")
549 self.autoindent = 0
550 self.autoindent = 0
550 return
551 return
551 if value is None:
552 if value is None:
552 self.autoindent = not self.autoindent
553 self.autoindent = not self.autoindent
553 else:
554 else:
554 self.autoindent = value
555 self.autoindent = value
555
556
556 #-------------------------------------------------------------------------
557 #-------------------------------------------------------------------------
557 # init_* methods called by __init__
558 # init_* methods called by __init__
558 #-------------------------------------------------------------------------
559 #-------------------------------------------------------------------------
559
560
560 def init_ipython_dir(self, ipython_dir):
561 def init_ipython_dir(self, ipython_dir):
561 if ipython_dir is not None:
562 if ipython_dir is not None:
562 self.ipython_dir = ipython_dir
563 self.ipython_dir = ipython_dir
563 return
564 return
564
565
565 self.ipython_dir = get_ipython_dir()
566 self.ipython_dir = get_ipython_dir()
566
567
567 def init_profile_dir(self, profile_dir):
568 def init_profile_dir(self, profile_dir):
568 if profile_dir is not None:
569 if profile_dir is not None:
569 self.profile_dir = profile_dir
570 self.profile_dir = profile_dir
570 return
571 return
571 self.profile_dir =\
572 self.profile_dir =\
572 ProfileDir.create_profile_dir_by_name(self.ipython_dir, 'default')
573 ProfileDir.create_profile_dir_by_name(self.ipython_dir, 'default')
573
574
574 def init_instance_attrs(self):
575 def init_instance_attrs(self):
575 self.more = False
576 self.more = False
576
577
577 # command compiler
578 # command compiler
578 self.compile = CachingCompiler()
579 self.compile = CachingCompiler()
579
580
580 # Make an empty namespace, which extension writers can rely on both
581 # Make an empty namespace, which extension writers can rely on both
581 # existing and NEVER being used by ipython itself. This gives them a
582 # existing and NEVER being used by ipython itself. This gives them a
582 # convenient location for storing additional information and state
583 # convenient location for storing additional information and state
583 # their extensions may require, without fear of collisions with other
584 # their extensions may require, without fear of collisions with other
584 # ipython names that may develop later.
585 # ipython names that may develop later.
585 self.meta = Struct()
586 self.meta = Struct()
586
587
587 # Temporary files used for various purposes. Deleted at exit.
588 # Temporary files used for various purposes. Deleted at exit.
588 self.tempfiles = []
589 self.tempfiles = []
589 self.tempdirs = []
590 self.tempdirs = []
590
591
591 # Keep track of readline usage (later set by init_readline)
592 # Keep track of readline usage (later set by init_readline)
592 self.has_readline = False
593 self.has_readline = False
593
594
594 # keep track of where we started running (mainly for crash post-mortem)
595 # keep track of where we started running (mainly for crash post-mortem)
595 # This is not being used anywhere currently.
596 # This is not being used anywhere currently.
596 self.starting_dir = py3compat.getcwd()
597 self.starting_dir = py3compat.getcwd()
597
598
598 # Indentation management
599 # Indentation management
599 self.indent_current_nsp = 0
600 self.indent_current_nsp = 0
600
601
601 # Dict to track post-execution functions that have been registered
602 # Dict to track post-execution functions that have been registered
602 self._post_execute = {}
603 self._post_execute = {}
603
604
604 def init_environment(self):
605 def init_environment(self):
605 """Any changes we need to make to the user's environment."""
606 """Any changes we need to make to the user's environment."""
606 pass
607 pass
607
608
608 def init_encoding(self):
609 def init_encoding(self):
609 # Get system encoding at startup time. Certain terminals (like Emacs
610 # Get system encoding at startup time. Certain terminals (like Emacs
610 # under Win32 have it set to None, and we need to have a known valid
611 # under Win32 have it set to None, and we need to have a known valid
611 # encoding to use in the raw_input() method
612 # encoding to use in the raw_input() method
612 try:
613 try:
613 self.stdin_encoding = sys.stdin.encoding or 'ascii'
614 self.stdin_encoding = sys.stdin.encoding or 'ascii'
614 except AttributeError:
615 except AttributeError:
615 self.stdin_encoding = 'ascii'
616 self.stdin_encoding = 'ascii'
616
617
617 def init_syntax_highlighting(self):
618 def init_syntax_highlighting(self):
618 # Python source parser/formatter for syntax highlighting
619 # Python source parser/formatter for syntax highlighting
619 pyformat = PyColorize.Parser().format
620 pyformat = PyColorize.Parser().format
620 self.pycolorize = lambda src: pyformat(src,'str',self.colors)
621 self.pycolorize = lambda src: pyformat(src,'str',self.colors)
621
622
622 def init_pushd_popd_magic(self):
623 def init_pushd_popd_magic(self):
623 # for pushd/popd management
624 # for pushd/popd management
624 self.home_dir = get_home_dir()
625 self.home_dir = get_home_dir()
625
626
626 self.dir_stack = []
627 self.dir_stack = []
627
628
628 def init_logger(self):
629 def init_logger(self):
629 self.logger = Logger(self.home_dir, logfname='ipython_log.py',
630 self.logger = Logger(self.home_dir, logfname='ipython_log.py',
630 logmode='rotate')
631 logmode='rotate')
631
632
632 def init_logstart(self):
633 def init_logstart(self):
633 """Initialize logging in case it was requested at the command line.
634 """Initialize logging in case it was requested at the command line.
634 """
635 """
635 if self.logappend:
636 if self.logappend:
636 self.magic('logstart %s append' % self.logappend)
637 self.magic('logstart %s append' % self.logappend)
637 elif self.logfile:
638 elif self.logfile:
638 self.magic('logstart %s' % self.logfile)
639 self.magic('logstart %s' % self.logfile)
639 elif self.logstart:
640 elif self.logstart:
640 self.magic('logstart')
641 self.magic('logstart')
641
642
642 def init_builtins(self):
643 def init_builtins(self):
643 # A single, static flag that we set to True. Its presence indicates
644 # A single, static flag that we set to True. Its presence indicates
644 # that an IPython shell has been created, and we make no attempts at
645 # that an IPython shell has been created, and we make no attempts at
645 # removing on exit or representing the existence of more than one
646 # removing on exit or representing the existence of more than one
646 # IPython at a time.
647 # IPython at a time.
647 builtin_mod.__dict__['__IPYTHON__'] = True
648 builtin_mod.__dict__['__IPYTHON__'] = True
648
649
649 # In 0.11 we introduced '__IPYTHON__active' as an integer we'd try to
650 # In 0.11 we introduced '__IPYTHON__active' as an integer we'd try to
650 # manage on enter/exit, but with all our shells it's virtually
651 # manage on enter/exit, but with all our shells it's virtually
651 # impossible to get all the cases right. We're leaving the name in for
652 # impossible to get all the cases right. We're leaving the name in for
652 # those who adapted their codes to check for this flag, but will
653 # those who adapted their codes to check for this flag, but will
653 # eventually remove it after a few more releases.
654 # eventually remove it after a few more releases.
654 builtin_mod.__dict__['__IPYTHON__active'] = \
655 builtin_mod.__dict__['__IPYTHON__active'] = \
655 'Deprecated, check for __IPYTHON__'
656 'Deprecated, check for __IPYTHON__'
656
657
657 self.builtin_trap = BuiltinTrap(shell=self)
658 self.builtin_trap = BuiltinTrap(shell=self)
658
659
659 def init_inspector(self):
660 def init_inspector(self):
660 # Object inspector
661 # Object inspector
661 self.inspector = oinspect.Inspector(oinspect.InspectColors,
662 self.inspector = oinspect.Inspector(oinspect.InspectColors,
662 PyColorize.ANSICodeColors,
663 PyColorize.ANSICodeColors,
663 'NoColor',
664 'NoColor',
664 self.object_info_string_level)
665 self.object_info_string_level)
665
666
666 def init_io(self):
667 def init_io(self):
667 # This will just use sys.stdout and sys.stderr. If you want to
668 # This will just use sys.stdout and sys.stderr. If you want to
668 # override sys.stdout and sys.stderr themselves, you need to do that
669 # override sys.stdout and sys.stderr themselves, you need to do that
669 # *before* instantiating this class, because io holds onto
670 # *before* instantiating this class, because io holds onto
670 # references to the underlying streams.
671 # references to the underlying streams.
671 if (sys.platform == 'win32' or sys.platform == 'cli') and self.has_readline:
672 if (sys.platform == 'win32' or sys.platform == 'cli') and self.has_readline:
672 io.stdout = io.stderr = io.IOStream(self.readline._outputfile)
673 io.stdout = io.stderr = io.IOStream(self.readline._outputfile)
673 else:
674 else:
674 io.stdout = io.IOStream(sys.stdout)
675 io.stdout = io.IOStream(sys.stdout)
675 io.stderr = io.IOStream(sys.stderr)
676 io.stderr = io.IOStream(sys.stderr)
676
677
677 def init_prompts(self):
678 def init_prompts(self):
678 self.prompt_manager = PromptManager(shell=self, parent=self)
679 self.prompt_manager = PromptManager(shell=self, parent=self)
679 self.configurables.append(self.prompt_manager)
680 self.configurables.append(self.prompt_manager)
680 # Set system prompts, so that scripts can decide if they are running
681 # Set system prompts, so that scripts can decide if they are running
681 # interactively.
682 # interactively.
682 sys.ps1 = 'In : '
683 sys.ps1 = 'In : '
683 sys.ps2 = '...: '
684 sys.ps2 = '...: '
684 sys.ps3 = 'Out: '
685 sys.ps3 = 'Out: '
685
686
686 def init_display_formatter(self):
687 def init_display_formatter(self):
687 self.display_formatter = DisplayFormatter(parent=self)
688 self.display_formatter = DisplayFormatter(parent=self)
688 self.configurables.append(self.display_formatter)
689 self.configurables.append(self.display_formatter)
689
690
690 def init_display_pub(self):
691 def init_display_pub(self):
691 self.display_pub = self.display_pub_class(parent=self)
692 self.display_pub = self.display_pub_class(parent=self)
692 self.configurables.append(self.display_pub)
693 self.configurables.append(self.display_pub)
693
694
694 def init_data_pub(self):
695 def init_data_pub(self):
695 if not self.data_pub_class:
696 if not self.data_pub_class:
696 self.data_pub = None
697 self.data_pub = None
697 return
698 return
698 self.data_pub = self.data_pub_class(parent=self)
699 self.data_pub = self.data_pub_class(parent=self)
699 self.configurables.append(self.data_pub)
700 self.configurables.append(self.data_pub)
700
701
701 def init_displayhook(self):
702 def init_displayhook(self):
702 # Initialize displayhook, set in/out prompts and printing system
703 # Initialize displayhook, set in/out prompts and printing system
703 self.displayhook = self.displayhook_class(
704 self.displayhook = self.displayhook_class(
704 parent=self,
705 parent=self,
705 shell=self,
706 shell=self,
706 cache_size=self.cache_size,
707 cache_size=self.cache_size,
707 )
708 )
708 self.configurables.append(self.displayhook)
709 self.configurables.append(self.displayhook)
709 # This is a context manager that installs/revmoes the displayhook at
710 # This is a context manager that installs/revmoes the displayhook at
710 # the appropriate time.
711 # the appropriate time.
711 self.display_trap = DisplayTrap(hook=self.displayhook)
712 self.display_trap = DisplayTrap(hook=self.displayhook)
712
713
713 def init_latextool(self):
714 def init_latextool(self):
714 """Configure LaTeXTool."""
715 """Configure LaTeXTool."""
715 cfg = LaTeXTool.instance(parent=self)
716 cfg = LaTeXTool.instance(parent=self)
716 if cfg not in self.configurables:
717 if cfg not in self.configurables:
717 self.configurables.append(cfg)
718 self.configurables.append(cfg)
718
719
719 def init_virtualenv(self):
720 def init_virtualenv(self):
720 """Add a virtualenv to sys.path so the user can import modules from it.
721 """Add a virtualenv to sys.path so the user can import modules from it.
721 This isn't perfect: it doesn't use the Python interpreter with which the
722 This isn't perfect: it doesn't use the Python interpreter with which the
722 virtualenv was built, and it ignores the --no-site-packages option. A
723 virtualenv was built, and it ignores the --no-site-packages option. A
723 warning will appear suggesting the user installs IPython in the
724 warning will appear suggesting the user installs IPython in the
724 virtualenv, but for many cases, it probably works well enough.
725 virtualenv, but for many cases, it probably works well enough.
725
726
726 Adapted from code snippets online.
727 Adapted from code snippets online.
727
728
728 http://blog.ufsoft.org/2009/1/29/ipython-and-virtualenv
729 http://blog.ufsoft.org/2009/1/29/ipython-and-virtualenv
729 """
730 """
730 if 'VIRTUAL_ENV' not in os.environ:
731 if 'VIRTUAL_ENV' not in os.environ:
731 # Not in a virtualenv
732 # Not in a virtualenv
732 return
733 return
733
734
734 # venv detection:
735 # venv detection:
735 # stdlib venv may symlink sys.executable, so we can't use realpath.
736 # stdlib venv may symlink sys.executable, so we can't use realpath.
736 # but others can symlink *to* the venv Python, so we can't just use sys.executable.
737 # but others can symlink *to* the venv Python, so we can't just use sys.executable.
737 # So we just check every item in the symlink tree (generally <= 3)
738 # So we just check every item in the symlink tree (generally <= 3)
738 p = os.path.normcase(sys.executable)
739 p = os.path.normcase(sys.executable)
739 paths = [p]
740 paths = [p]
740 while os.path.islink(p):
741 while os.path.islink(p):
741 p = os.path.normcase(os.path.join(os.path.dirname(p), os.readlink(p)))
742 p = os.path.normcase(os.path.join(os.path.dirname(p), os.readlink(p)))
742 paths.append(p)
743 paths.append(p)
743 p_venv = os.path.normcase(os.environ['VIRTUAL_ENV'])
744 p_venv = os.path.normcase(os.environ['VIRTUAL_ENV'])
744 if any(p.startswith(p_venv) for p in paths):
745 if any(p.startswith(p_venv) for p in paths):
745 # Running properly in the virtualenv, don't need to do anything
746 # Running properly in the virtualenv, don't need to do anything
746 return
747 return
747
748
748 warn("Attempting to work in a virtualenv. If you encounter problems, please "
749 warn("Attempting to work in a virtualenv. If you encounter problems, please "
749 "install IPython inside the virtualenv.")
750 "install IPython inside the virtualenv.")
750 if sys.platform == "win32":
751 if sys.platform == "win32":
751 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'Lib', 'site-packages')
752 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'Lib', 'site-packages')
752 else:
753 else:
753 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'lib',
754 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'lib',
754 'python%d.%d' % sys.version_info[:2], 'site-packages')
755 'python%d.%d' % sys.version_info[:2], 'site-packages')
755
756
756 import site
757 import site
757 sys.path.insert(0, virtual_env)
758 sys.path.insert(0, virtual_env)
758 site.addsitedir(virtual_env)
759 site.addsitedir(virtual_env)
759
760
760 #-------------------------------------------------------------------------
761 #-------------------------------------------------------------------------
761 # Things related to injections into the sys module
762 # Things related to injections into the sys module
762 #-------------------------------------------------------------------------
763 #-------------------------------------------------------------------------
763
764
764 def save_sys_module_state(self):
765 def save_sys_module_state(self):
765 """Save the state of hooks in the sys module.
766 """Save the state of hooks in the sys module.
766
767
767 This has to be called after self.user_module is created.
768 This has to be called after self.user_module is created.
768 """
769 """
769 self._orig_sys_module_state = {}
770 self._orig_sys_module_state = {}
770 self._orig_sys_module_state['stdin'] = sys.stdin
771 self._orig_sys_module_state['stdin'] = sys.stdin
771 self._orig_sys_module_state['stdout'] = sys.stdout
772 self._orig_sys_module_state['stdout'] = sys.stdout
772 self._orig_sys_module_state['stderr'] = sys.stderr
773 self._orig_sys_module_state['stderr'] = sys.stderr
773 self._orig_sys_module_state['excepthook'] = sys.excepthook
774 self._orig_sys_module_state['excepthook'] = sys.excepthook
774 self._orig_sys_modules_main_name = self.user_module.__name__
775 self._orig_sys_modules_main_name = self.user_module.__name__
775 self._orig_sys_modules_main_mod = sys.modules.get(self.user_module.__name__)
776 self._orig_sys_modules_main_mod = sys.modules.get(self.user_module.__name__)
776
777
777 def restore_sys_module_state(self):
778 def restore_sys_module_state(self):
778 """Restore the state of the sys module."""
779 """Restore the state of the sys module."""
779 try:
780 try:
780 for k, v in iteritems(self._orig_sys_module_state):
781 for k, v in iteritems(self._orig_sys_module_state):
781 setattr(sys, k, v)
782 setattr(sys, k, v)
782 except AttributeError:
783 except AttributeError:
783 pass
784 pass
784 # Reset what what done in self.init_sys_modules
785 # Reset what what done in self.init_sys_modules
785 if self._orig_sys_modules_main_mod is not None:
786 if self._orig_sys_modules_main_mod is not None:
786 sys.modules[self._orig_sys_modules_main_name] = self._orig_sys_modules_main_mod
787 sys.modules[self._orig_sys_modules_main_name] = self._orig_sys_modules_main_mod
787
788
788 #-------------------------------------------------------------------------
789 #-------------------------------------------------------------------------
789 # Things related to the banner
790 # Things related to the banner
790 #-------------------------------------------------------------------------
791 #-------------------------------------------------------------------------
791
792
792 @property
793 @property
793 def banner(self):
794 def banner(self):
794 banner = self.banner1
795 banner = self.banner1
795 if self.profile and self.profile != 'default':
796 if self.profile and self.profile != 'default':
796 banner += '\nIPython profile: %s\n' % self.profile
797 banner += '\nIPython profile: %s\n' % self.profile
797 if self.banner2:
798 if self.banner2:
798 banner += '\n' + self.banner2
799 banner += '\n' + self.banner2
799 return banner
800 return banner
800
801
801 def show_banner(self, banner=None):
802 def show_banner(self, banner=None):
802 if banner is None:
803 if banner is None:
803 banner = self.banner
804 banner = self.banner
804 self.write(banner)
805 self.write(banner)
805
806
806 #-------------------------------------------------------------------------
807 #-------------------------------------------------------------------------
807 # Things related to hooks
808 # Things related to hooks
808 #-------------------------------------------------------------------------
809 #-------------------------------------------------------------------------
809
810
810 def init_hooks(self):
811 def init_hooks(self):
811 # hooks holds pointers used for user-side customizations
812 # hooks holds pointers used for user-side customizations
812 self.hooks = Struct()
813 self.hooks = Struct()
813
814
814 self.strdispatchers = {}
815 self.strdispatchers = {}
815
816
816 # Set all default hooks, defined in the IPython.hooks module.
817 # Set all default hooks, defined in the IPython.hooks module.
817 hooks = IPython.core.hooks
818 hooks = IPython.core.hooks
818 for hook_name in hooks.__all__:
819 for hook_name in hooks.__all__:
819 # default hooks have priority 100, i.e. low; user hooks should have
820 # default hooks have priority 100, i.e. low; user hooks should have
820 # 0-100 priority
821 # 0-100 priority
821 self.set_hook(hook_name,getattr(hooks,hook_name), 100, _warn_deprecated=False)
822 self.set_hook(hook_name,getattr(hooks,hook_name), 100, _warn_deprecated=False)
822
823
823 def set_hook(self,name,hook, priority=50, str_key=None, re_key=None,
824 def set_hook(self,name,hook, priority=50, str_key=None, re_key=None,
824 _warn_deprecated=True):
825 _warn_deprecated=True):
825 """set_hook(name,hook) -> sets an internal IPython hook.
826 """set_hook(name,hook) -> sets an internal IPython hook.
826
827
827 IPython exposes some of its internal API as user-modifiable hooks. By
828 IPython exposes some of its internal API as user-modifiable hooks. By
828 adding your function to one of these hooks, you can modify IPython's
829 adding your function to one of these hooks, you can modify IPython's
829 behavior to call at runtime your own routines."""
830 behavior to call at runtime your own routines."""
830
831
831 # At some point in the future, this should validate the hook before it
832 # At some point in the future, this should validate the hook before it
832 # accepts it. Probably at least check that the hook takes the number
833 # accepts it. Probably at least check that the hook takes the number
833 # of args it's supposed to.
834 # of args it's supposed to.
834
835
835 f = types.MethodType(hook,self)
836 f = types.MethodType(hook,self)
836
837
837 # check if the hook is for strdispatcher first
838 # check if the hook is for strdispatcher first
838 if str_key is not None:
839 if str_key is not None:
839 sdp = self.strdispatchers.get(name, StrDispatch())
840 sdp = self.strdispatchers.get(name, StrDispatch())
840 sdp.add_s(str_key, f, priority )
841 sdp.add_s(str_key, f, priority )
841 self.strdispatchers[name] = sdp
842 self.strdispatchers[name] = sdp
842 return
843 return
843 if re_key is not None:
844 if re_key is not None:
844 sdp = self.strdispatchers.get(name, StrDispatch())
845 sdp = self.strdispatchers.get(name, StrDispatch())
845 sdp.add_re(re.compile(re_key), f, priority )
846 sdp.add_re(re.compile(re_key), f, priority )
846 self.strdispatchers[name] = sdp
847 self.strdispatchers[name] = sdp
847 return
848 return
848
849
849 dp = getattr(self.hooks, name, None)
850 dp = getattr(self.hooks, name, None)
850 if name not in IPython.core.hooks.__all__:
851 if name not in IPython.core.hooks.__all__:
851 print("Warning! Hook '%s' is not one of %s" % \
852 print("Warning! Hook '%s' is not one of %s" % \
852 (name, IPython.core.hooks.__all__ ))
853 (name, IPython.core.hooks.__all__ ))
853
854
854 if _warn_deprecated and (name in IPython.core.hooks.deprecated):
855 if _warn_deprecated and (name in IPython.core.hooks.deprecated):
855 alternative = IPython.core.hooks.deprecated[name]
856 alternative = IPython.core.hooks.deprecated[name]
856 warn("Hook {} is deprecated. Use {} instead.".format(name, alternative))
857 warn("Hook {} is deprecated. Use {} instead.".format(name, alternative))
857
858
858 if not dp:
859 if not dp:
859 dp = IPython.core.hooks.CommandChainDispatcher()
860 dp = IPython.core.hooks.CommandChainDispatcher()
860
861
861 try:
862 try:
862 dp.add(f,priority)
863 dp.add(f,priority)
863 except AttributeError:
864 except AttributeError:
864 # it was not commandchain, plain old func - replace
865 # it was not commandchain, plain old func - replace
865 dp = f
866 dp = f
866
867
867 setattr(self.hooks,name, dp)
868 setattr(self.hooks,name, dp)
868
869
869 #-------------------------------------------------------------------------
870 #-------------------------------------------------------------------------
870 # Things related to events
871 # Things related to events
871 #-------------------------------------------------------------------------
872 #-------------------------------------------------------------------------
872
873
873 def init_events(self):
874 def init_events(self):
874 self.events = EventManager(self, available_events)
875 self.events = EventManager(self, available_events)
875
876
876 self.events.register("pre_execute", self._clear_warning_registry)
877 self.events.register("pre_execute", self._clear_warning_registry)
877
878
878 def register_post_execute(self, func):
879 def register_post_execute(self, func):
879 """DEPRECATED: Use ip.events.register('post_run_cell', func)
880 """DEPRECATED: Use ip.events.register('post_run_cell', func)
880
881
881 Register a function for calling after code execution.
882 Register a function for calling after code execution.
882 """
883 """
883 warn("ip.register_post_execute is deprecated, use "
884 warn("ip.register_post_execute is deprecated, use "
884 "ip.events.register('post_run_cell', func) instead.")
885 "ip.events.register('post_run_cell', func) instead.")
885 self.events.register('post_run_cell', func)
886 self.events.register('post_run_cell', func)
886
887
887 def _clear_warning_registry(self):
888 def _clear_warning_registry(self):
888 # clear the warning registry, so that different code blocks with
889 # clear the warning registry, so that different code blocks with
889 # overlapping line number ranges don't cause spurious suppression of
890 # overlapping line number ranges don't cause spurious suppression of
890 # warnings (see gh-6611 for details)
891 # warnings (see gh-6611 for details)
891 if "__warningregistry__" in self.user_global_ns:
892 if "__warningregistry__" in self.user_global_ns:
892 del self.user_global_ns["__warningregistry__"]
893 del self.user_global_ns["__warningregistry__"]
893
894
894 #-------------------------------------------------------------------------
895 #-------------------------------------------------------------------------
895 # Things related to the "main" module
896 # Things related to the "main" module
896 #-------------------------------------------------------------------------
897 #-------------------------------------------------------------------------
897
898
898 def new_main_mod(self, filename, modname):
899 def new_main_mod(self, filename, modname):
899 """Return a new 'main' module object for user code execution.
900 """Return a new 'main' module object for user code execution.
900
901
901 ``filename`` should be the path of the script which will be run in the
902 ``filename`` should be the path of the script which will be run in the
902 module. Requests with the same filename will get the same module, with
903 module. Requests with the same filename will get the same module, with
903 its namespace cleared.
904 its namespace cleared.
904
905
905 ``modname`` should be the module name - normally either '__main__' or
906 ``modname`` should be the module name - normally either '__main__' or
906 the basename of the file without the extension.
907 the basename of the file without the extension.
907
908
908 When scripts are executed via %run, we must keep a reference to their
909 When scripts are executed via %run, we must keep a reference to their
909 __main__ module around so that Python doesn't
910 __main__ module around so that Python doesn't
910 clear it, rendering references to module globals useless.
911 clear it, rendering references to module globals useless.
911
912
912 This method keeps said reference in a private dict, keyed by the
913 This method keeps said reference in a private dict, keyed by the
913 absolute path of the script. This way, for multiple executions of the
914 absolute path of the script. This way, for multiple executions of the
914 same script we only keep one copy of the namespace (the last one),
915 same script we only keep one copy of the namespace (the last one),
915 thus preventing memory leaks from old references while allowing the
916 thus preventing memory leaks from old references while allowing the
916 objects from the last execution to be accessible.
917 objects from the last execution to be accessible.
917 """
918 """
918 filename = os.path.abspath(filename)
919 filename = os.path.abspath(filename)
919 try:
920 try:
920 main_mod = self._main_mod_cache[filename]
921 main_mod = self._main_mod_cache[filename]
921 except KeyError:
922 except KeyError:
922 main_mod = self._main_mod_cache[filename] = types.ModuleType(
923 main_mod = self._main_mod_cache[filename] = types.ModuleType(
923 py3compat.cast_bytes_py2(modname),
924 py3compat.cast_bytes_py2(modname),
924 doc="Module created for script run in IPython")
925 doc="Module created for script run in IPython")
925 else:
926 else:
926 main_mod.__dict__.clear()
927 main_mod.__dict__.clear()
927 main_mod.__name__ = modname
928 main_mod.__name__ = modname
928
929
929 main_mod.__file__ = filename
930 main_mod.__file__ = filename
930 # It seems pydoc (and perhaps others) needs any module instance to
931 # It seems pydoc (and perhaps others) needs any module instance to
931 # implement a __nonzero__ method
932 # implement a __nonzero__ method
932 main_mod.__nonzero__ = lambda : True
933 main_mod.__nonzero__ = lambda : True
933
934
934 return main_mod
935 return main_mod
935
936
936 def clear_main_mod_cache(self):
937 def clear_main_mod_cache(self):
937 """Clear the cache of main modules.
938 """Clear the cache of main modules.
938
939
939 Mainly for use by utilities like %reset.
940 Mainly for use by utilities like %reset.
940
941
941 Examples
942 Examples
942 --------
943 --------
943
944
944 In [15]: import IPython
945 In [15]: import IPython
945
946
946 In [16]: m = _ip.new_main_mod(IPython.__file__, 'IPython')
947 In [16]: m = _ip.new_main_mod(IPython.__file__, 'IPython')
947
948
948 In [17]: len(_ip._main_mod_cache) > 0
949 In [17]: len(_ip._main_mod_cache) > 0
949 Out[17]: True
950 Out[17]: True
950
951
951 In [18]: _ip.clear_main_mod_cache()
952 In [18]: _ip.clear_main_mod_cache()
952
953
953 In [19]: len(_ip._main_mod_cache) == 0
954 In [19]: len(_ip._main_mod_cache) == 0
954 Out[19]: True
955 Out[19]: True
955 """
956 """
956 self._main_mod_cache.clear()
957 self._main_mod_cache.clear()
957
958
958 #-------------------------------------------------------------------------
959 #-------------------------------------------------------------------------
959 # Things related to debugging
960 # Things related to debugging
960 #-------------------------------------------------------------------------
961 #-------------------------------------------------------------------------
961
962
962 def init_pdb(self):
963 def init_pdb(self):
963 # Set calling of pdb on exceptions
964 # Set calling of pdb on exceptions
964 # self.call_pdb is a property
965 # self.call_pdb is a property
965 self.call_pdb = self.pdb
966 self.call_pdb = self.pdb
966
967
967 def _get_call_pdb(self):
968 def _get_call_pdb(self):
968 return self._call_pdb
969 return self._call_pdb
969
970
970 def _set_call_pdb(self,val):
971 def _set_call_pdb(self,val):
971
972
972 if val not in (0,1,False,True):
973 if val not in (0,1,False,True):
973 raise ValueError('new call_pdb value must be boolean')
974 raise ValueError('new call_pdb value must be boolean')
974
975
975 # store value in instance
976 # store value in instance
976 self._call_pdb = val
977 self._call_pdb = val
977
978
978 # notify the actual exception handlers
979 # notify the actual exception handlers
979 self.InteractiveTB.call_pdb = val
980 self.InteractiveTB.call_pdb = val
980
981
981 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
982 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
982 'Control auto-activation of pdb at exceptions')
983 'Control auto-activation of pdb at exceptions')
983
984
984 def debugger(self,force=False):
985 def debugger(self,force=False):
985 """Call the pydb/pdb debugger.
986 """Call the pydb/pdb debugger.
986
987
987 Keywords:
988 Keywords:
988
989
989 - force(False): by default, this routine checks the instance call_pdb
990 - force(False): by default, this routine checks the instance call_pdb
990 flag and does not actually invoke the debugger if the flag is false.
991 flag and does not actually invoke the debugger if the flag is false.
991 The 'force' option forces the debugger to activate even if the flag
992 The 'force' option forces the debugger to activate even if the flag
992 is false.
993 is false.
993 """
994 """
994
995
995 if not (force or self.call_pdb):
996 if not (force or self.call_pdb):
996 return
997 return
997
998
998 if not hasattr(sys,'last_traceback'):
999 if not hasattr(sys,'last_traceback'):
999 error('No traceback has been produced, nothing to debug.')
1000 error('No traceback has been produced, nothing to debug.')
1000 return
1001 return
1001
1002
1002 # use pydb if available
1003 # use pydb if available
1003 if debugger.has_pydb:
1004 if debugger.has_pydb:
1004 from pydb import pm
1005 from pydb import pm
1005 else:
1006 else:
1006 # fallback to our internal debugger
1007 # fallback to our internal debugger
1007 pm = lambda : self.InteractiveTB.debugger(force=True)
1008 pm = lambda : self.InteractiveTB.debugger(force=True)
1008
1009
1009 with self.readline_no_record:
1010 with self.readline_no_record:
1010 pm()
1011 pm()
1011
1012
1012 #-------------------------------------------------------------------------
1013 #-------------------------------------------------------------------------
1013 # Things related to IPython's various namespaces
1014 # Things related to IPython's various namespaces
1014 #-------------------------------------------------------------------------
1015 #-------------------------------------------------------------------------
1015 default_user_namespaces = True
1016 default_user_namespaces = True
1016
1017
1017 def init_create_namespaces(self, user_module=None, user_ns=None):
1018 def init_create_namespaces(self, user_module=None, user_ns=None):
1018 # Create the namespace where the user will operate. user_ns is
1019 # Create the namespace where the user will operate. user_ns is
1019 # normally the only one used, and it is passed to the exec calls as
1020 # normally the only one used, and it is passed to the exec calls as
1020 # the locals argument. But we do carry a user_global_ns namespace
1021 # the locals argument. But we do carry a user_global_ns namespace
1021 # given as the exec 'globals' argument, This is useful in embedding
1022 # given as the exec 'globals' argument, This is useful in embedding
1022 # situations where the ipython shell opens in a context where the
1023 # situations where the ipython shell opens in a context where the
1023 # distinction between locals and globals is meaningful. For
1024 # distinction between locals and globals is meaningful. For
1024 # non-embedded contexts, it is just the same object as the user_ns dict.
1025 # non-embedded contexts, it is just the same object as the user_ns dict.
1025
1026
1026 # FIXME. For some strange reason, __builtins__ is showing up at user
1027 # FIXME. For some strange reason, __builtins__ is showing up at user
1027 # level as a dict instead of a module. This is a manual fix, but I
1028 # level as a dict instead of a module. This is a manual fix, but I
1028 # should really track down where the problem is coming from. Alex
1029 # should really track down where the problem is coming from. Alex
1029 # Schmolck reported this problem first.
1030 # Schmolck reported this problem first.
1030
1031
1031 # A useful post by Alex Martelli on this topic:
1032 # A useful post by Alex Martelli on this topic:
1032 # Re: inconsistent value from __builtins__
1033 # Re: inconsistent value from __builtins__
1033 # Von: Alex Martelli <aleaxit@yahoo.com>
1034 # Von: Alex Martelli <aleaxit@yahoo.com>
1034 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
1035 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
1035 # Gruppen: comp.lang.python
1036 # Gruppen: comp.lang.python
1036
1037
1037 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
1038 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
1038 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
1039 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
1039 # > <type 'dict'>
1040 # > <type 'dict'>
1040 # > >>> print type(__builtins__)
1041 # > >>> print type(__builtins__)
1041 # > <type 'module'>
1042 # > <type 'module'>
1042 # > Is this difference in return value intentional?
1043 # > Is this difference in return value intentional?
1043
1044
1044 # Well, it's documented that '__builtins__' can be either a dictionary
1045 # Well, it's documented that '__builtins__' can be either a dictionary
1045 # or a module, and it's been that way for a long time. Whether it's
1046 # or a module, and it's been that way for a long time. Whether it's
1046 # intentional (or sensible), I don't know. In any case, the idea is
1047 # intentional (or sensible), I don't know. In any case, the idea is
1047 # that if you need to access the built-in namespace directly, you
1048 # that if you need to access the built-in namespace directly, you
1048 # should start with "import __builtin__" (note, no 's') which will
1049 # should start with "import __builtin__" (note, no 's') which will
1049 # definitely give you a module. Yeah, it's somewhat confusing:-(.
1050 # definitely give you a module. Yeah, it's somewhat confusing:-(.
1050
1051
1051 # These routines return a properly built module and dict as needed by
1052 # These routines return a properly built module and dict as needed by
1052 # the rest of the code, and can also be used by extension writers to
1053 # the rest of the code, and can also be used by extension writers to
1053 # generate properly initialized namespaces.
1054 # generate properly initialized namespaces.
1054 if (user_ns is not None) or (user_module is not None):
1055 if (user_ns is not None) or (user_module is not None):
1055 self.default_user_namespaces = False
1056 self.default_user_namespaces = False
1056 self.user_module, self.user_ns = self.prepare_user_module(user_module, user_ns)
1057 self.user_module, self.user_ns = self.prepare_user_module(user_module, user_ns)
1057
1058
1058 # A record of hidden variables we have added to the user namespace, so
1059 # A record of hidden variables we have added to the user namespace, so
1059 # we can list later only variables defined in actual interactive use.
1060 # we can list later only variables defined in actual interactive use.
1060 self.user_ns_hidden = {}
1061 self.user_ns_hidden = {}
1061
1062
1062 # Now that FakeModule produces a real module, we've run into a nasty
1063 # Now that FakeModule produces a real module, we've run into a nasty
1063 # problem: after script execution (via %run), the module where the user
1064 # problem: after script execution (via %run), the module where the user
1064 # code ran is deleted. Now that this object is a true module (needed
1065 # code ran is deleted. Now that this object is a true module (needed
1065 # so docetst and other tools work correctly), the Python module
1066 # so docetst and other tools work correctly), the Python module
1066 # teardown mechanism runs over it, and sets to None every variable
1067 # teardown mechanism runs over it, and sets to None every variable
1067 # present in that module. Top-level references to objects from the
1068 # present in that module. Top-level references to objects from the
1068 # script survive, because the user_ns is updated with them. However,
1069 # script survive, because the user_ns is updated with them. However,
1069 # calling functions defined in the script that use other things from
1070 # calling functions defined in the script that use other things from
1070 # the script will fail, because the function's closure had references
1071 # the script will fail, because the function's closure had references
1071 # to the original objects, which are now all None. So we must protect
1072 # to the original objects, which are now all None. So we must protect
1072 # these modules from deletion by keeping a cache.
1073 # these modules from deletion by keeping a cache.
1073 #
1074 #
1074 # To avoid keeping stale modules around (we only need the one from the
1075 # To avoid keeping stale modules around (we only need the one from the
1075 # last run), we use a dict keyed with the full path to the script, so
1076 # last run), we use a dict keyed with the full path to the script, so
1076 # only the last version of the module is held in the cache. Note,
1077 # only the last version of the module is held in the cache. Note,
1077 # however, that we must cache the module *namespace contents* (their
1078 # however, that we must cache the module *namespace contents* (their
1078 # __dict__). Because if we try to cache the actual modules, old ones
1079 # __dict__). Because if we try to cache the actual modules, old ones
1079 # (uncached) could be destroyed while still holding references (such as
1080 # (uncached) could be destroyed while still holding references (such as
1080 # those held by GUI objects that tend to be long-lived)>
1081 # those held by GUI objects that tend to be long-lived)>
1081 #
1082 #
1082 # The %reset command will flush this cache. See the cache_main_mod()
1083 # The %reset command will flush this cache. See the cache_main_mod()
1083 # and clear_main_mod_cache() methods for details on use.
1084 # and clear_main_mod_cache() methods for details on use.
1084
1085
1085 # This is the cache used for 'main' namespaces
1086 # This is the cache used for 'main' namespaces
1086 self._main_mod_cache = {}
1087 self._main_mod_cache = {}
1087
1088
1088 # A table holding all the namespaces IPython deals with, so that
1089 # A table holding all the namespaces IPython deals with, so that
1089 # introspection facilities can search easily.
1090 # introspection facilities can search easily.
1090 self.ns_table = {'user_global':self.user_module.__dict__,
1091 self.ns_table = {'user_global':self.user_module.__dict__,
1091 'user_local':self.user_ns,
1092 'user_local':self.user_ns,
1092 'builtin':builtin_mod.__dict__
1093 'builtin':builtin_mod.__dict__
1093 }
1094 }
1094
1095
1095 @property
1096 @property
1096 def user_global_ns(self):
1097 def user_global_ns(self):
1097 return self.user_module.__dict__
1098 return self.user_module.__dict__
1098
1099
1099 def prepare_user_module(self, user_module=None, user_ns=None):
1100 def prepare_user_module(self, user_module=None, user_ns=None):
1100 """Prepare the module and namespace in which user code will be run.
1101 """Prepare the module and namespace in which user code will be run.
1101
1102
1102 When IPython is started normally, both parameters are None: a new module
1103 When IPython is started normally, both parameters are None: a new module
1103 is created automatically, and its __dict__ used as the namespace.
1104 is created automatically, and its __dict__ used as the namespace.
1104
1105
1105 If only user_module is provided, its __dict__ is used as the namespace.
1106 If only user_module is provided, its __dict__ is used as the namespace.
1106 If only user_ns is provided, a dummy module is created, and user_ns
1107 If only user_ns is provided, a dummy module is created, and user_ns
1107 becomes the global namespace. If both are provided (as they may be
1108 becomes the global namespace. If both are provided (as they may be
1108 when embedding), user_ns is the local namespace, and user_module
1109 when embedding), user_ns is the local namespace, and user_module
1109 provides the global namespace.
1110 provides the global namespace.
1110
1111
1111 Parameters
1112 Parameters
1112 ----------
1113 ----------
1113 user_module : module, optional
1114 user_module : module, optional
1114 The current user module in which IPython is being run. If None,
1115 The current user module in which IPython is being run. If None,
1115 a clean module will be created.
1116 a clean module will be created.
1116 user_ns : dict, optional
1117 user_ns : dict, optional
1117 A namespace in which to run interactive commands.
1118 A namespace in which to run interactive commands.
1118
1119
1119 Returns
1120 Returns
1120 -------
1121 -------
1121 A tuple of user_module and user_ns, each properly initialised.
1122 A tuple of user_module and user_ns, each properly initialised.
1122 """
1123 """
1123 if user_module is None and user_ns is not None:
1124 if user_module is None and user_ns is not None:
1124 user_ns.setdefault("__name__", "__main__")
1125 user_ns.setdefault("__name__", "__main__")
1125 user_module = DummyMod()
1126 user_module = DummyMod()
1126 user_module.__dict__ = user_ns
1127 user_module.__dict__ = user_ns
1127
1128
1128 if user_module is None:
1129 if user_module is None:
1129 user_module = types.ModuleType("__main__",
1130 user_module = types.ModuleType("__main__",
1130 doc="Automatically created module for IPython interactive environment")
1131 doc="Automatically created module for IPython interactive environment")
1131
1132
1132 # We must ensure that __builtin__ (without the final 's') is always
1133 # We must ensure that __builtin__ (without the final 's') is always
1133 # available and pointing to the __builtin__ *module*. For more details:
1134 # available and pointing to the __builtin__ *module*. For more details:
1134 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1135 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1135 user_module.__dict__.setdefault('__builtin__', builtin_mod)
1136 user_module.__dict__.setdefault('__builtin__', builtin_mod)
1136 user_module.__dict__.setdefault('__builtins__', builtin_mod)
1137 user_module.__dict__.setdefault('__builtins__', builtin_mod)
1137
1138
1138 if user_ns is None:
1139 if user_ns is None:
1139 user_ns = user_module.__dict__
1140 user_ns = user_module.__dict__
1140
1141
1141 return user_module, user_ns
1142 return user_module, user_ns
1142
1143
1143 def init_sys_modules(self):
1144 def init_sys_modules(self):
1144 # We need to insert into sys.modules something that looks like a
1145 # We need to insert into sys.modules something that looks like a
1145 # module but which accesses the IPython namespace, for shelve and
1146 # module but which accesses the IPython namespace, for shelve and
1146 # pickle to work interactively. Normally they rely on getting
1147 # pickle to work interactively. Normally they rely on getting
1147 # everything out of __main__, but for embedding purposes each IPython
1148 # everything out of __main__, but for embedding purposes each IPython
1148 # instance has its own private namespace, so we can't go shoving
1149 # instance has its own private namespace, so we can't go shoving
1149 # everything into __main__.
1150 # everything into __main__.
1150
1151
1151 # note, however, that we should only do this for non-embedded
1152 # note, however, that we should only do this for non-embedded
1152 # ipythons, which really mimic the __main__.__dict__ with their own
1153 # ipythons, which really mimic the __main__.__dict__ with their own
1153 # namespace. Embedded instances, on the other hand, should not do
1154 # namespace. Embedded instances, on the other hand, should not do
1154 # this because they need to manage the user local/global namespaces
1155 # this because they need to manage the user local/global namespaces
1155 # only, but they live within a 'normal' __main__ (meaning, they
1156 # only, but they live within a 'normal' __main__ (meaning, they
1156 # shouldn't overtake the execution environment of the script they're
1157 # shouldn't overtake the execution environment of the script they're
1157 # embedded in).
1158 # embedded in).
1158
1159
1159 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
1160 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
1160 main_name = self.user_module.__name__
1161 main_name = self.user_module.__name__
1161 sys.modules[main_name] = self.user_module
1162 sys.modules[main_name] = self.user_module
1162
1163
1163 def init_user_ns(self):
1164 def init_user_ns(self):
1164 """Initialize all user-visible namespaces to their minimum defaults.
1165 """Initialize all user-visible namespaces to their minimum defaults.
1165
1166
1166 Certain history lists are also initialized here, as they effectively
1167 Certain history lists are also initialized here, as they effectively
1167 act as user namespaces.
1168 act as user namespaces.
1168
1169
1169 Notes
1170 Notes
1170 -----
1171 -----
1171 All data structures here are only filled in, they are NOT reset by this
1172 All data structures here are only filled in, they are NOT reset by this
1172 method. If they were not empty before, data will simply be added to
1173 method. If they were not empty before, data will simply be added to
1173 therm.
1174 therm.
1174 """
1175 """
1175 # This function works in two parts: first we put a few things in
1176 # This function works in two parts: first we put a few things in
1176 # user_ns, and we sync that contents into user_ns_hidden so that these
1177 # user_ns, and we sync that contents into user_ns_hidden so that these
1177 # initial variables aren't shown by %who. After the sync, we add the
1178 # initial variables aren't shown by %who. After the sync, we add the
1178 # rest of what we *do* want the user to see with %who even on a new
1179 # rest of what we *do* want the user to see with %who even on a new
1179 # session (probably nothing, so theye really only see their own stuff)
1180 # session (probably nothing, so theye really only see their own stuff)
1180
1181
1181 # The user dict must *always* have a __builtin__ reference to the
1182 # The user dict must *always* have a __builtin__ reference to the
1182 # Python standard __builtin__ namespace, which must be imported.
1183 # Python standard __builtin__ namespace, which must be imported.
1183 # This is so that certain operations in prompt evaluation can be
1184 # This is so that certain operations in prompt evaluation can be
1184 # reliably executed with builtins. Note that we can NOT use
1185 # reliably executed with builtins. Note that we can NOT use
1185 # __builtins__ (note the 's'), because that can either be a dict or a
1186 # __builtins__ (note the 's'), because that can either be a dict or a
1186 # module, and can even mutate at runtime, depending on the context
1187 # module, and can even mutate at runtime, depending on the context
1187 # (Python makes no guarantees on it). In contrast, __builtin__ is
1188 # (Python makes no guarantees on it). In contrast, __builtin__ is
1188 # always a module object, though it must be explicitly imported.
1189 # always a module object, though it must be explicitly imported.
1189
1190
1190 # For more details:
1191 # For more details:
1191 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1192 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1192 ns = dict()
1193 ns = dict()
1193
1194
1194 # make global variables for user access to the histories
1195 # make global variables for user access to the histories
1195 ns['_ih'] = self.history_manager.input_hist_parsed
1196 ns['_ih'] = self.history_manager.input_hist_parsed
1196 ns['_oh'] = self.history_manager.output_hist
1197 ns['_oh'] = self.history_manager.output_hist
1197 ns['_dh'] = self.history_manager.dir_hist
1198 ns['_dh'] = self.history_manager.dir_hist
1198
1199
1199 ns['_sh'] = shadowns
1200 ns['_sh'] = shadowns
1200
1201
1201 # user aliases to input and output histories. These shouldn't show up
1202 # user aliases to input and output histories. These shouldn't show up
1202 # in %who, as they can have very large reprs.
1203 # in %who, as they can have very large reprs.
1203 ns['In'] = self.history_manager.input_hist_parsed
1204 ns['In'] = self.history_manager.input_hist_parsed
1204 ns['Out'] = self.history_manager.output_hist
1205 ns['Out'] = self.history_manager.output_hist
1205
1206
1206 # Store myself as the public api!!!
1207 # Store myself as the public api!!!
1207 ns['get_ipython'] = self.get_ipython
1208 ns['get_ipython'] = self.get_ipython
1208
1209
1209 ns['exit'] = self.exiter
1210 ns['exit'] = self.exiter
1210 ns['quit'] = self.exiter
1211 ns['quit'] = self.exiter
1211
1212
1212 # Sync what we've added so far to user_ns_hidden so these aren't seen
1213 # Sync what we've added so far to user_ns_hidden so these aren't seen
1213 # by %who
1214 # by %who
1214 self.user_ns_hidden.update(ns)
1215 self.user_ns_hidden.update(ns)
1215
1216
1216 # Anything put into ns now would show up in %who. Think twice before
1217 # Anything put into ns now would show up in %who. Think twice before
1217 # putting anything here, as we really want %who to show the user their
1218 # putting anything here, as we really want %who to show the user their
1218 # stuff, not our variables.
1219 # stuff, not our variables.
1219
1220
1220 # Finally, update the real user's namespace
1221 # Finally, update the real user's namespace
1221 self.user_ns.update(ns)
1222 self.user_ns.update(ns)
1222
1223
1223 @property
1224 @property
1224 def all_ns_refs(self):
1225 def all_ns_refs(self):
1225 """Get a list of references to all the namespace dictionaries in which
1226 """Get a list of references to all the namespace dictionaries in which
1226 IPython might store a user-created object.
1227 IPython might store a user-created object.
1227
1228
1228 Note that this does not include the displayhook, which also caches
1229 Note that this does not include the displayhook, which also caches
1229 objects from the output."""
1230 objects from the output."""
1230 return [self.user_ns, self.user_global_ns, self.user_ns_hidden] + \
1231 return [self.user_ns, self.user_global_ns, self.user_ns_hidden] + \
1231 [m.__dict__ for m in self._main_mod_cache.values()]
1232 [m.__dict__ for m in self._main_mod_cache.values()]
1232
1233
1233 def reset(self, new_session=True):
1234 def reset(self, new_session=True):
1234 """Clear all internal namespaces, and attempt to release references to
1235 """Clear all internal namespaces, and attempt to release references to
1235 user objects.
1236 user objects.
1236
1237
1237 If new_session is True, a new history session will be opened.
1238 If new_session is True, a new history session will be opened.
1238 """
1239 """
1239 # Clear histories
1240 # Clear histories
1240 self.history_manager.reset(new_session)
1241 self.history_manager.reset(new_session)
1241 # Reset counter used to index all histories
1242 # Reset counter used to index all histories
1242 if new_session:
1243 if new_session:
1243 self.execution_count = 1
1244 self.execution_count = 1
1244
1245
1245 # Flush cached output items
1246 # Flush cached output items
1246 if self.displayhook.do_full_cache:
1247 if self.displayhook.do_full_cache:
1247 self.displayhook.flush()
1248 self.displayhook.flush()
1248
1249
1249 # The main execution namespaces must be cleared very carefully,
1250 # The main execution namespaces must be cleared very carefully,
1250 # skipping the deletion of the builtin-related keys, because doing so
1251 # skipping the deletion of the builtin-related keys, because doing so
1251 # would cause errors in many object's __del__ methods.
1252 # would cause errors in many object's __del__ methods.
1252 if self.user_ns is not self.user_global_ns:
1253 if self.user_ns is not self.user_global_ns:
1253 self.user_ns.clear()
1254 self.user_ns.clear()
1254 ns = self.user_global_ns
1255 ns = self.user_global_ns
1255 drop_keys = set(ns.keys())
1256 drop_keys = set(ns.keys())
1256 drop_keys.discard('__builtin__')
1257 drop_keys.discard('__builtin__')
1257 drop_keys.discard('__builtins__')
1258 drop_keys.discard('__builtins__')
1258 drop_keys.discard('__name__')
1259 drop_keys.discard('__name__')
1259 for k in drop_keys:
1260 for k in drop_keys:
1260 del ns[k]
1261 del ns[k]
1261
1262
1262 self.user_ns_hidden.clear()
1263 self.user_ns_hidden.clear()
1263
1264
1264 # Restore the user namespaces to minimal usability
1265 # Restore the user namespaces to minimal usability
1265 self.init_user_ns()
1266 self.init_user_ns()
1266
1267
1267 # Restore the default and user aliases
1268 # Restore the default and user aliases
1268 self.alias_manager.clear_aliases()
1269 self.alias_manager.clear_aliases()
1269 self.alias_manager.init_aliases()
1270 self.alias_manager.init_aliases()
1270
1271
1271 # Flush the private list of module references kept for script
1272 # Flush the private list of module references kept for script
1272 # execution protection
1273 # execution protection
1273 self.clear_main_mod_cache()
1274 self.clear_main_mod_cache()
1274
1275
1275 def del_var(self, varname, by_name=False):
1276 def del_var(self, varname, by_name=False):
1276 """Delete a variable from the various namespaces, so that, as
1277 """Delete a variable from the various namespaces, so that, as
1277 far as possible, we're not keeping any hidden references to it.
1278 far as possible, we're not keeping any hidden references to it.
1278
1279
1279 Parameters
1280 Parameters
1280 ----------
1281 ----------
1281 varname : str
1282 varname : str
1282 The name of the variable to delete.
1283 The name of the variable to delete.
1283 by_name : bool
1284 by_name : bool
1284 If True, delete variables with the given name in each
1285 If True, delete variables with the given name in each
1285 namespace. If False (default), find the variable in the user
1286 namespace. If False (default), find the variable in the user
1286 namespace, and delete references to it.
1287 namespace, and delete references to it.
1287 """
1288 """
1288 if varname in ('__builtin__', '__builtins__'):
1289 if varname in ('__builtin__', '__builtins__'):
1289 raise ValueError("Refusing to delete %s" % varname)
1290 raise ValueError("Refusing to delete %s" % varname)
1290
1291
1291 ns_refs = self.all_ns_refs
1292 ns_refs = self.all_ns_refs
1292
1293
1293 if by_name: # Delete by name
1294 if by_name: # Delete by name
1294 for ns in ns_refs:
1295 for ns in ns_refs:
1295 try:
1296 try:
1296 del ns[varname]
1297 del ns[varname]
1297 except KeyError:
1298 except KeyError:
1298 pass
1299 pass
1299 else: # Delete by object
1300 else: # Delete by object
1300 try:
1301 try:
1301 obj = self.user_ns[varname]
1302 obj = self.user_ns[varname]
1302 except KeyError:
1303 except KeyError:
1303 raise NameError("name '%s' is not defined" % varname)
1304 raise NameError("name '%s' is not defined" % varname)
1304 # Also check in output history
1305 # Also check in output history
1305 ns_refs.append(self.history_manager.output_hist)
1306 ns_refs.append(self.history_manager.output_hist)
1306 for ns in ns_refs:
1307 for ns in ns_refs:
1307 to_delete = [n for n, o in iteritems(ns) if o is obj]
1308 to_delete = [n for n, o in iteritems(ns) if o is obj]
1308 for name in to_delete:
1309 for name in to_delete:
1309 del ns[name]
1310 del ns[name]
1310
1311
1311 # displayhook keeps extra references, but not in a dictionary
1312 # displayhook keeps extra references, but not in a dictionary
1312 for name in ('_', '__', '___'):
1313 for name in ('_', '__', '___'):
1313 if getattr(self.displayhook, name) is obj:
1314 if getattr(self.displayhook, name) is obj:
1314 setattr(self.displayhook, name, None)
1315 setattr(self.displayhook, name, None)
1315
1316
1316 def reset_selective(self, regex=None):
1317 def reset_selective(self, regex=None):
1317 """Clear selective variables from internal namespaces based on a
1318 """Clear selective variables from internal namespaces based on a
1318 specified regular expression.
1319 specified regular expression.
1319
1320
1320 Parameters
1321 Parameters
1321 ----------
1322 ----------
1322 regex : string or compiled pattern, optional
1323 regex : string or compiled pattern, optional
1323 A regular expression pattern that will be used in searching
1324 A regular expression pattern that will be used in searching
1324 variable names in the users namespaces.
1325 variable names in the users namespaces.
1325 """
1326 """
1326 if regex is not None:
1327 if regex is not None:
1327 try:
1328 try:
1328 m = re.compile(regex)
1329 m = re.compile(regex)
1329 except TypeError:
1330 except TypeError:
1330 raise TypeError('regex must be a string or compiled pattern')
1331 raise TypeError('regex must be a string or compiled pattern')
1331 # Search for keys in each namespace that match the given regex
1332 # Search for keys in each namespace that match the given regex
1332 # If a match is found, delete the key/value pair.
1333 # If a match is found, delete the key/value pair.
1333 for ns in self.all_ns_refs:
1334 for ns in self.all_ns_refs:
1334 for var in ns:
1335 for var in ns:
1335 if m.search(var):
1336 if m.search(var):
1336 del ns[var]
1337 del ns[var]
1337
1338
1338 def push(self, variables, interactive=True):
1339 def push(self, variables, interactive=True):
1339 """Inject a group of variables into the IPython user namespace.
1340 """Inject a group of variables into the IPython user namespace.
1340
1341
1341 Parameters
1342 Parameters
1342 ----------
1343 ----------
1343 variables : dict, str or list/tuple of str
1344 variables : dict, str or list/tuple of str
1344 The variables to inject into the user's namespace. If a dict, a
1345 The variables to inject into the user's namespace. If a dict, a
1345 simple update is done. If a str, the string is assumed to have
1346 simple update is done. If a str, the string is assumed to have
1346 variable names separated by spaces. A list/tuple of str can also
1347 variable names separated by spaces. A list/tuple of str can also
1347 be used to give the variable names. If just the variable names are
1348 be used to give the variable names. If just the variable names are
1348 give (list/tuple/str) then the variable values looked up in the
1349 give (list/tuple/str) then the variable values looked up in the
1349 callers frame.
1350 callers frame.
1350 interactive : bool
1351 interactive : bool
1351 If True (default), the variables will be listed with the ``who``
1352 If True (default), the variables will be listed with the ``who``
1352 magic.
1353 magic.
1353 """
1354 """
1354 vdict = None
1355 vdict = None
1355
1356
1356 # We need a dict of name/value pairs to do namespace updates.
1357 # We need a dict of name/value pairs to do namespace updates.
1357 if isinstance(variables, dict):
1358 if isinstance(variables, dict):
1358 vdict = variables
1359 vdict = variables
1359 elif isinstance(variables, string_types+(list, tuple)):
1360 elif isinstance(variables, string_types+(list, tuple)):
1360 if isinstance(variables, string_types):
1361 if isinstance(variables, string_types):
1361 vlist = variables.split()
1362 vlist = variables.split()
1362 else:
1363 else:
1363 vlist = variables
1364 vlist = variables
1364 vdict = {}
1365 vdict = {}
1365 cf = sys._getframe(1)
1366 cf = sys._getframe(1)
1366 for name in vlist:
1367 for name in vlist:
1367 try:
1368 try:
1368 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1369 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1369 except:
1370 except:
1370 print('Could not get variable %s from %s' %
1371 print('Could not get variable %s from %s' %
1371 (name,cf.f_code.co_name))
1372 (name,cf.f_code.co_name))
1372 else:
1373 else:
1373 raise ValueError('variables must be a dict/str/list/tuple')
1374 raise ValueError('variables must be a dict/str/list/tuple')
1374
1375
1375 # Propagate variables to user namespace
1376 # Propagate variables to user namespace
1376 self.user_ns.update(vdict)
1377 self.user_ns.update(vdict)
1377
1378
1378 # And configure interactive visibility
1379 # And configure interactive visibility
1379 user_ns_hidden = self.user_ns_hidden
1380 user_ns_hidden = self.user_ns_hidden
1380 if interactive:
1381 if interactive:
1381 for name in vdict:
1382 for name in vdict:
1382 user_ns_hidden.pop(name, None)
1383 user_ns_hidden.pop(name, None)
1383 else:
1384 else:
1384 user_ns_hidden.update(vdict)
1385 user_ns_hidden.update(vdict)
1385
1386
1386 def drop_by_id(self, variables):
1387 def drop_by_id(self, variables):
1387 """Remove a dict of variables from the user namespace, if they are the
1388 """Remove a dict of variables from the user namespace, if they are the
1388 same as the values in the dictionary.
1389 same as the values in the dictionary.
1389
1390
1390 This is intended for use by extensions: variables that they've added can
1391 This is intended for use by extensions: variables that they've added can
1391 be taken back out if they are unloaded, without removing any that the
1392 be taken back out if they are unloaded, without removing any that the
1392 user has overwritten.
1393 user has overwritten.
1393
1394
1394 Parameters
1395 Parameters
1395 ----------
1396 ----------
1396 variables : dict
1397 variables : dict
1397 A dictionary mapping object names (as strings) to the objects.
1398 A dictionary mapping object names (as strings) to the objects.
1398 """
1399 """
1399 for name, obj in iteritems(variables):
1400 for name, obj in iteritems(variables):
1400 if name in self.user_ns and self.user_ns[name] is obj:
1401 if name in self.user_ns and self.user_ns[name] is obj:
1401 del self.user_ns[name]
1402 del self.user_ns[name]
1402 self.user_ns_hidden.pop(name, None)
1403 self.user_ns_hidden.pop(name, None)
1403
1404
1404 #-------------------------------------------------------------------------
1405 #-------------------------------------------------------------------------
1405 # Things related to object introspection
1406 # Things related to object introspection
1406 #-------------------------------------------------------------------------
1407 #-------------------------------------------------------------------------
1407
1408
1408 def _ofind(self, oname, namespaces=None):
1409 def _ofind(self, oname, namespaces=None):
1409 """Find an object in the available namespaces.
1410 """Find an object in the available namespaces.
1410
1411
1411 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
1412 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
1412
1413
1413 Has special code to detect magic functions.
1414 Has special code to detect magic functions.
1414 """
1415 """
1415 oname = oname.strip()
1416 oname = oname.strip()
1416 #print '1- oname: <%r>' % oname # dbg
1417 #print '1- oname: <%r>' % oname # dbg
1417 if not oname.startswith(ESC_MAGIC) and \
1418 if not oname.startswith(ESC_MAGIC) and \
1418 not oname.startswith(ESC_MAGIC2) and \
1419 not oname.startswith(ESC_MAGIC2) and \
1419 not py3compat.isidentifier(oname, dotted=True):
1420 not py3compat.isidentifier(oname, dotted=True):
1420 return dict(found=False)
1421 return dict(found=False)
1421
1422
1422 alias_ns = None
1423 alias_ns = None
1423 if namespaces is None:
1424 if namespaces is None:
1424 # Namespaces to search in:
1425 # Namespaces to search in:
1425 # Put them in a list. The order is important so that we
1426 # Put them in a list. The order is important so that we
1426 # find things in the same order that Python finds them.
1427 # find things in the same order that Python finds them.
1427 namespaces = [ ('Interactive', self.user_ns),
1428 namespaces = [ ('Interactive', self.user_ns),
1428 ('Interactive (global)', self.user_global_ns),
1429 ('Interactive (global)', self.user_global_ns),
1429 ('Python builtin', builtin_mod.__dict__),
1430 ('Python builtin', builtin_mod.__dict__),
1430 ]
1431 ]
1431
1432
1432 # initialize results to 'null'
1433 # initialize results to 'null'
1433 found = False; obj = None; ospace = None; ds = None;
1434 found = False; obj = None; ospace = None; ds = None;
1434 ismagic = False; isalias = False; parent = None
1435 ismagic = False; isalias = False; parent = None
1435
1436
1436 # We need to special-case 'print', which as of python2.6 registers as a
1437 # We need to special-case 'print', which as of python2.6 registers as a
1437 # function but should only be treated as one if print_function was
1438 # function but should only be treated as one if print_function was
1438 # loaded with a future import. In this case, just bail.
1439 # loaded with a future import. In this case, just bail.
1439 if (oname == 'print' and not py3compat.PY3 and not \
1440 if (oname == 'print' and not py3compat.PY3 and not \
1440 (self.compile.compiler_flags & __future__.CO_FUTURE_PRINT_FUNCTION)):
1441 (self.compile.compiler_flags & __future__.CO_FUTURE_PRINT_FUNCTION)):
1441 return {'found':found, 'obj':obj, 'namespace':ospace,
1442 return {'found':found, 'obj':obj, 'namespace':ospace,
1442 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1443 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1443
1444
1444 # Look for the given name by splitting it in parts. If the head is
1445 # Look for the given name by splitting it in parts. If the head is
1445 # found, then we look for all the remaining parts as members, and only
1446 # found, then we look for all the remaining parts as members, and only
1446 # declare success if we can find them all.
1447 # declare success if we can find them all.
1447 oname_parts = oname.split('.')
1448 oname_parts = oname.split('.')
1448 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
1449 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
1449 for nsname,ns in namespaces:
1450 for nsname,ns in namespaces:
1450 try:
1451 try:
1451 obj = ns[oname_head]
1452 obj = ns[oname_head]
1452 except KeyError:
1453 except KeyError:
1453 continue
1454 continue
1454 else:
1455 else:
1455 #print 'oname_rest:', oname_rest # dbg
1456 #print 'oname_rest:', oname_rest # dbg
1456 for idx, part in enumerate(oname_rest):
1457 for idx, part in enumerate(oname_rest):
1457 try:
1458 try:
1458 parent = obj
1459 parent = obj
1459 # The last part is looked up in a special way to avoid
1460 # The last part is looked up in a special way to avoid
1460 # descriptor invocation as it may raise or have side
1461 # descriptor invocation as it may raise or have side
1461 # effects.
1462 # effects.
1462 if idx == len(oname_rest) - 1:
1463 if idx == len(oname_rest) - 1:
1463 obj = self._getattr_property(obj, part)
1464 obj = self._getattr_property(obj, part)
1464 else:
1465 else:
1465 obj = getattr(obj, part)
1466 obj = getattr(obj, part)
1466 except:
1467 except:
1467 # Blanket except b/c some badly implemented objects
1468 # Blanket except b/c some badly implemented objects
1468 # allow __getattr__ to raise exceptions other than
1469 # allow __getattr__ to raise exceptions other than
1469 # AttributeError, which then crashes IPython.
1470 # AttributeError, which then crashes IPython.
1470 break
1471 break
1471 else:
1472 else:
1472 # If we finish the for loop (no break), we got all members
1473 # If we finish the for loop (no break), we got all members
1473 found = True
1474 found = True
1474 ospace = nsname
1475 ospace = nsname
1475 break # namespace loop
1476 break # namespace loop
1476
1477
1477 # Try to see if it's magic
1478 # Try to see if it's magic
1478 if not found:
1479 if not found:
1479 obj = None
1480 obj = None
1480 if oname.startswith(ESC_MAGIC2):
1481 if oname.startswith(ESC_MAGIC2):
1481 oname = oname.lstrip(ESC_MAGIC2)
1482 oname = oname.lstrip(ESC_MAGIC2)
1482 obj = self.find_cell_magic(oname)
1483 obj = self.find_cell_magic(oname)
1483 elif oname.startswith(ESC_MAGIC):
1484 elif oname.startswith(ESC_MAGIC):
1484 oname = oname.lstrip(ESC_MAGIC)
1485 oname = oname.lstrip(ESC_MAGIC)
1485 obj = self.find_line_magic(oname)
1486 obj = self.find_line_magic(oname)
1486 else:
1487 else:
1487 # search without prefix, so run? will find %run?
1488 # search without prefix, so run? will find %run?
1488 obj = self.find_line_magic(oname)
1489 obj = self.find_line_magic(oname)
1489 if obj is None:
1490 if obj is None:
1490 obj = self.find_cell_magic(oname)
1491 obj = self.find_cell_magic(oname)
1491 if obj is not None:
1492 if obj is not None:
1492 found = True
1493 found = True
1493 ospace = 'IPython internal'
1494 ospace = 'IPython internal'
1494 ismagic = True
1495 ismagic = True
1495
1496
1496 # Last try: special-case some literals like '', [], {}, etc:
1497 # Last try: special-case some literals like '', [], {}, etc:
1497 if not found and oname_head in ["''",'""','[]','{}','()']:
1498 if not found and oname_head in ["''",'""','[]','{}','()']:
1498 obj = eval(oname_head)
1499 obj = eval(oname_head)
1499 found = True
1500 found = True
1500 ospace = 'Interactive'
1501 ospace = 'Interactive'
1501
1502
1502 return {'found':found, 'obj':obj, 'namespace':ospace,
1503 return {'found':found, 'obj':obj, 'namespace':ospace,
1503 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1504 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1504
1505
1505 @staticmethod
1506 @staticmethod
1506 def _getattr_property(obj, attrname):
1507 def _getattr_property(obj, attrname):
1507 """Property-aware getattr to use in object finding.
1508 """Property-aware getattr to use in object finding.
1508
1509
1509 If attrname represents a property, return it unevaluated (in case it has
1510 If attrname represents a property, return it unevaluated (in case it has
1510 side effects or raises an error.
1511 side effects or raises an error.
1511
1512
1512 """
1513 """
1513 if not isinstance(obj, type):
1514 if not isinstance(obj, type):
1514 try:
1515 try:
1515 # `getattr(type(obj), attrname)` is not guaranteed to return
1516 # `getattr(type(obj), attrname)` is not guaranteed to return
1516 # `obj`, but does so for property:
1517 # `obj`, but does so for property:
1517 #
1518 #
1518 # property.__get__(self, None, cls) -> self
1519 # property.__get__(self, None, cls) -> self
1519 #
1520 #
1520 # The universal alternative is to traverse the mro manually
1521 # The universal alternative is to traverse the mro manually
1521 # searching for attrname in class dicts.
1522 # searching for attrname in class dicts.
1522 attr = getattr(type(obj), attrname)
1523 attr = getattr(type(obj), attrname)
1523 except AttributeError:
1524 except AttributeError:
1524 pass
1525 pass
1525 else:
1526 else:
1526 # This relies on the fact that data descriptors (with both
1527 # This relies on the fact that data descriptors (with both
1527 # __get__ & __set__ magic methods) take precedence over
1528 # __get__ & __set__ magic methods) take precedence over
1528 # instance-level attributes:
1529 # instance-level attributes:
1529 #
1530 #
1530 # class A(object):
1531 # class A(object):
1531 # @property
1532 # @property
1532 # def foobar(self): return 123
1533 # def foobar(self): return 123
1533 # a = A()
1534 # a = A()
1534 # a.__dict__['foobar'] = 345
1535 # a.__dict__['foobar'] = 345
1535 # a.foobar # == 123
1536 # a.foobar # == 123
1536 #
1537 #
1537 # So, a property may be returned right away.
1538 # So, a property may be returned right away.
1538 if isinstance(attr, property):
1539 if isinstance(attr, property):
1539 return attr
1540 return attr
1540
1541
1541 # Nothing helped, fall back.
1542 # Nothing helped, fall back.
1542 return getattr(obj, attrname)
1543 return getattr(obj, attrname)
1543
1544
1544 def _object_find(self, oname, namespaces=None):
1545 def _object_find(self, oname, namespaces=None):
1545 """Find an object and return a struct with info about it."""
1546 """Find an object and return a struct with info about it."""
1546 return Struct(self._ofind(oname, namespaces))
1547 return Struct(self._ofind(oname, namespaces))
1547
1548
1548 def _inspect(self, meth, oname, namespaces=None, **kw):
1549 def _inspect(self, meth, oname, namespaces=None, **kw):
1549 """Generic interface to the inspector system.
1550 """Generic interface to the inspector system.
1550
1551
1551 This function is meant to be called by pdef, pdoc & friends."""
1552 This function is meant to be called by pdef, pdoc & friends."""
1552 info = self._object_find(oname, namespaces)
1553 info = self._object_find(oname, namespaces)
1553 if info.found:
1554 if info.found:
1554 pmethod = getattr(self.inspector, meth)
1555 pmethod = getattr(self.inspector, meth)
1555 formatter = format_screen if info.ismagic else None
1556 formatter = format_screen if info.ismagic else None
1556 if meth == 'pdoc':
1557 if meth == 'pdoc':
1557 pmethod(info.obj, oname, formatter)
1558 pmethod(info.obj, oname, formatter)
1558 elif meth == 'pinfo':
1559 elif meth == 'pinfo':
1559 pmethod(info.obj, oname, formatter, info, **kw)
1560 pmethod(info.obj, oname, formatter, info, **kw)
1560 else:
1561 else:
1561 pmethod(info.obj, oname)
1562 pmethod(info.obj, oname)
1562 else:
1563 else:
1563 print('Object `%s` not found.' % oname)
1564 print('Object `%s` not found.' % oname)
1564 return 'not found' # so callers can take other action
1565 return 'not found' # so callers can take other action
1565
1566
1566 def object_inspect(self, oname, detail_level=0):
1567 def object_inspect(self, oname, detail_level=0):
1567 """Get object info about oname"""
1568 """Get object info about oname"""
1568 with self.builtin_trap:
1569 with self.builtin_trap:
1569 info = self._object_find(oname)
1570 info = self._object_find(oname)
1570 if info.found:
1571 if info.found:
1571 return self.inspector.info(info.obj, oname, info=info,
1572 return self.inspector.info(info.obj, oname, info=info,
1572 detail_level=detail_level
1573 detail_level=detail_level
1573 )
1574 )
1574 else:
1575 else:
1575 return oinspect.object_info(name=oname, found=False)
1576 return oinspect.object_info(name=oname, found=False)
1576
1577
1577 def object_inspect_text(self, oname, detail_level=0):
1578 def object_inspect_text(self, oname, detail_level=0):
1578 """Get object info as formatted text"""
1579 """Get object info as formatted text"""
1579 with self.builtin_trap:
1580 with self.builtin_trap:
1580 info = self._object_find(oname)
1581 info = self._object_find(oname)
1581 if info.found:
1582 if info.found:
1582 return self.inspector._format_info(info.obj, oname, info=info,
1583 return self.inspector._format_info(info.obj, oname, info=info,
1583 detail_level=detail_level
1584 detail_level=detail_level
1584 )
1585 )
1585 else:
1586 else:
1586 raise KeyError(oname)
1587 raise KeyError(oname)
1587
1588
1588 #-------------------------------------------------------------------------
1589 #-------------------------------------------------------------------------
1589 # Things related to history management
1590 # Things related to history management
1590 #-------------------------------------------------------------------------
1591 #-------------------------------------------------------------------------
1591
1592
1592 def init_history(self):
1593 def init_history(self):
1593 """Sets up the command history, and starts regular autosaves."""
1594 """Sets up the command history, and starts regular autosaves."""
1594 self.history_manager = HistoryManager(shell=self, parent=self)
1595 self.history_manager = HistoryManager(shell=self, parent=self)
1595 self.configurables.append(self.history_manager)
1596 self.configurables.append(self.history_manager)
1596
1597
1597 #-------------------------------------------------------------------------
1598 #-------------------------------------------------------------------------
1598 # Things related to exception handling and tracebacks (not debugging)
1599 # Things related to exception handling and tracebacks (not debugging)
1599 #-------------------------------------------------------------------------
1600 #-------------------------------------------------------------------------
1600
1601
1601 def init_traceback_handlers(self, custom_exceptions):
1602 def init_traceback_handlers(self, custom_exceptions):
1602 # Syntax error handler.
1603 # Syntax error handler.
1603 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor')
1604 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor')
1604
1605
1605 # The interactive one is initialized with an offset, meaning we always
1606 # The interactive one is initialized with an offset, meaning we always
1606 # want to remove the topmost item in the traceback, which is our own
1607 # want to remove the topmost item in the traceback, which is our own
1607 # internal code. Valid modes: ['Plain','Context','Verbose']
1608 # internal code. Valid modes: ['Plain','Context','Verbose']
1608 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1609 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1609 color_scheme='NoColor',
1610 color_scheme='NoColor',
1610 tb_offset = 1,
1611 tb_offset = 1,
1611 check_cache=check_linecache_ipython)
1612 check_cache=check_linecache_ipython)
1612
1613
1613 # The instance will store a pointer to the system-wide exception hook,
1614 # The instance will store a pointer to the system-wide exception hook,
1614 # so that runtime code (such as magics) can access it. This is because
1615 # so that runtime code (such as magics) can access it. This is because
1615 # during the read-eval loop, it may get temporarily overwritten.
1616 # during the read-eval loop, it may get temporarily overwritten.
1616 self.sys_excepthook = sys.excepthook
1617 self.sys_excepthook = sys.excepthook
1617
1618
1618 # and add any custom exception handlers the user may have specified
1619 # and add any custom exception handlers the user may have specified
1619 self.set_custom_exc(*custom_exceptions)
1620 self.set_custom_exc(*custom_exceptions)
1620
1621
1621 # Set the exception mode
1622 # Set the exception mode
1622 self.InteractiveTB.set_mode(mode=self.xmode)
1623 self.InteractiveTB.set_mode(mode=self.xmode)
1623
1624
1624 def set_custom_exc(self, exc_tuple, handler):
1625 def set_custom_exc(self, exc_tuple, handler):
1625 """set_custom_exc(exc_tuple,handler)
1626 """set_custom_exc(exc_tuple,handler)
1626
1627
1627 Set a custom exception handler, which will be called if any of the
1628 Set a custom exception handler, which will be called if any of the
1628 exceptions in exc_tuple occur in the mainloop (specifically, in the
1629 exceptions in exc_tuple occur in the mainloop (specifically, in the
1629 run_code() method).
1630 run_code() method).
1630
1631
1631 Parameters
1632 Parameters
1632 ----------
1633 ----------
1633
1634
1634 exc_tuple : tuple of exception classes
1635 exc_tuple : tuple of exception classes
1635 A *tuple* of exception classes, for which to call the defined
1636 A *tuple* of exception classes, for which to call the defined
1636 handler. It is very important that you use a tuple, and NOT A
1637 handler. It is very important that you use a tuple, and NOT A
1637 LIST here, because of the way Python's except statement works. If
1638 LIST here, because of the way Python's except statement works. If
1638 you only want to trap a single exception, use a singleton tuple::
1639 you only want to trap a single exception, use a singleton tuple::
1639
1640
1640 exc_tuple == (MyCustomException,)
1641 exc_tuple == (MyCustomException,)
1641
1642
1642 handler : callable
1643 handler : callable
1643 handler must have the following signature::
1644 handler must have the following signature::
1644
1645
1645 def my_handler(self, etype, value, tb, tb_offset=None):
1646 def my_handler(self, etype, value, tb, tb_offset=None):
1646 ...
1647 ...
1647 return structured_traceback
1648 return structured_traceback
1648
1649
1649 Your handler must return a structured traceback (a list of strings),
1650 Your handler must return a structured traceback (a list of strings),
1650 or None.
1651 or None.
1651
1652
1652 This will be made into an instance method (via types.MethodType)
1653 This will be made into an instance method (via types.MethodType)
1653 of IPython itself, and it will be called if any of the exceptions
1654 of IPython itself, and it will be called if any of the exceptions
1654 listed in the exc_tuple are caught. If the handler is None, an
1655 listed in the exc_tuple are caught. If the handler is None, an
1655 internal basic one is used, which just prints basic info.
1656 internal basic one is used, which just prints basic info.
1656
1657
1657 To protect IPython from crashes, if your handler ever raises an
1658 To protect IPython from crashes, if your handler ever raises an
1658 exception or returns an invalid result, it will be immediately
1659 exception or returns an invalid result, it will be immediately
1659 disabled.
1660 disabled.
1660
1661
1661 WARNING: by putting in your own exception handler into IPython's main
1662 WARNING: by putting in your own exception handler into IPython's main
1662 execution loop, you run a very good chance of nasty crashes. This
1663 execution loop, you run a very good chance of nasty crashes. This
1663 facility should only be used if you really know what you are doing."""
1664 facility should only be used if you really know what you are doing."""
1664
1665
1665 assert type(exc_tuple)==type(()) , \
1666 assert type(exc_tuple)==type(()) , \
1666 "The custom exceptions must be given AS A TUPLE."
1667 "The custom exceptions must be given AS A TUPLE."
1667
1668
1668 def dummy_handler(self,etype,value,tb,tb_offset=None):
1669 def dummy_handler(self,etype,value,tb,tb_offset=None):
1669 print('*** Simple custom exception handler ***')
1670 print('*** Simple custom exception handler ***')
1670 print('Exception type :',etype)
1671 print('Exception type :',etype)
1671 print('Exception value:',value)
1672 print('Exception value:',value)
1672 print('Traceback :',tb)
1673 print('Traceback :',tb)
1673 #print 'Source code :','\n'.join(self.buffer)
1674 #print 'Source code :','\n'.join(self.buffer)
1674
1675
1675 def validate_stb(stb):
1676 def validate_stb(stb):
1676 """validate structured traceback return type
1677 """validate structured traceback return type
1677
1678
1678 return type of CustomTB *should* be a list of strings, but allow
1679 return type of CustomTB *should* be a list of strings, but allow
1679 single strings or None, which are harmless.
1680 single strings or None, which are harmless.
1680
1681
1681 This function will *always* return a list of strings,
1682 This function will *always* return a list of strings,
1682 and will raise a TypeError if stb is inappropriate.
1683 and will raise a TypeError if stb is inappropriate.
1683 """
1684 """
1684 msg = "CustomTB must return list of strings, not %r" % stb
1685 msg = "CustomTB must return list of strings, not %r" % stb
1685 if stb is None:
1686 if stb is None:
1686 return []
1687 return []
1687 elif isinstance(stb, string_types):
1688 elif isinstance(stb, string_types):
1688 return [stb]
1689 return [stb]
1689 elif not isinstance(stb, list):
1690 elif not isinstance(stb, list):
1690 raise TypeError(msg)
1691 raise TypeError(msg)
1691 # it's a list
1692 # it's a list
1692 for line in stb:
1693 for line in stb:
1693 # check every element
1694 # check every element
1694 if not isinstance(line, string_types):
1695 if not isinstance(line, string_types):
1695 raise TypeError(msg)
1696 raise TypeError(msg)
1696 return stb
1697 return stb
1697
1698
1698 if handler is None:
1699 if handler is None:
1699 wrapped = dummy_handler
1700 wrapped = dummy_handler
1700 else:
1701 else:
1701 def wrapped(self,etype,value,tb,tb_offset=None):
1702 def wrapped(self,etype,value,tb,tb_offset=None):
1702 """wrap CustomTB handler, to protect IPython from user code
1703 """wrap CustomTB handler, to protect IPython from user code
1703
1704
1704 This makes it harder (but not impossible) for custom exception
1705 This makes it harder (but not impossible) for custom exception
1705 handlers to crash IPython.
1706 handlers to crash IPython.
1706 """
1707 """
1707 try:
1708 try:
1708 stb = handler(self,etype,value,tb,tb_offset=tb_offset)
1709 stb = handler(self,etype,value,tb,tb_offset=tb_offset)
1709 return validate_stb(stb)
1710 return validate_stb(stb)
1710 except:
1711 except:
1711 # clear custom handler immediately
1712 # clear custom handler immediately
1712 self.set_custom_exc((), None)
1713 self.set_custom_exc((), None)
1713 print("Custom TB Handler failed, unregistering", file=io.stderr)
1714 print("Custom TB Handler failed, unregistering", file=io.stderr)
1714 # show the exception in handler first
1715 # show the exception in handler first
1715 stb = self.InteractiveTB.structured_traceback(*sys.exc_info())
1716 stb = self.InteractiveTB.structured_traceback(*sys.exc_info())
1716 print(self.InteractiveTB.stb2text(stb), file=io.stdout)
1717 print(self.InteractiveTB.stb2text(stb), file=io.stdout)
1717 print("The original exception:", file=io.stdout)
1718 print("The original exception:", file=io.stdout)
1718 stb = self.InteractiveTB.structured_traceback(
1719 stb = self.InteractiveTB.structured_traceback(
1719 (etype,value,tb), tb_offset=tb_offset
1720 (etype,value,tb), tb_offset=tb_offset
1720 )
1721 )
1721 return stb
1722 return stb
1722
1723
1723 self.CustomTB = types.MethodType(wrapped,self)
1724 self.CustomTB = types.MethodType(wrapped,self)
1724 self.custom_exceptions = exc_tuple
1725 self.custom_exceptions = exc_tuple
1725
1726
1726 def excepthook(self, etype, value, tb):
1727 def excepthook(self, etype, value, tb):
1727 """One more defense for GUI apps that call sys.excepthook.
1728 """One more defense for GUI apps that call sys.excepthook.
1728
1729
1729 GUI frameworks like wxPython trap exceptions and call
1730 GUI frameworks like wxPython trap exceptions and call
1730 sys.excepthook themselves. I guess this is a feature that
1731 sys.excepthook themselves. I guess this is a feature that
1731 enables them to keep running after exceptions that would
1732 enables them to keep running after exceptions that would
1732 otherwise kill their mainloop. This is a bother for IPython
1733 otherwise kill their mainloop. This is a bother for IPython
1733 which excepts to catch all of the program exceptions with a try:
1734 which excepts to catch all of the program exceptions with a try:
1734 except: statement.
1735 except: statement.
1735
1736
1736 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1737 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1737 any app directly invokes sys.excepthook, it will look to the user like
1738 any app directly invokes sys.excepthook, it will look to the user like
1738 IPython crashed. In order to work around this, we can disable the
1739 IPython crashed. In order to work around this, we can disable the
1739 CrashHandler and replace it with this excepthook instead, which prints a
1740 CrashHandler and replace it with this excepthook instead, which prints a
1740 regular traceback using our InteractiveTB. In this fashion, apps which
1741 regular traceback using our InteractiveTB. In this fashion, apps which
1741 call sys.excepthook will generate a regular-looking exception from
1742 call sys.excepthook will generate a regular-looking exception from
1742 IPython, and the CrashHandler will only be triggered by real IPython
1743 IPython, and the CrashHandler will only be triggered by real IPython
1743 crashes.
1744 crashes.
1744
1745
1745 This hook should be used sparingly, only in places which are not likely
1746 This hook should be used sparingly, only in places which are not likely
1746 to be true IPython errors.
1747 to be true IPython errors.
1747 """
1748 """
1748 self.showtraceback((etype, value, tb), tb_offset=0)
1749 self.showtraceback((etype, value, tb), tb_offset=0)
1749
1750
1750 def _get_exc_info(self, exc_tuple=None):
1751 def _get_exc_info(self, exc_tuple=None):
1751 """get exc_info from a given tuple, sys.exc_info() or sys.last_type etc.
1752 """get exc_info from a given tuple, sys.exc_info() or sys.last_type etc.
1752
1753
1753 Ensures sys.last_type,value,traceback hold the exc_info we found,
1754 Ensures sys.last_type,value,traceback hold the exc_info we found,
1754 from whichever source.
1755 from whichever source.
1755
1756
1756 raises ValueError if none of these contain any information
1757 raises ValueError if none of these contain any information
1757 """
1758 """
1758 if exc_tuple is None:
1759 if exc_tuple is None:
1759 etype, value, tb = sys.exc_info()
1760 etype, value, tb = sys.exc_info()
1760 else:
1761 else:
1761 etype, value, tb = exc_tuple
1762 etype, value, tb = exc_tuple
1762
1763
1763 if etype is None:
1764 if etype is None:
1764 if hasattr(sys, 'last_type'):
1765 if hasattr(sys, 'last_type'):
1765 etype, value, tb = sys.last_type, sys.last_value, \
1766 etype, value, tb = sys.last_type, sys.last_value, \
1766 sys.last_traceback
1767 sys.last_traceback
1767
1768
1768 if etype is None:
1769 if etype is None:
1769 raise ValueError("No exception to find")
1770 raise ValueError("No exception to find")
1770
1771
1771 # Now store the exception info in sys.last_type etc.
1772 # Now store the exception info in sys.last_type etc.
1772 # WARNING: these variables are somewhat deprecated and not
1773 # WARNING: these variables are somewhat deprecated and not
1773 # necessarily safe to use in a threaded environment, but tools
1774 # necessarily safe to use in a threaded environment, but tools
1774 # like pdb depend on their existence, so let's set them. If we
1775 # like pdb depend on their existence, so let's set them. If we
1775 # find problems in the field, we'll need to revisit their use.
1776 # find problems in the field, we'll need to revisit their use.
1776 sys.last_type = etype
1777 sys.last_type = etype
1777 sys.last_value = value
1778 sys.last_value = value
1778 sys.last_traceback = tb
1779 sys.last_traceback = tb
1779
1780
1780 return etype, value, tb
1781 return etype, value, tb
1781
1782
1782 def show_usage_error(self, exc):
1783 def show_usage_error(self, exc):
1783 """Show a short message for UsageErrors
1784 """Show a short message for UsageErrors
1784
1785
1785 These are special exceptions that shouldn't show a traceback.
1786 These are special exceptions that shouldn't show a traceback.
1786 """
1787 """
1787 self.write_err("UsageError: %s" % exc)
1788 self.write_err("UsageError: %s" % exc)
1788
1789
1790 def get_exception_only(self, exc_tuple=None):
1791 """
1792 Return as a string (ending with a newline) the exception that
1793 just occurred, without any traceback.
1794 """
1795 etype, value, tb = self._get_exc_info(exc_tuple)
1796 msg = traceback.format_exception_only(etype, value)
1797 return ''.join(msg)
1798
1789 def showtraceback(self, exc_tuple=None, filename=None, tb_offset=None,
1799 def showtraceback(self, exc_tuple=None, filename=None, tb_offset=None,
1790 exception_only=False):
1800 exception_only=False):
1791 """Display the exception that just occurred.
1801 """Display the exception that just occurred.
1792
1802
1793 If nothing is known about the exception, this is the method which
1803 If nothing is known about the exception, this is the method which
1794 should be used throughout the code for presenting user tracebacks,
1804 should be used throughout the code for presenting user tracebacks,
1795 rather than directly invoking the InteractiveTB object.
1805 rather than directly invoking the InteractiveTB object.
1796
1806
1797 A specific showsyntaxerror() also exists, but this method can take
1807 A specific showsyntaxerror() also exists, but this method can take
1798 care of calling it if needed, so unless you are explicitly catching a
1808 care of calling it if needed, so unless you are explicitly catching a
1799 SyntaxError exception, don't try to analyze the stack manually and
1809 SyntaxError exception, don't try to analyze the stack manually and
1800 simply call this method."""
1810 simply call this method."""
1801
1811
1802 try:
1812 try:
1803 try:
1813 try:
1804 etype, value, tb = self._get_exc_info(exc_tuple)
1814 etype, value, tb = self._get_exc_info(exc_tuple)
1805 except ValueError:
1815 except ValueError:
1806 self.write_err('No traceback available to show.\n')
1816 self.write_err('No traceback available to show.\n')
1807 return
1817 return
1808
1818
1809 if issubclass(etype, SyntaxError):
1819 if issubclass(etype, SyntaxError):
1810 # Though this won't be called by syntax errors in the input
1820 # Though this won't be called by syntax errors in the input
1811 # line, there may be SyntaxError cases with imported code.
1821 # line, there may be SyntaxError cases with imported code.
1812 self.showsyntaxerror(filename)
1822 self.showsyntaxerror(filename)
1813 elif etype is UsageError:
1823 elif etype is UsageError:
1814 self.show_usage_error(value)
1824 self.show_usage_error(value)
1815 else:
1825 else:
1816 if exception_only:
1826 if exception_only:
1817 stb = ['An exception has occurred, use %tb to see '
1827 stb = ['An exception has occurred, use %tb to see '
1818 'the full traceback.\n']
1828 'the full traceback.\n']
1819 stb.extend(self.InteractiveTB.get_exception_only(etype,
1829 stb.extend(self.InteractiveTB.get_exception_only(etype,
1820 value))
1830 value))
1821 else:
1831 else:
1822 try:
1832 try:
1823 # Exception classes can customise their traceback - we
1833 # Exception classes can customise their traceback - we
1824 # use this in IPython.parallel for exceptions occurring
1834 # use this in IPython.parallel for exceptions occurring
1825 # in the engines. This should return a list of strings.
1835 # in the engines. This should return a list of strings.
1826 stb = value._render_traceback_()
1836 stb = value._render_traceback_()
1827 except Exception:
1837 except Exception:
1828 stb = self.InteractiveTB.structured_traceback(etype,
1838 stb = self.InteractiveTB.structured_traceback(etype,
1829 value, tb, tb_offset=tb_offset)
1839 value, tb, tb_offset=tb_offset)
1830
1840
1831 self._showtraceback(etype, value, stb)
1841 self._showtraceback(etype, value, stb)
1832 if self.call_pdb:
1842 if self.call_pdb:
1833 # drop into debugger
1843 # drop into debugger
1834 self.debugger(force=True)
1844 self.debugger(force=True)
1835 return
1845 return
1836
1846
1837 # Actually show the traceback
1847 # Actually show the traceback
1838 self._showtraceback(etype, value, stb)
1848 self._showtraceback(etype, value, stb)
1839
1849
1840 except KeyboardInterrupt:
1850 except KeyboardInterrupt:
1841 self.write_err("\nKeyboardInterrupt\n")
1851 self.write_err('\n' + self.get_exception_only())
1842
1852
1843 def _showtraceback(self, etype, evalue, stb):
1853 def _showtraceback(self, etype, evalue, stb):
1844 """Actually show a traceback.
1854 """Actually show a traceback.
1845
1855
1846 Subclasses may override this method to put the traceback on a different
1856 Subclasses may override this method to put the traceback on a different
1847 place, like a side channel.
1857 place, like a side channel.
1848 """
1858 """
1849 print(self.InteractiveTB.stb2text(stb), file=io.stdout)
1859 print(self.InteractiveTB.stb2text(stb), file=io.stdout)
1850
1860
1851 def showsyntaxerror(self, filename=None):
1861 def showsyntaxerror(self, filename=None):
1852 """Display the syntax error that just occurred.
1862 """Display the syntax error that just occurred.
1853
1863
1854 This doesn't display a stack trace because there isn't one.
1864 This doesn't display a stack trace because there isn't one.
1855
1865
1856 If a filename is given, it is stuffed in the exception instead
1866 If a filename is given, it is stuffed in the exception instead
1857 of what was there before (because Python's parser always uses
1867 of what was there before (because Python's parser always uses
1858 "<string>" when reading from a string).
1868 "<string>" when reading from a string).
1859 """
1869 """
1860 etype, value, last_traceback = self._get_exc_info()
1870 etype, value, last_traceback = self._get_exc_info()
1861
1871
1862 if filename and issubclass(etype, SyntaxError):
1872 if filename and issubclass(etype, SyntaxError):
1863 try:
1873 try:
1864 value.filename = filename
1874 value.filename = filename
1865 except:
1875 except:
1866 # Not the format we expect; leave it alone
1876 # Not the format we expect; leave it alone
1867 pass
1877 pass
1868
1878
1869 stb = self.SyntaxTB.structured_traceback(etype, value, [])
1879 stb = self.SyntaxTB.structured_traceback(etype, value, [])
1870 self._showtraceback(etype, value, stb)
1880 self._showtraceback(etype, value, stb)
1871
1881
1872 # This is overridden in TerminalInteractiveShell to show a message about
1882 # This is overridden in TerminalInteractiveShell to show a message about
1873 # the %paste magic.
1883 # the %paste magic.
1874 def showindentationerror(self):
1884 def showindentationerror(self):
1875 """Called by run_cell when there's an IndentationError in code entered
1885 """Called by run_cell when there's an IndentationError in code entered
1876 at the prompt.
1886 at the prompt.
1877
1887
1878 This is overridden in TerminalInteractiveShell to show a message about
1888 This is overridden in TerminalInteractiveShell to show a message about
1879 the %paste magic."""
1889 the %paste magic."""
1880 self.showsyntaxerror()
1890 self.showsyntaxerror()
1881
1891
1882 #-------------------------------------------------------------------------
1892 #-------------------------------------------------------------------------
1883 # Things related to readline
1893 # Things related to readline
1884 #-------------------------------------------------------------------------
1894 #-------------------------------------------------------------------------
1885
1895
1886 def init_readline(self):
1896 def init_readline(self):
1887 """Command history completion/saving/reloading."""
1897 """Command history completion/saving/reloading."""
1888
1898
1889 if self.readline_use:
1899 if self.readline_use:
1890 import IPython.utils.rlineimpl as readline
1900 import IPython.utils.rlineimpl as readline
1891
1901
1892 self.rl_next_input = None
1902 self.rl_next_input = None
1893 self.rl_do_indent = False
1903 self.rl_do_indent = False
1894
1904
1895 if not self.readline_use or not readline.have_readline:
1905 if not self.readline_use or not readline.have_readline:
1896 self.has_readline = False
1906 self.has_readline = False
1897 self.readline = None
1907 self.readline = None
1898 # Set a number of methods that depend on readline to be no-op
1908 # Set a number of methods that depend on readline to be no-op
1899 self.readline_no_record = no_op_context
1909 self.readline_no_record = no_op_context
1900 self.set_readline_completer = no_op
1910 self.set_readline_completer = no_op
1901 self.set_custom_completer = no_op
1911 self.set_custom_completer = no_op
1902 if self.readline_use:
1912 if self.readline_use:
1903 warn('Readline services not available or not loaded.')
1913 warn('Readline services not available or not loaded.')
1904 else:
1914 else:
1905 self.has_readline = True
1915 self.has_readline = True
1906 self.readline = readline
1916 self.readline = readline
1907 sys.modules['readline'] = readline
1917 sys.modules['readline'] = readline
1908
1918
1909 # Platform-specific configuration
1919 # Platform-specific configuration
1910 if os.name == 'nt':
1920 if os.name == 'nt':
1911 # FIXME - check with Frederick to see if we can harmonize
1921 # FIXME - check with Frederick to see if we can harmonize
1912 # naming conventions with pyreadline to avoid this
1922 # naming conventions with pyreadline to avoid this
1913 # platform-dependent check
1923 # platform-dependent check
1914 self.readline_startup_hook = readline.set_pre_input_hook
1924 self.readline_startup_hook = readline.set_pre_input_hook
1915 else:
1925 else:
1916 self.readline_startup_hook = readline.set_startup_hook
1926 self.readline_startup_hook = readline.set_startup_hook
1917
1927
1918 # Readline config order:
1928 # Readline config order:
1919 # - IPython config (default value)
1929 # - IPython config (default value)
1920 # - custom inputrc
1930 # - custom inputrc
1921 # - IPython config (user customized)
1931 # - IPython config (user customized)
1922
1932
1923 # load IPython config before inputrc if default
1933 # load IPython config before inputrc if default
1924 # skip if libedit because parse_and_bind syntax is different
1934 # skip if libedit because parse_and_bind syntax is different
1925 if not self._custom_readline_config and not readline.uses_libedit:
1935 if not self._custom_readline_config and not readline.uses_libedit:
1926 for rlcommand in self.readline_parse_and_bind:
1936 for rlcommand in self.readline_parse_and_bind:
1927 readline.parse_and_bind(rlcommand)
1937 readline.parse_and_bind(rlcommand)
1928
1938
1929 # Load user's initrc file (readline config)
1939 # Load user's initrc file (readline config)
1930 # Or if libedit is used, load editrc.
1940 # Or if libedit is used, load editrc.
1931 inputrc_name = os.environ.get('INPUTRC')
1941 inputrc_name = os.environ.get('INPUTRC')
1932 if inputrc_name is None:
1942 if inputrc_name is None:
1933 inputrc_name = '.inputrc'
1943 inputrc_name = '.inputrc'
1934 if readline.uses_libedit:
1944 if readline.uses_libedit:
1935 inputrc_name = '.editrc'
1945 inputrc_name = '.editrc'
1936 inputrc_name = os.path.join(self.home_dir, inputrc_name)
1946 inputrc_name = os.path.join(self.home_dir, inputrc_name)
1937 if os.path.isfile(inputrc_name):
1947 if os.path.isfile(inputrc_name):
1938 try:
1948 try:
1939 readline.read_init_file(inputrc_name)
1949 readline.read_init_file(inputrc_name)
1940 except:
1950 except:
1941 warn('Problems reading readline initialization file <%s>'
1951 warn('Problems reading readline initialization file <%s>'
1942 % inputrc_name)
1952 % inputrc_name)
1943
1953
1944 # load IPython config after inputrc if user has customized
1954 # load IPython config after inputrc if user has customized
1945 if self._custom_readline_config:
1955 if self._custom_readline_config:
1946 for rlcommand in self.readline_parse_and_bind:
1956 for rlcommand in self.readline_parse_and_bind:
1947 readline.parse_and_bind(rlcommand)
1957 readline.parse_and_bind(rlcommand)
1948
1958
1949 # Remove some chars from the delimiters list. If we encounter
1959 # Remove some chars from the delimiters list. If we encounter
1950 # unicode chars, discard them.
1960 # unicode chars, discard them.
1951 delims = readline.get_completer_delims()
1961 delims = readline.get_completer_delims()
1952 if not py3compat.PY3:
1962 if not py3compat.PY3:
1953 delims = delims.encode("ascii", "ignore")
1963 delims = delims.encode("ascii", "ignore")
1954 for d in self.readline_remove_delims:
1964 for d in self.readline_remove_delims:
1955 delims = delims.replace(d, "")
1965 delims = delims.replace(d, "")
1956 delims = delims.replace(ESC_MAGIC, '')
1966 delims = delims.replace(ESC_MAGIC, '')
1957 readline.set_completer_delims(delims)
1967 readline.set_completer_delims(delims)
1958 # Store these so we can restore them if something like rpy2 modifies
1968 # Store these so we can restore them if something like rpy2 modifies
1959 # them.
1969 # them.
1960 self.readline_delims = delims
1970 self.readline_delims = delims
1961 # otherwise we end up with a monster history after a while:
1971 # otherwise we end up with a monster history after a while:
1962 readline.set_history_length(self.history_length)
1972 readline.set_history_length(self.history_length)
1963
1973
1964 self.refill_readline_hist()
1974 self.refill_readline_hist()
1965 self.readline_no_record = ReadlineNoRecord(self)
1975 self.readline_no_record = ReadlineNoRecord(self)
1966
1976
1967 # Configure auto-indent for all platforms
1977 # Configure auto-indent for all platforms
1968 self.set_autoindent(self.autoindent)
1978 self.set_autoindent(self.autoindent)
1969
1979
1970 def refill_readline_hist(self):
1980 def refill_readline_hist(self):
1971 # Load the last 1000 lines from history
1981 # Load the last 1000 lines from history
1972 self.readline.clear_history()
1982 self.readline.clear_history()
1973 stdin_encoding = sys.stdin.encoding or "utf-8"
1983 stdin_encoding = sys.stdin.encoding or "utf-8"
1974 last_cell = u""
1984 last_cell = u""
1975 for _, _, cell in self.history_manager.get_tail(1000,
1985 for _, _, cell in self.history_manager.get_tail(1000,
1976 include_latest=True):
1986 include_latest=True):
1977 # Ignore blank lines and consecutive duplicates
1987 # Ignore blank lines and consecutive duplicates
1978 cell = cell.rstrip()
1988 cell = cell.rstrip()
1979 if cell and (cell != last_cell):
1989 if cell and (cell != last_cell):
1980 try:
1990 try:
1981 if self.multiline_history:
1991 if self.multiline_history:
1982 self.readline.add_history(py3compat.unicode_to_str(cell,
1992 self.readline.add_history(py3compat.unicode_to_str(cell,
1983 stdin_encoding))
1993 stdin_encoding))
1984 else:
1994 else:
1985 for line in cell.splitlines():
1995 for line in cell.splitlines():
1986 self.readline.add_history(py3compat.unicode_to_str(line,
1996 self.readline.add_history(py3compat.unicode_to_str(line,
1987 stdin_encoding))
1997 stdin_encoding))
1988 last_cell = cell
1998 last_cell = cell
1989
1999
1990 except TypeError:
2000 except TypeError:
1991 # The history DB can get corrupted so it returns strings
2001 # The history DB can get corrupted so it returns strings
1992 # containing null bytes, which readline objects to.
2002 # containing null bytes, which readline objects to.
1993 continue
2003 continue
1994
2004
1995 @skip_doctest
2005 @skip_doctest
1996 def set_next_input(self, s):
2006 def set_next_input(self, s):
1997 """ Sets the 'default' input string for the next command line.
2007 """ Sets the 'default' input string for the next command line.
1998
2008
1999 Requires readline.
2009 Requires readline.
2000
2010
2001 Example::
2011 Example::
2002
2012
2003 In [1]: _ip.set_next_input("Hello Word")
2013 In [1]: _ip.set_next_input("Hello Word")
2004 In [2]: Hello Word_ # cursor is here
2014 In [2]: Hello Word_ # cursor is here
2005 """
2015 """
2006 self.rl_next_input = py3compat.cast_bytes_py2(s)
2016 self.rl_next_input = py3compat.cast_bytes_py2(s)
2007
2017
2008 # Maybe move this to the terminal subclass?
2018 # Maybe move this to the terminal subclass?
2009 def pre_readline(self):
2019 def pre_readline(self):
2010 """readline hook to be used at the start of each line.
2020 """readline hook to be used at the start of each line.
2011
2021
2012 Currently it handles auto-indent only."""
2022 Currently it handles auto-indent only."""
2013
2023
2014 if self.rl_do_indent:
2024 if self.rl_do_indent:
2015 self.readline.insert_text(self._indent_current_str())
2025 self.readline.insert_text(self._indent_current_str())
2016 if self.rl_next_input is not None:
2026 if self.rl_next_input is not None:
2017 self.readline.insert_text(self.rl_next_input)
2027 self.readline.insert_text(self.rl_next_input)
2018 self.rl_next_input = None
2028 self.rl_next_input = None
2019
2029
2020 def _indent_current_str(self):
2030 def _indent_current_str(self):
2021 """return the current level of indentation as a string"""
2031 """return the current level of indentation as a string"""
2022 return self.input_splitter.indent_spaces * ' '
2032 return self.input_splitter.indent_spaces * ' '
2023
2033
2024 #-------------------------------------------------------------------------
2034 #-------------------------------------------------------------------------
2025 # Things related to text completion
2035 # Things related to text completion
2026 #-------------------------------------------------------------------------
2036 #-------------------------------------------------------------------------
2027
2037
2028 def init_completer(self):
2038 def init_completer(self):
2029 """Initialize the completion machinery.
2039 """Initialize the completion machinery.
2030
2040
2031 This creates completion machinery that can be used by client code,
2041 This creates completion machinery that can be used by client code,
2032 either interactively in-process (typically triggered by the readline
2042 either interactively in-process (typically triggered by the readline
2033 library), programatically (such as in test suites) or out-of-prcess
2043 library), programatically (such as in test suites) or out-of-prcess
2034 (typically over the network by remote frontends).
2044 (typically over the network by remote frontends).
2035 """
2045 """
2036 from IPython.core.completer import IPCompleter
2046 from IPython.core.completer import IPCompleter
2037 from IPython.core.completerlib import (module_completer,
2047 from IPython.core.completerlib import (module_completer,
2038 magic_run_completer, cd_completer, reset_completer)
2048 magic_run_completer, cd_completer, reset_completer)
2039
2049
2040 self.Completer = IPCompleter(shell=self,
2050 self.Completer = IPCompleter(shell=self,
2041 namespace=self.user_ns,
2051 namespace=self.user_ns,
2042 global_namespace=self.user_global_ns,
2052 global_namespace=self.user_global_ns,
2043 use_readline=self.has_readline,
2053 use_readline=self.has_readline,
2044 parent=self,
2054 parent=self,
2045 )
2055 )
2046 self.configurables.append(self.Completer)
2056 self.configurables.append(self.Completer)
2047
2057
2048 # Add custom completers to the basic ones built into IPCompleter
2058 # Add custom completers to the basic ones built into IPCompleter
2049 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
2059 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
2050 self.strdispatchers['complete_command'] = sdisp
2060 self.strdispatchers['complete_command'] = sdisp
2051 self.Completer.custom_completers = sdisp
2061 self.Completer.custom_completers = sdisp
2052
2062
2053 self.set_hook('complete_command', module_completer, str_key = 'import')
2063 self.set_hook('complete_command', module_completer, str_key = 'import')
2054 self.set_hook('complete_command', module_completer, str_key = 'from')
2064 self.set_hook('complete_command', module_completer, str_key = 'from')
2055 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
2065 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
2056 self.set_hook('complete_command', cd_completer, str_key = '%cd')
2066 self.set_hook('complete_command', cd_completer, str_key = '%cd')
2057 self.set_hook('complete_command', reset_completer, str_key = '%reset')
2067 self.set_hook('complete_command', reset_completer, str_key = '%reset')
2058
2068
2059 # Only configure readline if we truly are using readline. IPython can
2069 # Only configure readline if we truly are using readline. IPython can
2060 # do tab-completion over the network, in GUIs, etc, where readline
2070 # do tab-completion over the network, in GUIs, etc, where readline
2061 # itself may be absent
2071 # itself may be absent
2062 if self.has_readline:
2072 if self.has_readline:
2063 self.set_readline_completer()
2073 self.set_readline_completer()
2064
2074
2065 def complete(self, text, line=None, cursor_pos=None):
2075 def complete(self, text, line=None, cursor_pos=None):
2066 """Return the completed text and a list of completions.
2076 """Return the completed text and a list of completions.
2067
2077
2068 Parameters
2078 Parameters
2069 ----------
2079 ----------
2070
2080
2071 text : string
2081 text : string
2072 A string of text to be completed on. It can be given as empty and
2082 A string of text to be completed on. It can be given as empty and
2073 instead a line/position pair are given. In this case, the
2083 instead a line/position pair are given. In this case, the
2074 completer itself will split the line like readline does.
2084 completer itself will split the line like readline does.
2075
2085
2076 line : string, optional
2086 line : string, optional
2077 The complete line that text is part of.
2087 The complete line that text is part of.
2078
2088
2079 cursor_pos : int, optional
2089 cursor_pos : int, optional
2080 The position of the cursor on the input line.
2090 The position of the cursor on the input line.
2081
2091
2082 Returns
2092 Returns
2083 -------
2093 -------
2084 text : string
2094 text : string
2085 The actual text that was completed.
2095 The actual text that was completed.
2086
2096
2087 matches : list
2097 matches : list
2088 A sorted list with all possible completions.
2098 A sorted list with all possible completions.
2089
2099
2090 The optional arguments allow the completion to take more context into
2100 The optional arguments allow the completion to take more context into
2091 account, and are part of the low-level completion API.
2101 account, and are part of the low-level completion API.
2092
2102
2093 This is a wrapper around the completion mechanism, similar to what
2103 This is a wrapper around the completion mechanism, similar to what
2094 readline does at the command line when the TAB key is hit. By
2104 readline does at the command line when the TAB key is hit. By
2095 exposing it as a method, it can be used by other non-readline
2105 exposing it as a method, it can be used by other non-readline
2096 environments (such as GUIs) for text completion.
2106 environments (such as GUIs) for text completion.
2097
2107
2098 Simple usage example:
2108 Simple usage example:
2099
2109
2100 In [1]: x = 'hello'
2110 In [1]: x = 'hello'
2101
2111
2102 In [2]: _ip.complete('x.l')
2112 In [2]: _ip.complete('x.l')
2103 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
2113 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
2104 """
2114 """
2105
2115
2106 # Inject names into __builtin__ so we can complete on the added names.
2116 # Inject names into __builtin__ so we can complete on the added names.
2107 with self.builtin_trap:
2117 with self.builtin_trap:
2108 return self.Completer.complete(text, line, cursor_pos)
2118 return self.Completer.complete(text, line, cursor_pos)
2109
2119
2110 def set_custom_completer(self, completer, pos=0):
2120 def set_custom_completer(self, completer, pos=0):
2111 """Adds a new custom completer function.
2121 """Adds a new custom completer function.
2112
2122
2113 The position argument (defaults to 0) is the index in the completers
2123 The position argument (defaults to 0) is the index in the completers
2114 list where you want the completer to be inserted."""
2124 list where you want the completer to be inserted."""
2115
2125
2116 newcomp = types.MethodType(completer,self.Completer)
2126 newcomp = types.MethodType(completer,self.Completer)
2117 self.Completer.matchers.insert(pos,newcomp)
2127 self.Completer.matchers.insert(pos,newcomp)
2118
2128
2119 def set_readline_completer(self):
2129 def set_readline_completer(self):
2120 """Reset readline's completer to be our own."""
2130 """Reset readline's completer to be our own."""
2121 self.readline.set_completer(self.Completer.rlcomplete)
2131 self.readline.set_completer(self.Completer.rlcomplete)
2122
2132
2123 def set_completer_frame(self, frame=None):
2133 def set_completer_frame(self, frame=None):
2124 """Set the frame of the completer."""
2134 """Set the frame of the completer."""
2125 if frame:
2135 if frame:
2126 self.Completer.namespace = frame.f_locals
2136 self.Completer.namespace = frame.f_locals
2127 self.Completer.global_namespace = frame.f_globals
2137 self.Completer.global_namespace = frame.f_globals
2128 else:
2138 else:
2129 self.Completer.namespace = self.user_ns
2139 self.Completer.namespace = self.user_ns
2130 self.Completer.global_namespace = self.user_global_ns
2140 self.Completer.global_namespace = self.user_global_ns
2131
2141
2132 #-------------------------------------------------------------------------
2142 #-------------------------------------------------------------------------
2133 # Things related to magics
2143 # Things related to magics
2134 #-------------------------------------------------------------------------
2144 #-------------------------------------------------------------------------
2135
2145
2136 def init_magics(self):
2146 def init_magics(self):
2137 from IPython.core import magics as m
2147 from IPython.core import magics as m
2138 self.magics_manager = magic.MagicsManager(shell=self,
2148 self.magics_manager = magic.MagicsManager(shell=self,
2139 parent=self,
2149 parent=self,
2140 user_magics=m.UserMagics(self))
2150 user_magics=m.UserMagics(self))
2141 self.configurables.append(self.magics_manager)
2151 self.configurables.append(self.magics_manager)
2142
2152
2143 # Expose as public API from the magics manager
2153 # Expose as public API from the magics manager
2144 self.register_magics = self.magics_manager.register
2154 self.register_magics = self.magics_manager.register
2145 self.define_magic = self.magics_manager.define_magic
2155 self.define_magic = self.magics_manager.define_magic
2146
2156
2147 self.register_magics(m.AutoMagics, m.BasicMagics, m.CodeMagics,
2157 self.register_magics(m.AutoMagics, m.BasicMagics, m.CodeMagics,
2148 m.ConfigMagics, m.DeprecatedMagics, m.DisplayMagics, m.ExecutionMagics,
2158 m.ConfigMagics, m.DeprecatedMagics, m.DisplayMagics, m.ExecutionMagics,
2149 m.ExtensionMagics, m.HistoryMagics, m.LoggingMagics,
2159 m.ExtensionMagics, m.HistoryMagics, m.LoggingMagics,
2150 m.NamespaceMagics, m.OSMagics, m.PylabMagics, m.ScriptMagics,
2160 m.NamespaceMagics, m.OSMagics, m.PylabMagics, m.ScriptMagics,
2151 )
2161 )
2152
2162
2153 # Register Magic Aliases
2163 # Register Magic Aliases
2154 mman = self.magics_manager
2164 mman = self.magics_manager
2155 # FIXME: magic aliases should be defined by the Magics classes
2165 # FIXME: magic aliases should be defined by the Magics classes
2156 # or in MagicsManager, not here
2166 # or in MagicsManager, not here
2157 mman.register_alias('ed', 'edit')
2167 mman.register_alias('ed', 'edit')
2158 mman.register_alias('hist', 'history')
2168 mman.register_alias('hist', 'history')
2159 mman.register_alias('rep', 'recall')
2169 mman.register_alias('rep', 'recall')
2160 mman.register_alias('SVG', 'svg', 'cell')
2170 mman.register_alias('SVG', 'svg', 'cell')
2161 mman.register_alias('HTML', 'html', 'cell')
2171 mman.register_alias('HTML', 'html', 'cell')
2162 mman.register_alias('file', 'writefile', 'cell')
2172 mman.register_alias('file', 'writefile', 'cell')
2163
2173
2164 # FIXME: Move the color initialization to the DisplayHook, which
2174 # FIXME: Move the color initialization to the DisplayHook, which
2165 # should be split into a prompt manager and displayhook. We probably
2175 # should be split into a prompt manager and displayhook. We probably
2166 # even need a centralize colors management object.
2176 # even need a centralize colors management object.
2167 self.magic('colors %s' % self.colors)
2177 self.magic('colors %s' % self.colors)
2168
2178
2169 # Defined here so that it's included in the documentation
2179 # Defined here so that it's included in the documentation
2170 @functools.wraps(magic.MagicsManager.register_function)
2180 @functools.wraps(magic.MagicsManager.register_function)
2171 def register_magic_function(self, func, magic_kind='line', magic_name=None):
2181 def register_magic_function(self, func, magic_kind='line', magic_name=None):
2172 self.magics_manager.register_function(func,
2182 self.magics_manager.register_function(func,
2173 magic_kind=magic_kind, magic_name=magic_name)
2183 magic_kind=magic_kind, magic_name=magic_name)
2174
2184
2175 def run_line_magic(self, magic_name, line):
2185 def run_line_magic(self, magic_name, line):
2176 """Execute the given line magic.
2186 """Execute the given line magic.
2177
2187
2178 Parameters
2188 Parameters
2179 ----------
2189 ----------
2180 magic_name : str
2190 magic_name : str
2181 Name of the desired magic function, without '%' prefix.
2191 Name of the desired magic function, without '%' prefix.
2182
2192
2183 line : str
2193 line : str
2184 The rest of the input line as a single string.
2194 The rest of the input line as a single string.
2185 """
2195 """
2186 fn = self.find_line_magic(magic_name)
2196 fn = self.find_line_magic(magic_name)
2187 if fn is None:
2197 if fn is None:
2188 cm = self.find_cell_magic(magic_name)
2198 cm = self.find_cell_magic(magic_name)
2189 etpl = "Line magic function `%%%s` not found%s."
2199 etpl = "Line magic function `%%%s` not found%s."
2190 extra = '' if cm is None else (' (But cell magic `%%%%%s` exists, '
2200 extra = '' if cm is None else (' (But cell magic `%%%%%s` exists, '
2191 'did you mean that instead?)' % magic_name )
2201 'did you mean that instead?)' % magic_name )
2192 error(etpl % (magic_name, extra))
2202 error(etpl % (magic_name, extra))
2193 else:
2203 else:
2194 # Note: this is the distance in the stack to the user's frame.
2204 # Note: this is the distance in the stack to the user's frame.
2195 # This will need to be updated if the internal calling logic gets
2205 # This will need to be updated if the internal calling logic gets
2196 # refactored, or else we'll be expanding the wrong variables.
2206 # refactored, or else we'll be expanding the wrong variables.
2197 stack_depth = 2
2207 stack_depth = 2
2198 magic_arg_s = self.var_expand(line, stack_depth)
2208 magic_arg_s = self.var_expand(line, stack_depth)
2199 # Put magic args in a list so we can call with f(*a) syntax
2209 # Put magic args in a list so we can call with f(*a) syntax
2200 args = [magic_arg_s]
2210 args = [magic_arg_s]
2201 kwargs = {}
2211 kwargs = {}
2202 # Grab local namespace if we need it:
2212 # Grab local namespace if we need it:
2203 if getattr(fn, "needs_local_scope", False):
2213 if getattr(fn, "needs_local_scope", False):
2204 kwargs['local_ns'] = sys._getframe(stack_depth).f_locals
2214 kwargs['local_ns'] = sys._getframe(stack_depth).f_locals
2205 with self.builtin_trap:
2215 with self.builtin_trap:
2206 result = fn(*args,**kwargs)
2216 result = fn(*args,**kwargs)
2207 return result
2217 return result
2208
2218
2209 def run_cell_magic(self, magic_name, line, cell):
2219 def run_cell_magic(self, magic_name, line, cell):
2210 """Execute the given cell magic.
2220 """Execute the given cell magic.
2211
2221
2212 Parameters
2222 Parameters
2213 ----------
2223 ----------
2214 magic_name : str
2224 magic_name : str
2215 Name of the desired magic function, without '%' prefix.
2225 Name of the desired magic function, without '%' prefix.
2216
2226
2217 line : str
2227 line : str
2218 The rest of the first input line as a single string.
2228 The rest of the first input line as a single string.
2219
2229
2220 cell : str
2230 cell : str
2221 The body of the cell as a (possibly multiline) string.
2231 The body of the cell as a (possibly multiline) string.
2222 """
2232 """
2223 fn = self.find_cell_magic(magic_name)
2233 fn = self.find_cell_magic(magic_name)
2224 if fn is None:
2234 if fn is None:
2225 lm = self.find_line_magic(magic_name)
2235 lm = self.find_line_magic(magic_name)
2226 etpl = "Cell magic `%%{0}` not found{1}."
2236 etpl = "Cell magic `%%{0}` not found{1}."
2227 extra = '' if lm is None else (' (But line magic `%{0}` exists, '
2237 extra = '' if lm is None else (' (But line magic `%{0}` exists, '
2228 'did you mean that instead?)'.format(magic_name))
2238 'did you mean that instead?)'.format(magic_name))
2229 error(etpl.format(magic_name, extra))
2239 error(etpl.format(magic_name, extra))
2230 elif cell == '':
2240 elif cell == '':
2231 message = '%%{0} is a cell magic, but the cell body is empty.'.format(magic_name)
2241 message = '%%{0} is a cell magic, but the cell body is empty.'.format(magic_name)
2232 if self.find_line_magic(magic_name) is not None:
2242 if self.find_line_magic(magic_name) is not None:
2233 message += ' Did you mean the line magic %{0} (single %)?'.format(magic_name)
2243 message += ' Did you mean the line magic %{0} (single %)?'.format(magic_name)
2234 raise UsageError(message)
2244 raise UsageError(message)
2235 else:
2245 else:
2236 # Note: this is the distance in the stack to the user's frame.
2246 # Note: this is the distance in the stack to the user's frame.
2237 # This will need to be updated if the internal calling logic gets
2247 # This will need to be updated if the internal calling logic gets
2238 # refactored, or else we'll be expanding the wrong variables.
2248 # refactored, or else we'll be expanding the wrong variables.
2239 stack_depth = 2
2249 stack_depth = 2
2240 magic_arg_s = self.var_expand(line, stack_depth)
2250 magic_arg_s = self.var_expand(line, stack_depth)
2241 with self.builtin_trap:
2251 with self.builtin_trap:
2242 result = fn(magic_arg_s, cell)
2252 result = fn(magic_arg_s, cell)
2243 return result
2253 return result
2244
2254
2245 def find_line_magic(self, magic_name):
2255 def find_line_magic(self, magic_name):
2246 """Find and return a line magic by name.
2256 """Find and return a line magic by name.
2247
2257
2248 Returns None if the magic isn't found."""
2258 Returns None if the magic isn't found."""
2249 return self.magics_manager.magics['line'].get(magic_name)
2259 return self.magics_manager.magics['line'].get(magic_name)
2250
2260
2251 def find_cell_magic(self, magic_name):
2261 def find_cell_magic(self, magic_name):
2252 """Find and return a cell magic by name.
2262 """Find and return a cell magic by name.
2253
2263
2254 Returns None if the magic isn't found."""
2264 Returns None if the magic isn't found."""
2255 return self.magics_manager.magics['cell'].get(magic_name)
2265 return self.magics_manager.magics['cell'].get(magic_name)
2256
2266
2257 def find_magic(self, magic_name, magic_kind='line'):
2267 def find_magic(self, magic_name, magic_kind='line'):
2258 """Find and return a magic of the given type by name.
2268 """Find and return a magic of the given type by name.
2259
2269
2260 Returns None if the magic isn't found."""
2270 Returns None if the magic isn't found."""
2261 return self.magics_manager.magics[magic_kind].get(magic_name)
2271 return self.magics_manager.magics[magic_kind].get(magic_name)
2262
2272
2263 def magic(self, arg_s):
2273 def magic(self, arg_s):
2264 """DEPRECATED. Use run_line_magic() instead.
2274 """DEPRECATED. Use run_line_magic() instead.
2265
2275
2266 Call a magic function by name.
2276 Call a magic function by name.
2267
2277
2268 Input: a string containing the name of the magic function to call and
2278 Input: a string containing the name of the magic function to call and
2269 any additional arguments to be passed to the magic.
2279 any additional arguments to be passed to the magic.
2270
2280
2271 magic('name -opt foo bar') is equivalent to typing at the ipython
2281 magic('name -opt foo bar') is equivalent to typing at the ipython
2272 prompt:
2282 prompt:
2273
2283
2274 In[1]: %name -opt foo bar
2284 In[1]: %name -opt foo bar
2275
2285
2276 To call a magic without arguments, simply use magic('name').
2286 To call a magic without arguments, simply use magic('name').
2277
2287
2278 This provides a proper Python function to call IPython's magics in any
2288 This provides a proper Python function to call IPython's magics in any
2279 valid Python code you can type at the interpreter, including loops and
2289 valid Python code you can type at the interpreter, including loops and
2280 compound statements.
2290 compound statements.
2281 """
2291 """
2282 # TODO: should we issue a loud deprecation warning here?
2292 # TODO: should we issue a loud deprecation warning here?
2283 magic_name, _, magic_arg_s = arg_s.partition(' ')
2293 magic_name, _, magic_arg_s = arg_s.partition(' ')
2284 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
2294 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
2285 return self.run_line_magic(magic_name, magic_arg_s)
2295 return self.run_line_magic(magic_name, magic_arg_s)
2286
2296
2287 #-------------------------------------------------------------------------
2297 #-------------------------------------------------------------------------
2288 # Things related to macros
2298 # Things related to macros
2289 #-------------------------------------------------------------------------
2299 #-------------------------------------------------------------------------
2290
2300
2291 def define_macro(self, name, themacro):
2301 def define_macro(self, name, themacro):
2292 """Define a new macro
2302 """Define a new macro
2293
2303
2294 Parameters
2304 Parameters
2295 ----------
2305 ----------
2296 name : str
2306 name : str
2297 The name of the macro.
2307 The name of the macro.
2298 themacro : str or Macro
2308 themacro : str or Macro
2299 The action to do upon invoking the macro. If a string, a new
2309 The action to do upon invoking the macro. If a string, a new
2300 Macro object is created by passing the string to it.
2310 Macro object is created by passing the string to it.
2301 """
2311 """
2302
2312
2303 from IPython.core import macro
2313 from IPython.core import macro
2304
2314
2305 if isinstance(themacro, string_types):
2315 if isinstance(themacro, string_types):
2306 themacro = macro.Macro(themacro)
2316 themacro = macro.Macro(themacro)
2307 if not isinstance(themacro, macro.Macro):
2317 if not isinstance(themacro, macro.Macro):
2308 raise ValueError('A macro must be a string or a Macro instance.')
2318 raise ValueError('A macro must be a string or a Macro instance.')
2309 self.user_ns[name] = themacro
2319 self.user_ns[name] = themacro
2310
2320
2311 #-------------------------------------------------------------------------
2321 #-------------------------------------------------------------------------
2312 # Things related to the running of system commands
2322 # Things related to the running of system commands
2313 #-------------------------------------------------------------------------
2323 #-------------------------------------------------------------------------
2314
2324
2315 def system_piped(self, cmd):
2325 def system_piped(self, cmd):
2316 """Call the given cmd in a subprocess, piping stdout/err
2326 """Call the given cmd in a subprocess, piping stdout/err
2317
2327
2318 Parameters
2328 Parameters
2319 ----------
2329 ----------
2320 cmd : str
2330 cmd : str
2321 Command to execute (can not end in '&', as background processes are
2331 Command to execute (can not end in '&', as background processes are
2322 not supported. Should not be a command that expects input
2332 not supported. Should not be a command that expects input
2323 other than simple text.
2333 other than simple text.
2324 """
2334 """
2325 if cmd.rstrip().endswith('&'):
2335 if cmd.rstrip().endswith('&'):
2326 # this is *far* from a rigorous test
2336 # this is *far* from a rigorous test
2327 # We do not support backgrounding processes because we either use
2337 # We do not support backgrounding processes because we either use
2328 # pexpect or pipes to read from. Users can always just call
2338 # pexpect or pipes to read from. Users can always just call
2329 # os.system() or use ip.system=ip.system_raw
2339 # os.system() or use ip.system=ip.system_raw
2330 # if they really want a background process.
2340 # if they really want a background process.
2331 raise OSError("Background processes not supported.")
2341 raise OSError("Background processes not supported.")
2332
2342
2333 # we explicitly do NOT return the subprocess status code, because
2343 # we explicitly do NOT return the subprocess status code, because
2334 # a non-None value would trigger :func:`sys.displayhook` calls.
2344 # a non-None value would trigger :func:`sys.displayhook` calls.
2335 # Instead, we store the exit_code in user_ns.
2345 # Instead, we store the exit_code in user_ns.
2336 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=1))
2346 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=1))
2337
2347
2338 def system_raw(self, cmd):
2348 def system_raw(self, cmd):
2339 """Call the given cmd in a subprocess using os.system on Windows or
2349 """Call the given cmd in a subprocess using os.system on Windows or
2340 subprocess.call using the system shell on other platforms.
2350 subprocess.call using the system shell on other platforms.
2341
2351
2342 Parameters
2352 Parameters
2343 ----------
2353 ----------
2344 cmd : str
2354 cmd : str
2345 Command to execute.
2355 Command to execute.
2346 """
2356 """
2347 cmd = self.var_expand(cmd, depth=1)
2357 cmd = self.var_expand(cmd, depth=1)
2348 # protect os.system from UNC paths on Windows, which it can't handle:
2358 # protect os.system from UNC paths on Windows, which it can't handle:
2349 if sys.platform == 'win32':
2359 if sys.platform == 'win32':
2350 from IPython.utils._process_win32 import AvoidUNCPath
2360 from IPython.utils._process_win32 import AvoidUNCPath
2351 with AvoidUNCPath() as path:
2361 with AvoidUNCPath() as path:
2352 if path is not None:
2362 if path is not None:
2353 cmd = '"pushd %s &&"%s' % (path, cmd)
2363 cmd = '"pushd %s &&"%s' % (path, cmd)
2354 cmd = py3compat.unicode_to_str(cmd)
2364 cmd = py3compat.unicode_to_str(cmd)
2355 try:
2365 try:
2356 ec = os.system(cmd)
2366 ec = os.system(cmd)
2357 except KeyboardInterrupt:
2367 except KeyboardInterrupt:
2358 self.write_err("\nKeyboardInterrupt\n")
2368 self.write_err('\n' + self.get_exception_only())
2359 ec = -2
2369 ec = -2
2360 else:
2370 else:
2361 cmd = py3compat.unicode_to_str(cmd)
2371 cmd = py3compat.unicode_to_str(cmd)
2362 # For posix the result of the subprocess.call() below is an exit
2372 # For posix the result of the subprocess.call() below is an exit
2363 # code, which by convention is zero for success, positive for
2373 # code, which by convention is zero for success, positive for
2364 # program failure. Exit codes above 128 are reserved for signals,
2374 # program failure. Exit codes above 128 are reserved for signals,
2365 # and the formula for converting a signal to an exit code is usually
2375 # and the formula for converting a signal to an exit code is usually
2366 # signal_number+128. To more easily differentiate between exit
2376 # signal_number+128. To more easily differentiate between exit
2367 # codes and signals, ipython uses negative numbers. For instance
2377 # codes and signals, ipython uses negative numbers. For instance
2368 # since control-c is signal 2 but exit code 130, ipython's
2378 # since control-c is signal 2 but exit code 130, ipython's
2369 # _exit_code variable will read -2. Note that some shells like
2379 # _exit_code variable will read -2. Note that some shells like
2370 # csh and fish don't follow sh/bash conventions for exit codes.
2380 # csh and fish don't follow sh/bash conventions for exit codes.
2371 executable = os.environ.get('SHELL', None)
2381 executable = os.environ.get('SHELL', None)
2372 try:
2382 try:
2373 # Use env shell instead of default /bin/sh
2383 # Use env shell instead of default /bin/sh
2374 ec = subprocess.call(cmd, shell=True, executable=executable)
2384 ec = subprocess.call(cmd, shell=True, executable=executable)
2375 except KeyboardInterrupt:
2385 except KeyboardInterrupt:
2376 # intercept control-C; a long traceback is not useful here
2386 # intercept control-C; a long traceback is not useful here
2377 self.write_err("\nKeyboardInterrupt\n")
2387 self.write_err('\n' + self.get_exception_only())
2378 ec = 130
2388 ec = 130
2379 if ec > 128:
2389 if ec > 128:
2380 ec = -(ec - 128)
2390 ec = -(ec - 128)
2381
2391
2382 # We explicitly do NOT return the subprocess status code, because
2392 # We explicitly do NOT return the subprocess status code, because
2383 # a non-None value would trigger :func:`sys.displayhook` calls.
2393 # a non-None value would trigger :func:`sys.displayhook` calls.
2384 # Instead, we store the exit_code in user_ns. Note the semantics
2394 # Instead, we store the exit_code in user_ns. Note the semantics
2385 # of _exit_code: for control-c, _exit_code == -signal.SIGNIT,
2395 # of _exit_code: for control-c, _exit_code == -signal.SIGNIT,
2386 # but raising SystemExit(_exit_code) will give status 254!
2396 # but raising SystemExit(_exit_code) will give status 254!
2387 self.user_ns['_exit_code'] = ec
2397 self.user_ns['_exit_code'] = ec
2388
2398
2389 # use piped system by default, because it is better behaved
2399 # use piped system by default, because it is better behaved
2390 system = system_piped
2400 system = system_piped
2391
2401
2392 def getoutput(self, cmd, split=True, depth=0):
2402 def getoutput(self, cmd, split=True, depth=0):
2393 """Get output (possibly including stderr) from a subprocess.
2403 """Get output (possibly including stderr) from a subprocess.
2394
2404
2395 Parameters
2405 Parameters
2396 ----------
2406 ----------
2397 cmd : str
2407 cmd : str
2398 Command to execute (can not end in '&', as background processes are
2408 Command to execute (can not end in '&', as background processes are
2399 not supported.
2409 not supported.
2400 split : bool, optional
2410 split : bool, optional
2401 If True, split the output into an IPython SList. Otherwise, an
2411 If True, split the output into an IPython SList. Otherwise, an
2402 IPython LSString is returned. These are objects similar to normal
2412 IPython LSString is returned. These are objects similar to normal
2403 lists and strings, with a few convenience attributes for easier
2413 lists and strings, with a few convenience attributes for easier
2404 manipulation of line-based output. You can use '?' on them for
2414 manipulation of line-based output. You can use '?' on them for
2405 details.
2415 details.
2406 depth : int, optional
2416 depth : int, optional
2407 How many frames above the caller are the local variables which should
2417 How many frames above the caller are the local variables which should
2408 be expanded in the command string? The default (0) assumes that the
2418 be expanded in the command string? The default (0) assumes that the
2409 expansion variables are in the stack frame calling this function.
2419 expansion variables are in the stack frame calling this function.
2410 """
2420 """
2411 if cmd.rstrip().endswith('&'):
2421 if cmd.rstrip().endswith('&'):
2412 # this is *far* from a rigorous test
2422 # this is *far* from a rigorous test
2413 raise OSError("Background processes not supported.")
2423 raise OSError("Background processes not supported.")
2414 out = getoutput(self.var_expand(cmd, depth=depth+1))
2424 out = getoutput(self.var_expand(cmd, depth=depth+1))
2415 if split:
2425 if split:
2416 out = SList(out.splitlines())
2426 out = SList(out.splitlines())
2417 else:
2427 else:
2418 out = LSString(out)
2428 out = LSString(out)
2419 return out
2429 return out
2420
2430
2421 #-------------------------------------------------------------------------
2431 #-------------------------------------------------------------------------
2422 # Things related to aliases
2432 # Things related to aliases
2423 #-------------------------------------------------------------------------
2433 #-------------------------------------------------------------------------
2424
2434
2425 def init_alias(self):
2435 def init_alias(self):
2426 self.alias_manager = AliasManager(shell=self, parent=self)
2436 self.alias_manager = AliasManager(shell=self, parent=self)
2427 self.configurables.append(self.alias_manager)
2437 self.configurables.append(self.alias_manager)
2428
2438
2429 #-------------------------------------------------------------------------
2439 #-------------------------------------------------------------------------
2430 # Things related to extensions
2440 # Things related to extensions
2431 #-------------------------------------------------------------------------
2441 #-------------------------------------------------------------------------
2432
2442
2433 def init_extension_manager(self):
2443 def init_extension_manager(self):
2434 self.extension_manager = ExtensionManager(shell=self, parent=self)
2444 self.extension_manager = ExtensionManager(shell=self, parent=self)
2435 self.configurables.append(self.extension_manager)
2445 self.configurables.append(self.extension_manager)
2436
2446
2437 #-------------------------------------------------------------------------
2447 #-------------------------------------------------------------------------
2438 # Things related to payloads
2448 # Things related to payloads
2439 #-------------------------------------------------------------------------
2449 #-------------------------------------------------------------------------
2440
2450
2441 def init_payload(self):
2451 def init_payload(self):
2442 self.payload_manager = PayloadManager(parent=self)
2452 self.payload_manager = PayloadManager(parent=self)
2443 self.configurables.append(self.payload_manager)
2453 self.configurables.append(self.payload_manager)
2444
2454
2445 #-------------------------------------------------------------------------
2455 #-------------------------------------------------------------------------
2446 # Things related to the prefilter
2456 # Things related to the prefilter
2447 #-------------------------------------------------------------------------
2457 #-------------------------------------------------------------------------
2448
2458
2449 def init_prefilter(self):
2459 def init_prefilter(self):
2450 self.prefilter_manager = PrefilterManager(shell=self, parent=self)
2460 self.prefilter_manager = PrefilterManager(shell=self, parent=self)
2451 self.configurables.append(self.prefilter_manager)
2461 self.configurables.append(self.prefilter_manager)
2452 # Ultimately this will be refactored in the new interpreter code, but
2462 # Ultimately this will be refactored in the new interpreter code, but
2453 # for now, we should expose the main prefilter method (there's legacy
2463 # for now, we should expose the main prefilter method (there's legacy
2454 # code out there that may rely on this).
2464 # code out there that may rely on this).
2455 self.prefilter = self.prefilter_manager.prefilter_lines
2465 self.prefilter = self.prefilter_manager.prefilter_lines
2456
2466
2457 def auto_rewrite_input(self, cmd):
2467 def auto_rewrite_input(self, cmd):
2458 """Print to the screen the rewritten form of the user's command.
2468 """Print to the screen the rewritten form of the user's command.
2459
2469
2460 This shows visual feedback by rewriting input lines that cause
2470 This shows visual feedback by rewriting input lines that cause
2461 automatic calling to kick in, like::
2471 automatic calling to kick in, like::
2462
2472
2463 /f x
2473 /f x
2464
2474
2465 into::
2475 into::
2466
2476
2467 ------> f(x)
2477 ------> f(x)
2468
2478
2469 after the user's input prompt. This helps the user understand that the
2479 after the user's input prompt. This helps the user understand that the
2470 input line was transformed automatically by IPython.
2480 input line was transformed automatically by IPython.
2471 """
2481 """
2472 if not self.show_rewritten_input:
2482 if not self.show_rewritten_input:
2473 return
2483 return
2474
2484
2475 rw = self.prompt_manager.render('rewrite') + cmd
2485 rw = self.prompt_manager.render('rewrite') + cmd
2476
2486
2477 try:
2487 try:
2478 # plain ascii works better w/ pyreadline, on some machines, so
2488 # plain ascii works better w/ pyreadline, on some machines, so
2479 # we use it and only print uncolored rewrite if we have unicode
2489 # we use it and only print uncolored rewrite if we have unicode
2480 rw = str(rw)
2490 rw = str(rw)
2481 print(rw, file=io.stdout)
2491 print(rw, file=io.stdout)
2482 except UnicodeEncodeError:
2492 except UnicodeEncodeError:
2483 print("------> " + cmd)
2493 print("------> " + cmd)
2484
2494
2485 #-------------------------------------------------------------------------
2495 #-------------------------------------------------------------------------
2486 # Things related to extracting values/expressions from kernel and user_ns
2496 # Things related to extracting values/expressions from kernel and user_ns
2487 #-------------------------------------------------------------------------
2497 #-------------------------------------------------------------------------
2488
2498
2489 def _user_obj_error(self):
2499 def _user_obj_error(self):
2490 """return simple exception dict
2500 """return simple exception dict
2491
2501
2492 for use in user_expressions
2502 for use in user_expressions
2493 """
2503 """
2494
2504
2495 etype, evalue, tb = self._get_exc_info()
2505 etype, evalue, tb = self._get_exc_info()
2496 stb = self.InteractiveTB.get_exception_only(etype, evalue)
2506 stb = self.InteractiveTB.get_exception_only(etype, evalue)
2497
2507
2498 exc_info = {
2508 exc_info = {
2499 u'status' : 'error',
2509 u'status' : 'error',
2500 u'traceback' : stb,
2510 u'traceback' : stb,
2501 u'ename' : unicode_type(etype.__name__),
2511 u'ename' : unicode_type(etype.__name__),
2502 u'evalue' : py3compat.safe_unicode(evalue),
2512 u'evalue' : py3compat.safe_unicode(evalue),
2503 }
2513 }
2504
2514
2505 return exc_info
2515 return exc_info
2506
2516
2507 def _format_user_obj(self, obj):
2517 def _format_user_obj(self, obj):
2508 """format a user object to display dict
2518 """format a user object to display dict
2509
2519
2510 for use in user_expressions
2520 for use in user_expressions
2511 """
2521 """
2512
2522
2513 data, md = self.display_formatter.format(obj)
2523 data, md = self.display_formatter.format(obj)
2514 value = {
2524 value = {
2515 'status' : 'ok',
2525 'status' : 'ok',
2516 'data' : data,
2526 'data' : data,
2517 'metadata' : md,
2527 'metadata' : md,
2518 }
2528 }
2519 return value
2529 return value
2520
2530
2521 def user_expressions(self, expressions):
2531 def user_expressions(self, expressions):
2522 """Evaluate a dict of expressions in the user's namespace.
2532 """Evaluate a dict of expressions in the user's namespace.
2523
2533
2524 Parameters
2534 Parameters
2525 ----------
2535 ----------
2526 expressions : dict
2536 expressions : dict
2527 A dict with string keys and string values. The expression values
2537 A dict with string keys and string values. The expression values
2528 should be valid Python expressions, each of which will be evaluated
2538 should be valid Python expressions, each of which will be evaluated
2529 in the user namespace.
2539 in the user namespace.
2530
2540
2531 Returns
2541 Returns
2532 -------
2542 -------
2533 A dict, keyed like the input expressions dict, with the rich mime-typed
2543 A dict, keyed like the input expressions dict, with the rich mime-typed
2534 display_data of each value.
2544 display_data of each value.
2535 """
2545 """
2536 out = {}
2546 out = {}
2537 user_ns = self.user_ns
2547 user_ns = self.user_ns
2538 global_ns = self.user_global_ns
2548 global_ns = self.user_global_ns
2539
2549
2540 for key, expr in iteritems(expressions):
2550 for key, expr in iteritems(expressions):
2541 try:
2551 try:
2542 value = self._format_user_obj(eval(expr, global_ns, user_ns))
2552 value = self._format_user_obj(eval(expr, global_ns, user_ns))
2543 except:
2553 except:
2544 value = self._user_obj_error()
2554 value = self._user_obj_error()
2545 out[key] = value
2555 out[key] = value
2546 return out
2556 return out
2547
2557
2548 #-------------------------------------------------------------------------
2558 #-------------------------------------------------------------------------
2549 # Things related to the running of code
2559 # Things related to the running of code
2550 #-------------------------------------------------------------------------
2560 #-------------------------------------------------------------------------
2551
2561
2552 def ex(self, cmd):
2562 def ex(self, cmd):
2553 """Execute a normal python statement in user namespace."""
2563 """Execute a normal python statement in user namespace."""
2554 with self.builtin_trap:
2564 with self.builtin_trap:
2555 exec(cmd, self.user_global_ns, self.user_ns)
2565 exec(cmd, self.user_global_ns, self.user_ns)
2556
2566
2557 def ev(self, expr):
2567 def ev(self, expr):
2558 """Evaluate python expression expr in user namespace.
2568 """Evaluate python expression expr in user namespace.
2559
2569
2560 Returns the result of evaluation
2570 Returns the result of evaluation
2561 """
2571 """
2562 with self.builtin_trap:
2572 with self.builtin_trap:
2563 return eval(expr, self.user_global_ns, self.user_ns)
2573 return eval(expr, self.user_global_ns, self.user_ns)
2564
2574
2565 def safe_execfile(self, fname, *where, **kw):
2575 def safe_execfile(self, fname, *where, **kw):
2566 """A safe version of the builtin execfile().
2576 """A safe version of the builtin execfile().
2567
2577
2568 This version will never throw an exception, but instead print
2578 This version will never throw an exception, but instead print
2569 helpful error messages to the screen. This only works on pure
2579 helpful error messages to the screen. This only works on pure
2570 Python files with the .py extension.
2580 Python files with the .py extension.
2571
2581
2572 Parameters
2582 Parameters
2573 ----------
2583 ----------
2574 fname : string
2584 fname : string
2575 The name of the file to be executed.
2585 The name of the file to be executed.
2576 where : tuple
2586 where : tuple
2577 One or two namespaces, passed to execfile() as (globals,locals).
2587 One or two namespaces, passed to execfile() as (globals,locals).
2578 If only one is given, it is passed as both.
2588 If only one is given, it is passed as both.
2579 exit_ignore : bool (False)
2589 exit_ignore : bool (False)
2580 If True, then silence SystemExit for non-zero status (it is always
2590 If True, then silence SystemExit for non-zero status (it is always
2581 silenced for zero status, as it is so common).
2591 silenced for zero status, as it is so common).
2582 raise_exceptions : bool (False)
2592 raise_exceptions : bool (False)
2583 If True raise exceptions everywhere. Meant for testing.
2593 If True raise exceptions everywhere. Meant for testing.
2584 shell_futures : bool (False)
2594 shell_futures : bool (False)
2585 If True, the code will share future statements with the interactive
2595 If True, the code will share future statements with the interactive
2586 shell. It will both be affected by previous __future__ imports, and
2596 shell. It will both be affected by previous __future__ imports, and
2587 any __future__ imports in the code will affect the shell. If False,
2597 any __future__ imports in the code will affect the shell. If False,
2588 __future__ imports are not shared in either direction.
2598 __future__ imports are not shared in either direction.
2589
2599
2590 """
2600 """
2591 kw.setdefault('exit_ignore', False)
2601 kw.setdefault('exit_ignore', False)
2592 kw.setdefault('raise_exceptions', False)
2602 kw.setdefault('raise_exceptions', False)
2593 kw.setdefault('shell_futures', False)
2603 kw.setdefault('shell_futures', False)
2594
2604
2595 fname = os.path.abspath(os.path.expanduser(fname))
2605 fname = os.path.abspath(os.path.expanduser(fname))
2596
2606
2597 # Make sure we can open the file
2607 # Make sure we can open the file
2598 try:
2608 try:
2599 with open(fname) as thefile:
2609 with open(fname) as thefile:
2600 pass
2610 pass
2601 except:
2611 except:
2602 warn('Could not open file <%s> for safe execution.' % fname)
2612 warn('Could not open file <%s> for safe execution.' % fname)
2603 return
2613 return
2604
2614
2605 # Find things also in current directory. This is needed to mimic the
2615 # Find things also in current directory. This is needed to mimic the
2606 # behavior of running a script from the system command line, where
2616 # behavior of running a script from the system command line, where
2607 # Python inserts the script's directory into sys.path
2617 # Python inserts the script's directory into sys.path
2608 dname = os.path.dirname(fname)
2618 dname = os.path.dirname(fname)
2609
2619
2610 with prepended_to_syspath(dname):
2620 with prepended_to_syspath(dname):
2611 try:
2621 try:
2612 glob, loc = (where + (None, ))[:2]
2622 glob, loc = (where + (None, ))[:2]
2613 py3compat.execfile(
2623 py3compat.execfile(
2614 fname, glob, loc,
2624 fname, glob, loc,
2615 self.compile if kw['shell_futures'] else None)
2625 self.compile if kw['shell_futures'] else None)
2616 except SystemExit as status:
2626 except SystemExit as status:
2617 # If the call was made with 0 or None exit status (sys.exit(0)
2627 # If the call was made with 0 or None exit status (sys.exit(0)
2618 # or sys.exit() ), don't bother showing a traceback, as both of
2628 # or sys.exit() ), don't bother showing a traceback, as both of
2619 # these are considered normal by the OS:
2629 # these are considered normal by the OS:
2620 # > python -c'import sys;sys.exit(0)'; echo $?
2630 # > python -c'import sys;sys.exit(0)'; echo $?
2621 # 0
2631 # 0
2622 # > python -c'import sys;sys.exit()'; echo $?
2632 # > python -c'import sys;sys.exit()'; echo $?
2623 # 0
2633 # 0
2624 # For other exit status, we show the exception unless
2634 # For other exit status, we show the exception unless
2625 # explicitly silenced, but only in short form.
2635 # explicitly silenced, but only in short form.
2626 if kw['raise_exceptions']:
2636 if kw['raise_exceptions']:
2627 raise
2637 raise
2628 if status.code and not kw['exit_ignore']:
2638 if status.code and not kw['exit_ignore']:
2629 self.showtraceback(exception_only=True)
2639 self.showtraceback(exception_only=True)
2630 except:
2640 except:
2631 if kw['raise_exceptions']:
2641 if kw['raise_exceptions']:
2632 raise
2642 raise
2633 # tb offset is 2 because we wrap execfile
2643 # tb offset is 2 because we wrap execfile
2634 self.showtraceback(tb_offset=2)
2644 self.showtraceback(tb_offset=2)
2635
2645
2636 def safe_execfile_ipy(self, fname, shell_futures=False):
2646 def safe_execfile_ipy(self, fname, shell_futures=False):
2637 """Like safe_execfile, but for .ipy or .ipynb files with IPython syntax.
2647 """Like safe_execfile, but for .ipy or .ipynb files with IPython syntax.
2638
2648
2639 Parameters
2649 Parameters
2640 ----------
2650 ----------
2641 fname : str
2651 fname : str
2642 The name of the file to execute. The filename must have a
2652 The name of the file to execute. The filename must have a
2643 .ipy or .ipynb extension.
2653 .ipy or .ipynb extension.
2644 shell_futures : bool (False)
2654 shell_futures : bool (False)
2645 If True, the code will share future statements with the interactive
2655 If True, the code will share future statements with the interactive
2646 shell. It will both be affected by previous __future__ imports, and
2656 shell. It will both be affected by previous __future__ imports, and
2647 any __future__ imports in the code will affect the shell. If False,
2657 any __future__ imports in the code will affect the shell. If False,
2648 __future__ imports are not shared in either direction.
2658 __future__ imports are not shared in either direction.
2649 """
2659 """
2650 fname = os.path.abspath(os.path.expanduser(fname))
2660 fname = os.path.abspath(os.path.expanduser(fname))
2651
2661
2652 # Make sure we can open the file
2662 # Make sure we can open the file
2653 try:
2663 try:
2654 with open(fname) as thefile:
2664 with open(fname) as thefile:
2655 pass
2665 pass
2656 except:
2666 except:
2657 warn('Could not open file <%s> for safe execution.' % fname)
2667 warn('Could not open file <%s> for safe execution.' % fname)
2658 return
2668 return
2659
2669
2660 # Find things also in current directory. This is needed to mimic the
2670 # Find things also in current directory. This is needed to mimic the
2661 # behavior of running a script from the system command line, where
2671 # behavior of running a script from the system command line, where
2662 # Python inserts the script's directory into sys.path
2672 # Python inserts the script's directory into sys.path
2663 dname = os.path.dirname(fname)
2673 dname = os.path.dirname(fname)
2664
2674
2665 def get_cells():
2675 def get_cells():
2666 """generator for sequence of code blocks to run"""
2676 """generator for sequence of code blocks to run"""
2667 if fname.endswith('.ipynb'):
2677 if fname.endswith('.ipynb'):
2668 from IPython.nbformat import read
2678 from IPython.nbformat import read
2669 with io_open(fname) as f:
2679 with io_open(fname) as f:
2670 nb = read(f, as_version=4)
2680 nb = read(f, as_version=4)
2671 if not nb.cells:
2681 if not nb.cells:
2672 return
2682 return
2673 for cell in nb.cells:
2683 for cell in nb.cells:
2674 if cell.cell_type == 'code':
2684 if cell.cell_type == 'code':
2675 yield cell.source
2685 yield cell.source
2676 else:
2686 else:
2677 with open(fname) as f:
2687 with open(fname) as f:
2678 yield f.read()
2688 yield f.read()
2679
2689
2680 with prepended_to_syspath(dname):
2690 with prepended_to_syspath(dname):
2681 try:
2691 try:
2682 for cell in get_cells():
2692 for cell in get_cells():
2683 # self.run_cell currently captures all exceptions
2693 # self.run_cell currently captures all exceptions
2684 # raised in user code. It would be nice if there were
2694 # raised in user code. It would be nice if there were
2685 # versions of run_cell that did raise, so
2695 # versions of run_cell that did raise, so
2686 # we could catch the errors.
2696 # we could catch the errors.
2687 self.run_cell(cell, silent=True, shell_futures=shell_futures)
2697 self.run_cell(cell, silent=True, shell_futures=shell_futures)
2688 except:
2698 except:
2689 self.showtraceback()
2699 self.showtraceback()
2690 warn('Unknown failure executing file: <%s>' % fname)
2700 warn('Unknown failure executing file: <%s>' % fname)
2691
2701
2692 def safe_run_module(self, mod_name, where):
2702 def safe_run_module(self, mod_name, where):
2693 """A safe version of runpy.run_module().
2703 """A safe version of runpy.run_module().
2694
2704
2695 This version will never throw an exception, but instead print
2705 This version will never throw an exception, but instead print
2696 helpful error messages to the screen.
2706 helpful error messages to the screen.
2697
2707
2698 `SystemExit` exceptions with status code 0 or None are ignored.
2708 `SystemExit` exceptions with status code 0 or None are ignored.
2699
2709
2700 Parameters
2710 Parameters
2701 ----------
2711 ----------
2702 mod_name : string
2712 mod_name : string
2703 The name of the module to be executed.
2713 The name of the module to be executed.
2704 where : dict
2714 where : dict
2705 The globals namespace.
2715 The globals namespace.
2706 """
2716 """
2707 try:
2717 try:
2708 try:
2718 try:
2709 where.update(
2719 where.update(
2710 runpy.run_module(str(mod_name), run_name="__main__",
2720 runpy.run_module(str(mod_name), run_name="__main__",
2711 alter_sys=True)
2721 alter_sys=True)
2712 )
2722 )
2713 except SystemExit as status:
2723 except SystemExit as status:
2714 if status.code:
2724 if status.code:
2715 raise
2725 raise
2716 except:
2726 except:
2717 self.showtraceback()
2727 self.showtraceback()
2718 warn('Unknown failure executing module: <%s>' % mod_name)
2728 warn('Unknown failure executing module: <%s>' % mod_name)
2719
2729
2720 def _run_cached_cell_magic(self, magic_name, line):
2730 def _run_cached_cell_magic(self, magic_name, line):
2721 """Special method to call a cell magic with the data stored in self.
2731 """Special method to call a cell magic with the data stored in self.
2722 """
2732 """
2723 cell = self._current_cell_magic_body
2733 cell = self._current_cell_magic_body
2724 self._current_cell_magic_body = None
2734 self._current_cell_magic_body = None
2725 return self.run_cell_magic(magic_name, line, cell)
2735 return self.run_cell_magic(magic_name, line, cell)
2726
2736
2727 def run_cell(self, raw_cell, store_history=False, silent=False, shell_futures=True):
2737 def run_cell(self, raw_cell, store_history=False, silent=False, shell_futures=True):
2728 """Run a complete IPython cell.
2738 """Run a complete IPython cell.
2729
2739
2730 Parameters
2740 Parameters
2731 ----------
2741 ----------
2732 raw_cell : str
2742 raw_cell : str
2733 The code (including IPython code such as %magic functions) to run.
2743 The code (including IPython code such as %magic functions) to run.
2734 store_history : bool
2744 store_history : bool
2735 If True, the raw and translated cell will be stored in IPython's
2745 If True, the raw and translated cell will be stored in IPython's
2736 history. For user code calling back into IPython's machinery, this
2746 history. For user code calling back into IPython's machinery, this
2737 should be set to False.
2747 should be set to False.
2738 silent : bool
2748 silent : bool
2739 If True, avoid side-effects, such as implicit displayhooks and
2749 If True, avoid side-effects, such as implicit displayhooks and
2740 and logging. silent=True forces store_history=False.
2750 and logging. silent=True forces store_history=False.
2741 shell_futures : bool
2751 shell_futures : bool
2742 If True, the code will share future statements with the interactive
2752 If True, the code will share future statements with the interactive
2743 shell. It will both be affected by previous __future__ imports, and
2753 shell. It will both be affected by previous __future__ imports, and
2744 any __future__ imports in the code will affect the shell. If False,
2754 any __future__ imports in the code will affect the shell. If False,
2745 __future__ imports are not shared in either direction.
2755 __future__ imports are not shared in either direction.
2746 """
2756 """
2747 if (not raw_cell) or raw_cell.isspace():
2757 if (not raw_cell) or raw_cell.isspace():
2748 return
2758 return
2749
2759
2750 if silent:
2760 if silent:
2751 store_history = False
2761 store_history = False
2752
2762
2753 self.events.trigger('pre_execute')
2763 self.events.trigger('pre_execute')
2754 if not silent:
2764 if not silent:
2755 self.events.trigger('pre_run_cell')
2765 self.events.trigger('pre_run_cell')
2756
2766
2757 # If any of our input transformation (input_transformer_manager or
2767 # If any of our input transformation (input_transformer_manager or
2758 # prefilter_manager) raises an exception, we store it in this variable
2768 # prefilter_manager) raises an exception, we store it in this variable
2759 # so that we can display the error after logging the input and storing
2769 # so that we can display the error after logging the input and storing
2760 # it in the history.
2770 # it in the history.
2761 preprocessing_exc_tuple = None
2771 preprocessing_exc_tuple = None
2762 try:
2772 try:
2763 # Static input transformations
2773 # Static input transformations
2764 cell = self.input_transformer_manager.transform_cell(raw_cell)
2774 cell = self.input_transformer_manager.transform_cell(raw_cell)
2765 except SyntaxError:
2775 except SyntaxError:
2766 preprocessing_exc_tuple = sys.exc_info()
2776 preprocessing_exc_tuple = sys.exc_info()
2767 cell = raw_cell # cell has to exist so it can be stored/logged
2777 cell = raw_cell # cell has to exist so it can be stored/logged
2768 else:
2778 else:
2769 if len(cell.splitlines()) == 1:
2779 if len(cell.splitlines()) == 1:
2770 # Dynamic transformations - only applied for single line commands
2780 # Dynamic transformations - only applied for single line commands
2771 with self.builtin_trap:
2781 with self.builtin_trap:
2772 try:
2782 try:
2773 # use prefilter_lines to handle trailing newlines
2783 # use prefilter_lines to handle trailing newlines
2774 # restore trailing newline for ast.parse
2784 # restore trailing newline for ast.parse
2775 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
2785 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
2776 except Exception:
2786 except Exception:
2777 # don't allow prefilter errors to crash IPython
2787 # don't allow prefilter errors to crash IPython
2778 preprocessing_exc_tuple = sys.exc_info()
2788 preprocessing_exc_tuple = sys.exc_info()
2779
2789
2780 # Store raw and processed history
2790 # Store raw and processed history
2781 if store_history:
2791 if store_history:
2782 self.history_manager.store_inputs(self.execution_count,
2792 self.history_manager.store_inputs(self.execution_count,
2783 cell, raw_cell)
2793 cell, raw_cell)
2784 if not silent:
2794 if not silent:
2785 self.logger.log(cell, raw_cell)
2795 self.logger.log(cell, raw_cell)
2786
2796
2787 # Display the exception if input processing failed.
2797 # Display the exception if input processing failed.
2788 if preprocessing_exc_tuple is not None:
2798 if preprocessing_exc_tuple is not None:
2789 self.showtraceback(preprocessing_exc_tuple)
2799 self.showtraceback(preprocessing_exc_tuple)
2790 if store_history:
2800 if store_history:
2791 self.execution_count += 1
2801 self.execution_count += 1
2792 return
2802 return
2793
2803
2794 # Our own compiler remembers the __future__ environment. If we want to
2804 # Our own compiler remembers the __future__ environment. If we want to
2795 # run code with a separate __future__ environment, use the default
2805 # run code with a separate __future__ environment, use the default
2796 # compiler
2806 # compiler
2797 compiler = self.compile if shell_futures else CachingCompiler()
2807 compiler = self.compile if shell_futures else CachingCompiler()
2798
2808
2799 with self.builtin_trap:
2809 with self.builtin_trap:
2800 cell_name = self.compile.cache(cell, self.execution_count)
2810 cell_name = self.compile.cache(cell, self.execution_count)
2801
2811
2802 with self.display_trap:
2812 with self.display_trap:
2803 # Compile to bytecode
2813 # Compile to bytecode
2804 try:
2814 try:
2805 code_ast = compiler.ast_parse(cell, filename=cell_name)
2815 code_ast = compiler.ast_parse(cell, filename=cell_name)
2806 except IndentationError:
2816 except IndentationError:
2807 self.showindentationerror()
2817 self.showindentationerror()
2808 if store_history:
2818 if store_history:
2809 self.execution_count += 1
2819 self.execution_count += 1
2810 return None
2820 return None
2811 except (OverflowError, SyntaxError, ValueError, TypeError,
2821 except (OverflowError, SyntaxError, ValueError, TypeError,
2812 MemoryError):
2822 MemoryError):
2813 self.showsyntaxerror()
2823 self.showsyntaxerror()
2814 if store_history:
2824 if store_history:
2815 self.execution_count += 1
2825 self.execution_count += 1
2816 return None
2826 return None
2817
2827
2818 # Apply AST transformations
2828 # Apply AST transformations
2819 try:
2829 try:
2820 code_ast = self.transform_ast(code_ast)
2830 code_ast = self.transform_ast(code_ast)
2821 except InputRejected:
2831 except InputRejected:
2822 self.showtraceback()
2832 self.showtraceback()
2823 if store_history:
2833 if store_history:
2824 self.execution_count += 1
2834 self.execution_count += 1
2825 return None
2835 return None
2826
2836
2827 # Execute the user code
2837 # Execute the user code
2828 interactivity = "none" if silent else self.ast_node_interactivity
2838 interactivity = "none" if silent else self.ast_node_interactivity
2829 self.run_ast_nodes(code_ast.body, cell_name,
2839 self.run_ast_nodes(code_ast.body, cell_name,
2830 interactivity=interactivity, compiler=compiler)
2840 interactivity=interactivity, compiler=compiler)
2831
2841
2832 self.events.trigger('post_execute')
2842 self.events.trigger('post_execute')
2833 if not silent:
2843 if not silent:
2834 self.events.trigger('post_run_cell')
2844 self.events.trigger('post_run_cell')
2835
2845
2836 if store_history:
2846 if store_history:
2837 # Write output to the database. Does nothing unless
2847 # Write output to the database. Does nothing unless
2838 # history output logging is enabled.
2848 # history output logging is enabled.
2839 self.history_manager.store_output(self.execution_count)
2849 self.history_manager.store_output(self.execution_count)
2840 # Each cell is a *single* input, regardless of how many lines it has
2850 # Each cell is a *single* input, regardless of how many lines it has
2841 self.execution_count += 1
2851 self.execution_count += 1
2842
2852
2843 def transform_ast(self, node):
2853 def transform_ast(self, node):
2844 """Apply the AST transformations from self.ast_transformers
2854 """Apply the AST transformations from self.ast_transformers
2845
2855
2846 Parameters
2856 Parameters
2847 ----------
2857 ----------
2848 node : ast.Node
2858 node : ast.Node
2849 The root node to be transformed. Typically called with the ast.Module
2859 The root node to be transformed. Typically called with the ast.Module
2850 produced by parsing user input.
2860 produced by parsing user input.
2851
2861
2852 Returns
2862 Returns
2853 -------
2863 -------
2854 An ast.Node corresponding to the node it was called with. Note that it
2864 An ast.Node corresponding to the node it was called with. Note that it
2855 may also modify the passed object, so don't rely on references to the
2865 may also modify the passed object, so don't rely on references to the
2856 original AST.
2866 original AST.
2857 """
2867 """
2858 for transformer in self.ast_transformers:
2868 for transformer in self.ast_transformers:
2859 try:
2869 try:
2860 node = transformer.visit(node)
2870 node = transformer.visit(node)
2861 except InputRejected:
2871 except InputRejected:
2862 # User-supplied AST transformers can reject an input by raising
2872 # User-supplied AST transformers can reject an input by raising
2863 # an InputRejected. Short-circuit in this case so that we
2873 # an InputRejected. Short-circuit in this case so that we
2864 # don't unregister the transform.
2874 # don't unregister the transform.
2865 raise
2875 raise
2866 except Exception:
2876 except Exception:
2867 warn("AST transformer %r threw an error. It will be unregistered." % transformer)
2877 warn("AST transformer %r threw an error. It will be unregistered." % transformer)
2868 self.ast_transformers.remove(transformer)
2878 self.ast_transformers.remove(transformer)
2869
2879
2870 if self.ast_transformers:
2880 if self.ast_transformers:
2871 ast.fix_missing_locations(node)
2881 ast.fix_missing_locations(node)
2872 return node
2882 return node
2873
2883
2874
2884
2875 def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr',
2885 def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr',
2876 compiler=compile):
2886 compiler=compile):
2877 """Run a sequence of AST nodes. The execution mode depends on the
2887 """Run a sequence of AST nodes. The execution mode depends on the
2878 interactivity parameter.
2888 interactivity parameter.
2879
2889
2880 Parameters
2890 Parameters
2881 ----------
2891 ----------
2882 nodelist : list
2892 nodelist : list
2883 A sequence of AST nodes to run.
2893 A sequence of AST nodes to run.
2884 cell_name : str
2894 cell_name : str
2885 Will be passed to the compiler as the filename of the cell. Typically
2895 Will be passed to the compiler as the filename of the cell. Typically
2886 the value returned by ip.compile.cache(cell).
2896 the value returned by ip.compile.cache(cell).
2887 interactivity : str
2897 interactivity : str
2888 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
2898 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
2889 run interactively (displaying output from expressions). 'last_expr'
2899 run interactively (displaying output from expressions). 'last_expr'
2890 will run the last node interactively only if it is an expression (i.e.
2900 will run the last node interactively only if it is an expression (i.e.
2891 expressions in loops or other blocks are not displayed. Other values
2901 expressions in loops or other blocks are not displayed. Other values
2892 for this parameter will raise a ValueError.
2902 for this parameter will raise a ValueError.
2893 compiler : callable
2903 compiler : callable
2894 A function with the same interface as the built-in compile(), to turn
2904 A function with the same interface as the built-in compile(), to turn
2895 the AST nodes into code objects. Default is the built-in compile().
2905 the AST nodes into code objects. Default is the built-in compile().
2896 """
2906 """
2897 if not nodelist:
2907 if not nodelist:
2898 return
2908 return
2899
2909
2900 if interactivity == 'last_expr':
2910 if interactivity == 'last_expr':
2901 if isinstance(nodelist[-1], ast.Expr):
2911 if isinstance(nodelist[-1], ast.Expr):
2902 interactivity = "last"
2912 interactivity = "last"
2903 else:
2913 else:
2904 interactivity = "none"
2914 interactivity = "none"
2905
2915
2906 if interactivity == 'none':
2916 if interactivity == 'none':
2907 to_run_exec, to_run_interactive = nodelist, []
2917 to_run_exec, to_run_interactive = nodelist, []
2908 elif interactivity == 'last':
2918 elif interactivity == 'last':
2909 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
2919 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
2910 elif interactivity == 'all':
2920 elif interactivity == 'all':
2911 to_run_exec, to_run_interactive = [], nodelist
2921 to_run_exec, to_run_interactive = [], nodelist
2912 else:
2922 else:
2913 raise ValueError("Interactivity was %r" % interactivity)
2923 raise ValueError("Interactivity was %r" % interactivity)
2914
2924
2915 exec_count = self.execution_count
2925 exec_count = self.execution_count
2916
2926
2917 try:
2927 try:
2918 for i, node in enumerate(to_run_exec):
2928 for i, node in enumerate(to_run_exec):
2919 mod = ast.Module([node])
2929 mod = ast.Module([node])
2920 code = compiler(mod, cell_name, "exec")
2930 code = compiler(mod, cell_name, "exec")
2921 if self.run_code(code):
2931 if self.run_code(code):
2922 return True
2932 return True
2923
2933
2924 for i, node in enumerate(to_run_interactive):
2934 for i, node in enumerate(to_run_interactive):
2925 mod = ast.Interactive([node])
2935 mod = ast.Interactive([node])
2926 code = compiler(mod, cell_name, "single")
2936 code = compiler(mod, cell_name, "single")
2927 if self.run_code(code):
2937 if self.run_code(code):
2928 return True
2938 return True
2929
2939
2930 # Flush softspace
2940 # Flush softspace
2931 if softspace(sys.stdout, 0):
2941 if softspace(sys.stdout, 0):
2932 print()
2942 print()
2933
2943
2934 except:
2944 except:
2935 # It's possible to have exceptions raised here, typically by
2945 # It's possible to have exceptions raised here, typically by
2936 # compilation of odd code (such as a naked 'return' outside a
2946 # compilation of odd code (such as a naked 'return' outside a
2937 # function) that did parse but isn't valid. Typically the exception
2947 # function) that did parse but isn't valid. Typically the exception
2938 # is a SyntaxError, but it's safest just to catch anything and show
2948 # is a SyntaxError, but it's safest just to catch anything and show
2939 # the user a traceback.
2949 # the user a traceback.
2940
2950
2941 # We do only one try/except outside the loop to minimize the impact
2951 # We do only one try/except outside the loop to minimize the impact
2942 # on runtime, and also because if any node in the node list is
2952 # on runtime, and also because if any node in the node list is
2943 # broken, we should stop execution completely.
2953 # broken, we should stop execution completely.
2944 self.showtraceback()
2954 self.showtraceback()
2945
2955
2946 return False
2956 return False
2947
2957
2948 def run_code(self, code_obj):
2958 def run_code(self, code_obj):
2949 """Execute a code object.
2959 """Execute a code object.
2950
2960
2951 When an exception occurs, self.showtraceback() is called to display a
2961 When an exception occurs, self.showtraceback() is called to display a
2952 traceback.
2962 traceback.
2953
2963
2954 Parameters
2964 Parameters
2955 ----------
2965 ----------
2956 code_obj : code object
2966 code_obj : code object
2957 A compiled code object, to be executed
2967 A compiled code object, to be executed
2958
2968
2959 Returns
2969 Returns
2960 -------
2970 -------
2961 False : successful execution.
2971 False : successful execution.
2962 True : an error occurred.
2972 True : an error occurred.
2963 """
2973 """
2964 # Set our own excepthook in case the user code tries to call it
2974 # Set our own excepthook in case the user code tries to call it
2965 # directly, so that the IPython crash handler doesn't get triggered
2975 # directly, so that the IPython crash handler doesn't get triggered
2966 old_excepthook, sys.excepthook = sys.excepthook, self.excepthook
2976 old_excepthook, sys.excepthook = sys.excepthook, self.excepthook
2967
2977
2968 # we save the original sys.excepthook in the instance, in case config
2978 # we save the original sys.excepthook in the instance, in case config
2969 # code (such as magics) needs access to it.
2979 # code (such as magics) needs access to it.
2970 self.sys_excepthook = old_excepthook
2980 self.sys_excepthook = old_excepthook
2971 outflag = 1 # happens in more places, so it's easier as default
2981 outflag = 1 # happens in more places, so it's easier as default
2972 try:
2982 try:
2973 try:
2983 try:
2974 self.hooks.pre_run_code_hook()
2984 self.hooks.pre_run_code_hook()
2975 #rprint('Running code', repr(code_obj)) # dbg
2985 #rprint('Running code', repr(code_obj)) # dbg
2976 exec(code_obj, self.user_global_ns, self.user_ns)
2986 exec(code_obj, self.user_global_ns, self.user_ns)
2977 finally:
2987 finally:
2978 # Reset our crash handler in place
2988 # Reset our crash handler in place
2979 sys.excepthook = old_excepthook
2989 sys.excepthook = old_excepthook
2980 except SystemExit:
2990 except SystemExit:
2981 self.showtraceback(exception_only=True)
2991 self.showtraceback(exception_only=True)
2982 warn("To exit: use 'exit', 'quit', or Ctrl-D.", level=1)
2992 warn("To exit: use 'exit', 'quit', or Ctrl-D.", level=1)
2983 except self.custom_exceptions:
2993 except self.custom_exceptions:
2984 etype, value, tb = sys.exc_info()
2994 etype, value, tb = sys.exc_info()
2985 self.CustomTB(etype, value, tb)
2995 self.CustomTB(etype, value, tb)
2986 except:
2996 except:
2987 self.showtraceback()
2997 self.showtraceback()
2988 else:
2998 else:
2989 outflag = 0
2999 outflag = 0
2990 return outflag
3000 return outflag
2991
3001
2992 # For backwards compatibility
3002 # For backwards compatibility
2993 runcode = run_code
3003 runcode = run_code
2994
3004
2995 #-------------------------------------------------------------------------
3005 #-------------------------------------------------------------------------
2996 # Things related to GUI support and pylab
3006 # Things related to GUI support and pylab
2997 #-------------------------------------------------------------------------
3007 #-------------------------------------------------------------------------
2998
3008
2999 def enable_gui(self, gui=None):
3009 def enable_gui(self, gui=None):
3000 raise NotImplementedError('Implement enable_gui in a subclass')
3010 raise NotImplementedError('Implement enable_gui in a subclass')
3001
3011
3002 def enable_matplotlib(self, gui=None):
3012 def enable_matplotlib(self, gui=None):
3003 """Enable interactive matplotlib and inline figure support.
3013 """Enable interactive matplotlib and inline figure support.
3004
3014
3005 This takes the following steps:
3015 This takes the following steps:
3006
3016
3007 1. select the appropriate eventloop and matplotlib backend
3017 1. select the appropriate eventloop and matplotlib backend
3008 2. set up matplotlib for interactive use with that backend
3018 2. set up matplotlib for interactive use with that backend
3009 3. configure formatters for inline figure display
3019 3. configure formatters for inline figure display
3010 4. enable the selected gui eventloop
3020 4. enable the selected gui eventloop
3011
3021
3012 Parameters
3022 Parameters
3013 ----------
3023 ----------
3014 gui : optional, string
3024 gui : optional, string
3015 If given, dictates the choice of matplotlib GUI backend to use
3025 If given, dictates the choice of matplotlib GUI backend to use
3016 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
3026 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
3017 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
3027 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
3018 matplotlib (as dictated by the matplotlib build-time options plus the
3028 matplotlib (as dictated by the matplotlib build-time options plus the
3019 user's matplotlibrc configuration file). Note that not all backends
3029 user's matplotlibrc configuration file). Note that not all backends
3020 make sense in all contexts, for example a terminal ipython can't
3030 make sense in all contexts, for example a terminal ipython can't
3021 display figures inline.
3031 display figures inline.
3022 """
3032 """
3023 from IPython.core import pylabtools as pt
3033 from IPython.core import pylabtools as pt
3024 gui, backend = pt.find_gui_and_backend(gui, self.pylab_gui_select)
3034 gui, backend = pt.find_gui_and_backend(gui, self.pylab_gui_select)
3025
3035
3026 if gui != 'inline':
3036 if gui != 'inline':
3027 # If we have our first gui selection, store it
3037 # If we have our first gui selection, store it
3028 if self.pylab_gui_select is None:
3038 if self.pylab_gui_select is None:
3029 self.pylab_gui_select = gui
3039 self.pylab_gui_select = gui
3030 # Otherwise if they are different
3040 # Otherwise if they are different
3031 elif gui != self.pylab_gui_select:
3041 elif gui != self.pylab_gui_select:
3032 print ('Warning: Cannot change to a different GUI toolkit: %s.'
3042 print ('Warning: Cannot change to a different GUI toolkit: %s.'
3033 ' Using %s instead.' % (gui, self.pylab_gui_select))
3043 ' Using %s instead.' % (gui, self.pylab_gui_select))
3034 gui, backend = pt.find_gui_and_backend(self.pylab_gui_select)
3044 gui, backend = pt.find_gui_and_backend(self.pylab_gui_select)
3035
3045
3036 pt.activate_matplotlib(backend)
3046 pt.activate_matplotlib(backend)
3037 pt.configure_inline_support(self, backend)
3047 pt.configure_inline_support(self, backend)
3038
3048
3039 # Now we must activate the gui pylab wants to use, and fix %run to take
3049 # Now we must activate the gui pylab wants to use, and fix %run to take
3040 # plot updates into account
3050 # plot updates into account
3041 self.enable_gui(gui)
3051 self.enable_gui(gui)
3042 self.magics_manager.registry['ExecutionMagics'].default_runner = \
3052 self.magics_manager.registry['ExecutionMagics'].default_runner = \
3043 pt.mpl_runner(self.safe_execfile)
3053 pt.mpl_runner(self.safe_execfile)
3044
3054
3045 return gui, backend
3055 return gui, backend
3046
3056
3047 def enable_pylab(self, gui=None, import_all=True, welcome_message=False):
3057 def enable_pylab(self, gui=None, import_all=True, welcome_message=False):
3048 """Activate pylab support at runtime.
3058 """Activate pylab support at runtime.
3049
3059
3050 This turns on support for matplotlib, preloads into the interactive
3060 This turns on support for matplotlib, preloads into the interactive
3051 namespace all of numpy and pylab, and configures IPython to correctly
3061 namespace all of numpy and pylab, and configures IPython to correctly
3052 interact with the GUI event loop. The GUI backend to be used can be
3062 interact with the GUI event loop. The GUI backend to be used can be
3053 optionally selected with the optional ``gui`` argument.
3063 optionally selected with the optional ``gui`` argument.
3054
3064
3055 This method only adds preloading the namespace to InteractiveShell.enable_matplotlib.
3065 This method only adds preloading the namespace to InteractiveShell.enable_matplotlib.
3056
3066
3057 Parameters
3067 Parameters
3058 ----------
3068 ----------
3059 gui : optional, string
3069 gui : optional, string
3060 If given, dictates the choice of matplotlib GUI backend to use
3070 If given, dictates the choice of matplotlib GUI backend to use
3061 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
3071 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
3062 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
3072 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
3063 matplotlib (as dictated by the matplotlib build-time options plus the
3073 matplotlib (as dictated by the matplotlib build-time options plus the
3064 user's matplotlibrc configuration file). Note that not all backends
3074 user's matplotlibrc configuration file). Note that not all backends
3065 make sense in all contexts, for example a terminal ipython can't
3075 make sense in all contexts, for example a terminal ipython can't
3066 display figures inline.
3076 display figures inline.
3067 import_all : optional, bool, default: True
3077 import_all : optional, bool, default: True
3068 Whether to do `from numpy import *` and `from pylab import *`
3078 Whether to do `from numpy import *` and `from pylab import *`
3069 in addition to module imports.
3079 in addition to module imports.
3070 welcome_message : deprecated
3080 welcome_message : deprecated
3071 This argument is ignored, no welcome message will be displayed.
3081 This argument is ignored, no welcome message will be displayed.
3072 """
3082 """
3073 from IPython.core.pylabtools import import_pylab
3083 from IPython.core.pylabtools import import_pylab
3074
3084
3075 gui, backend = self.enable_matplotlib(gui)
3085 gui, backend = self.enable_matplotlib(gui)
3076
3086
3077 # We want to prevent the loading of pylab to pollute the user's
3087 # We want to prevent the loading of pylab to pollute the user's
3078 # namespace as shown by the %who* magics, so we execute the activation
3088 # namespace as shown by the %who* magics, so we execute the activation
3079 # code in an empty namespace, and we update *both* user_ns and
3089 # code in an empty namespace, and we update *both* user_ns and
3080 # user_ns_hidden with this information.
3090 # user_ns_hidden with this information.
3081 ns = {}
3091 ns = {}
3082 import_pylab(ns, import_all)
3092 import_pylab(ns, import_all)
3083 # warn about clobbered names
3093 # warn about clobbered names
3084 ignored = set(["__builtins__"])
3094 ignored = set(["__builtins__"])
3085 both = set(ns).intersection(self.user_ns).difference(ignored)
3095 both = set(ns).intersection(self.user_ns).difference(ignored)
3086 clobbered = [ name for name in both if self.user_ns[name] is not ns[name] ]
3096 clobbered = [ name for name in both if self.user_ns[name] is not ns[name] ]
3087 self.user_ns.update(ns)
3097 self.user_ns.update(ns)
3088 self.user_ns_hidden.update(ns)
3098 self.user_ns_hidden.update(ns)
3089 return gui, backend, clobbered
3099 return gui, backend, clobbered
3090
3100
3091 #-------------------------------------------------------------------------
3101 #-------------------------------------------------------------------------
3092 # Utilities
3102 # Utilities
3093 #-------------------------------------------------------------------------
3103 #-------------------------------------------------------------------------
3094
3104
3095 def var_expand(self, cmd, depth=0, formatter=DollarFormatter()):
3105 def var_expand(self, cmd, depth=0, formatter=DollarFormatter()):
3096 """Expand python variables in a string.
3106 """Expand python variables in a string.
3097
3107
3098 The depth argument indicates how many frames above the caller should
3108 The depth argument indicates how many frames above the caller should
3099 be walked to look for the local namespace where to expand variables.
3109 be walked to look for the local namespace where to expand variables.
3100
3110
3101 The global namespace for expansion is always the user's interactive
3111 The global namespace for expansion is always the user's interactive
3102 namespace.
3112 namespace.
3103 """
3113 """
3104 ns = self.user_ns.copy()
3114 ns = self.user_ns.copy()
3105 try:
3115 try:
3106 frame = sys._getframe(depth+1)
3116 frame = sys._getframe(depth+1)
3107 except ValueError:
3117 except ValueError:
3108 # This is thrown if there aren't that many frames on the stack,
3118 # This is thrown if there aren't that many frames on the stack,
3109 # e.g. if a script called run_line_magic() directly.
3119 # e.g. if a script called run_line_magic() directly.
3110 pass
3120 pass
3111 else:
3121 else:
3112 ns.update(frame.f_locals)
3122 ns.update(frame.f_locals)
3113
3123
3114 try:
3124 try:
3115 # We have to use .vformat() here, because 'self' is a valid and common
3125 # We have to use .vformat() here, because 'self' is a valid and common
3116 # name, and expanding **ns for .format() would make it collide with
3126 # name, and expanding **ns for .format() would make it collide with
3117 # the 'self' argument of the method.
3127 # the 'self' argument of the method.
3118 cmd = formatter.vformat(cmd, args=[], kwargs=ns)
3128 cmd = formatter.vformat(cmd, args=[], kwargs=ns)
3119 except Exception:
3129 except Exception:
3120 # if formatter couldn't format, just let it go untransformed
3130 # if formatter couldn't format, just let it go untransformed
3121 pass
3131 pass
3122 return cmd
3132 return cmd
3123
3133
3124 def mktempfile(self, data=None, prefix='ipython_edit_'):
3134 def mktempfile(self, data=None, prefix='ipython_edit_'):
3125 """Make a new tempfile and return its filename.
3135 """Make a new tempfile and return its filename.
3126
3136
3127 This makes a call to tempfile.mkstemp (created in a tempfile.mkdtemp),
3137 This makes a call to tempfile.mkstemp (created in a tempfile.mkdtemp),
3128 but it registers the created filename internally so ipython cleans it up
3138 but it registers the created filename internally so ipython cleans it up
3129 at exit time.
3139 at exit time.
3130
3140
3131 Optional inputs:
3141 Optional inputs:
3132
3142
3133 - data(None): if data is given, it gets written out to the temp file
3143 - data(None): if data is given, it gets written out to the temp file
3134 immediately, and the file is closed again."""
3144 immediately, and the file is closed again."""
3135
3145
3136 dirname = tempfile.mkdtemp(prefix=prefix)
3146 dirname = tempfile.mkdtemp(prefix=prefix)
3137 self.tempdirs.append(dirname)
3147 self.tempdirs.append(dirname)
3138
3148
3139 handle, filename = tempfile.mkstemp('.py', prefix, dir=dirname)
3149 handle, filename = tempfile.mkstemp('.py', prefix, dir=dirname)
3140 os.close(handle) # On Windows, there can only be one open handle on a file
3150 os.close(handle) # On Windows, there can only be one open handle on a file
3141 self.tempfiles.append(filename)
3151 self.tempfiles.append(filename)
3142
3152
3143 if data:
3153 if data:
3144 tmp_file = open(filename,'w')
3154 tmp_file = open(filename,'w')
3145 tmp_file.write(data)
3155 tmp_file.write(data)
3146 tmp_file.close()
3156 tmp_file.close()
3147 return filename
3157 return filename
3148
3158
3149 # TODO: This should be removed when Term is refactored.
3159 # TODO: This should be removed when Term is refactored.
3150 def write(self,data):
3160 def write(self,data):
3151 """Write a string to the default output"""
3161 """Write a string to the default output"""
3152 io.stdout.write(data)
3162 io.stdout.write(data)
3153
3163
3154 # TODO: This should be removed when Term is refactored.
3164 # TODO: This should be removed when Term is refactored.
3155 def write_err(self,data):
3165 def write_err(self,data):
3156 """Write a string to the default error output"""
3166 """Write a string to the default error output"""
3157 io.stderr.write(data)
3167 io.stderr.write(data)
3158
3168
3159 def ask_yes_no(self, prompt, default=None):
3169 def ask_yes_no(self, prompt, default=None):
3160 if self.quiet:
3170 if self.quiet:
3161 return True
3171 return True
3162 return ask_yes_no(prompt,default)
3172 return ask_yes_no(prompt,default)
3163
3173
3164 def show_usage(self):
3174 def show_usage(self):
3165 """Show a usage message"""
3175 """Show a usage message"""
3166 page.page(IPython.core.usage.interactive_usage)
3176 page.page(IPython.core.usage.interactive_usage)
3167
3177
3168 def extract_input_lines(self, range_str, raw=False):
3178 def extract_input_lines(self, range_str, raw=False):
3169 """Return as a string a set of input history slices.
3179 """Return as a string a set of input history slices.
3170
3180
3171 Parameters
3181 Parameters
3172 ----------
3182 ----------
3173 range_str : string
3183 range_str : string
3174 The set of slices is given as a string, like "~5/6-~4/2 4:8 9",
3184 The set of slices is given as a string, like "~5/6-~4/2 4:8 9",
3175 since this function is for use by magic functions which get their
3185 since this function is for use by magic functions which get their
3176 arguments as strings. The number before the / is the session
3186 arguments as strings. The number before the / is the session
3177 number: ~n goes n back from the current session.
3187 number: ~n goes n back from the current session.
3178
3188
3179 raw : bool, optional
3189 raw : bool, optional
3180 By default, the processed input is used. If this is true, the raw
3190 By default, the processed input is used. If this is true, the raw
3181 input history is used instead.
3191 input history is used instead.
3182
3192
3183 Notes
3193 Notes
3184 -----
3194 -----
3185
3195
3186 Slices can be described with two notations:
3196 Slices can be described with two notations:
3187
3197
3188 * ``N:M`` -> standard python form, means including items N...(M-1).
3198 * ``N:M`` -> standard python form, means including items N...(M-1).
3189 * ``N-M`` -> include items N..M (closed endpoint).
3199 * ``N-M`` -> include items N..M (closed endpoint).
3190 """
3200 """
3191 lines = self.history_manager.get_range_by_str(range_str, raw=raw)
3201 lines = self.history_manager.get_range_by_str(range_str, raw=raw)
3192 return "\n".join(x for _, _, x in lines)
3202 return "\n".join(x for _, _, x in lines)
3193
3203
3194 def find_user_code(self, target, raw=True, py_only=False, skip_encoding_cookie=True, search_ns=False):
3204 def find_user_code(self, target, raw=True, py_only=False, skip_encoding_cookie=True, search_ns=False):
3195 """Get a code string from history, file, url, or a string or macro.
3205 """Get a code string from history, file, url, or a string or macro.
3196
3206
3197 This is mainly used by magic functions.
3207 This is mainly used by magic functions.
3198
3208
3199 Parameters
3209 Parameters
3200 ----------
3210 ----------
3201
3211
3202 target : str
3212 target : str
3203
3213
3204 A string specifying code to retrieve. This will be tried respectively
3214 A string specifying code to retrieve. This will be tried respectively
3205 as: ranges of input history (see %history for syntax), url,
3215 as: ranges of input history (see %history for syntax), url,
3206 correspnding .py file, filename, or an expression evaluating to a
3216 correspnding .py file, filename, or an expression evaluating to a
3207 string or Macro in the user namespace.
3217 string or Macro in the user namespace.
3208
3218
3209 raw : bool
3219 raw : bool
3210 If true (default), retrieve raw history. Has no effect on the other
3220 If true (default), retrieve raw history. Has no effect on the other
3211 retrieval mechanisms.
3221 retrieval mechanisms.
3212
3222
3213 py_only : bool (default False)
3223 py_only : bool (default False)
3214 Only try to fetch python code, do not try alternative methods to decode file
3224 Only try to fetch python code, do not try alternative methods to decode file
3215 if unicode fails.
3225 if unicode fails.
3216
3226
3217 Returns
3227 Returns
3218 -------
3228 -------
3219 A string of code.
3229 A string of code.
3220
3230
3221 ValueError is raised if nothing is found, and TypeError if it evaluates
3231 ValueError is raised if nothing is found, and TypeError if it evaluates
3222 to an object of another type. In each case, .args[0] is a printable
3232 to an object of another type. In each case, .args[0] is a printable
3223 message.
3233 message.
3224 """
3234 """
3225 code = self.extract_input_lines(target, raw=raw) # Grab history
3235 code = self.extract_input_lines(target, raw=raw) # Grab history
3226 if code:
3236 if code:
3227 return code
3237 return code
3228 utarget = unquote_filename(target)
3238 utarget = unquote_filename(target)
3229 try:
3239 try:
3230 if utarget.startswith(('http://', 'https://')):
3240 if utarget.startswith(('http://', 'https://')):
3231 return openpy.read_py_url(utarget, skip_encoding_cookie=skip_encoding_cookie)
3241 return openpy.read_py_url(utarget, skip_encoding_cookie=skip_encoding_cookie)
3232 except UnicodeDecodeError:
3242 except UnicodeDecodeError:
3233 if not py_only :
3243 if not py_only :
3234 # Deferred import
3244 # Deferred import
3235 try:
3245 try:
3236 from urllib.request import urlopen # Py3
3246 from urllib.request import urlopen # Py3
3237 except ImportError:
3247 except ImportError:
3238 from urllib import urlopen
3248 from urllib import urlopen
3239 response = urlopen(target)
3249 response = urlopen(target)
3240 return response.read().decode('latin1')
3250 return response.read().decode('latin1')
3241 raise ValueError(("'%s' seem to be unreadable.") % utarget)
3251 raise ValueError(("'%s' seem to be unreadable.") % utarget)
3242
3252
3243 potential_target = [target]
3253 potential_target = [target]
3244 try :
3254 try :
3245 potential_target.insert(0,get_py_filename(target))
3255 potential_target.insert(0,get_py_filename(target))
3246 except IOError:
3256 except IOError:
3247 pass
3257 pass
3248
3258
3249 for tgt in potential_target :
3259 for tgt in potential_target :
3250 if os.path.isfile(tgt): # Read file
3260 if os.path.isfile(tgt): # Read file
3251 try :
3261 try :
3252 return openpy.read_py_file(tgt, skip_encoding_cookie=skip_encoding_cookie)
3262 return openpy.read_py_file(tgt, skip_encoding_cookie=skip_encoding_cookie)
3253 except UnicodeDecodeError :
3263 except UnicodeDecodeError :
3254 if not py_only :
3264 if not py_only :
3255 with io_open(tgt,'r', encoding='latin1') as f :
3265 with io_open(tgt,'r', encoding='latin1') as f :
3256 return f.read()
3266 return f.read()
3257 raise ValueError(("'%s' seem to be unreadable.") % target)
3267 raise ValueError(("'%s' seem to be unreadable.") % target)
3258 elif os.path.isdir(os.path.expanduser(tgt)):
3268 elif os.path.isdir(os.path.expanduser(tgt)):
3259 raise ValueError("'%s' is a directory, not a regular file." % target)
3269 raise ValueError("'%s' is a directory, not a regular file." % target)
3260
3270
3261 if search_ns:
3271 if search_ns:
3262 # Inspect namespace to load object source
3272 # Inspect namespace to load object source
3263 object_info = self.object_inspect(target, detail_level=1)
3273 object_info = self.object_inspect(target, detail_level=1)
3264 if object_info['found'] and object_info['source']:
3274 if object_info['found'] and object_info['source']:
3265 return object_info['source']
3275 return object_info['source']
3266
3276
3267 try: # User namespace
3277 try: # User namespace
3268 codeobj = eval(target, self.user_ns)
3278 codeobj = eval(target, self.user_ns)
3269 except Exception:
3279 except Exception:
3270 raise ValueError(("'%s' was not found in history, as a file, url, "
3280 raise ValueError(("'%s' was not found in history, as a file, url, "
3271 "nor in the user namespace.") % target)
3281 "nor in the user namespace.") % target)
3272
3282
3273 if isinstance(codeobj, string_types):
3283 if isinstance(codeobj, string_types):
3274 return codeobj
3284 return codeobj
3275 elif isinstance(codeobj, Macro):
3285 elif isinstance(codeobj, Macro):
3276 return codeobj.value
3286 return codeobj.value
3277
3287
3278 raise TypeError("%s is neither a string nor a macro." % target,
3288 raise TypeError("%s is neither a string nor a macro." % target,
3279 codeobj)
3289 codeobj)
3280
3290
3281 #-------------------------------------------------------------------------
3291 #-------------------------------------------------------------------------
3282 # Things related to IPython exiting
3292 # Things related to IPython exiting
3283 #-------------------------------------------------------------------------
3293 #-------------------------------------------------------------------------
3284 def atexit_operations(self):
3294 def atexit_operations(self):
3285 """This will be executed at the time of exit.
3295 """This will be executed at the time of exit.
3286
3296
3287 Cleanup operations and saving of persistent data that is done
3297 Cleanup operations and saving of persistent data that is done
3288 unconditionally by IPython should be performed here.
3298 unconditionally by IPython should be performed here.
3289
3299
3290 For things that may depend on startup flags or platform specifics (such
3300 For things that may depend on startup flags or platform specifics (such
3291 as having readline or not), register a separate atexit function in the
3301 as having readline or not), register a separate atexit function in the
3292 code that has the appropriate information, rather than trying to
3302 code that has the appropriate information, rather than trying to
3293 clutter
3303 clutter
3294 """
3304 """
3295 # Close the history session (this stores the end time and line count)
3305 # Close the history session (this stores the end time and line count)
3296 # this must be *before* the tempfile cleanup, in case of temporary
3306 # this must be *before* the tempfile cleanup, in case of temporary
3297 # history db
3307 # history db
3298 self.history_manager.end_session()
3308 self.history_manager.end_session()
3299
3309
3300 # Cleanup all tempfiles and folders left around
3310 # Cleanup all tempfiles and folders left around
3301 for tfile in self.tempfiles:
3311 for tfile in self.tempfiles:
3302 try:
3312 try:
3303 os.unlink(tfile)
3313 os.unlink(tfile)
3304 except OSError:
3314 except OSError:
3305 pass
3315 pass
3306
3316
3307 for tdir in self.tempdirs:
3317 for tdir in self.tempdirs:
3308 try:
3318 try:
3309 os.rmdir(tdir)
3319 os.rmdir(tdir)
3310 except OSError:
3320 except OSError:
3311 pass
3321 pass
3312
3322
3313 # Clear all user namespaces to release all references cleanly.
3323 # Clear all user namespaces to release all references cleanly.
3314 self.reset(new_session=False)
3324 self.reset(new_session=False)
3315
3325
3316 # Run user hooks
3326 # Run user hooks
3317 self.hooks.shutdown_hook()
3327 self.hooks.shutdown_hook()
3318
3328
3319 def cleanup(self):
3329 def cleanup(self):
3320 self.restore_sys_module_state()
3330 self.restore_sys_module_state()
3321
3331
3322
3332
3323 class InteractiveShellABC(with_metaclass(abc.ABCMeta, object)):
3333 class InteractiveShellABC(with_metaclass(abc.ABCMeta, object)):
3324 """An abstract base class for InteractiveShell."""
3334 """An abstract base class for InteractiveShell."""
3325
3335
3326 InteractiveShellABC.register(InteractiveShell)
3336 InteractiveShellABC.register(InteractiveShell)
@@ -1,869 +1,884 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Tests for the key interactiveshell module.
2 """Tests for the key interactiveshell module.
3
3
4 Historically the main classes in interactiveshell have been under-tested. This
4 Historically the main classes in interactiveshell have been under-tested. This
5 module should grow as many single-method tests as possible to trap many of the
5 module should grow as many single-method tests as possible to trap many of the
6 recurring bugs we seem to encounter with high-level interaction.
6 recurring bugs we seem to encounter with high-level interaction.
7 """
7 """
8
8
9 # Copyright (c) IPython Development Team.
9 # Copyright (c) IPython Development Team.
10 # Distributed under the terms of the Modified BSD License.
10 # Distributed under the terms of the Modified BSD License.
11
11
12 import ast
12 import ast
13 import os
13 import os
14 import signal
14 import signal
15 import shutil
15 import shutil
16 import sys
16 import sys
17 import tempfile
17 import tempfile
18 import unittest
18 import unittest
19 try:
19 try:
20 from unittest import mock
20 from unittest import mock
21 except ImportError:
21 except ImportError:
22 import mock
22 import mock
23 from os.path import join
23 from os.path import join
24
24
25 import nose.tools as nt
25 import nose.tools as nt
26
26
27 from IPython.core.error import InputRejected
27 from IPython.core.error import InputRejected
28 from IPython.core.inputtransformer import InputTransformer
28 from IPython.core.inputtransformer import InputTransformer
29 from IPython.testing.decorators import (
29 from IPython.testing.decorators import (
30 skipif, skip_win32, onlyif_unicode_paths, onlyif_cmds_exist,
30 skipif, skip_win32, onlyif_unicode_paths, onlyif_cmds_exist,
31 )
31 )
32 from IPython.testing import tools as tt
32 from IPython.testing import tools as tt
33 from IPython.utils import io
33 from IPython.utils import io
34 from IPython.utils.process import find_cmd
34 from IPython.utils.process import find_cmd
35 from IPython.utils import py3compat
35 from IPython.utils import py3compat
36 from IPython.utils.py3compat import unicode_type, PY3
36 from IPython.utils.py3compat import unicode_type, PY3
37
37
38 if PY3:
38 if PY3:
39 from io import StringIO
39 from io import StringIO
40 else:
40 else:
41 from StringIO import StringIO
41 from StringIO import StringIO
42
42
43 #-----------------------------------------------------------------------------
43 #-----------------------------------------------------------------------------
44 # Globals
44 # Globals
45 #-----------------------------------------------------------------------------
45 #-----------------------------------------------------------------------------
46 # This is used by every single test, no point repeating it ad nauseam
46 # This is used by every single test, no point repeating it ad nauseam
47 ip = get_ipython()
47 ip = get_ipython()
48
48
49 #-----------------------------------------------------------------------------
49 #-----------------------------------------------------------------------------
50 # Tests
50 # Tests
51 #-----------------------------------------------------------------------------
51 #-----------------------------------------------------------------------------
52
52
53 class InteractiveShellTestCase(unittest.TestCase):
53 class InteractiveShellTestCase(unittest.TestCase):
54 def test_naked_string_cells(self):
54 def test_naked_string_cells(self):
55 """Test that cells with only naked strings are fully executed"""
55 """Test that cells with only naked strings are fully executed"""
56 # First, single-line inputs
56 # First, single-line inputs
57 ip.run_cell('"a"\n')
57 ip.run_cell('"a"\n')
58 self.assertEqual(ip.user_ns['_'], 'a')
58 self.assertEqual(ip.user_ns['_'], 'a')
59 # And also multi-line cells
59 # And also multi-line cells
60 ip.run_cell('"""a\nb"""\n')
60 ip.run_cell('"""a\nb"""\n')
61 self.assertEqual(ip.user_ns['_'], 'a\nb')
61 self.assertEqual(ip.user_ns['_'], 'a\nb')
62
62
63 def test_run_empty_cell(self):
63 def test_run_empty_cell(self):
64 """Just make sure we don't get a horrible error with a blank
64 """Just make sure we don't get a horrible error with a blank
65 cell of input. Yes, I did overlook that."""
65 cell of input. Yes, I did overlook that."""
66 old_xc = ip.execution_count
66 old_xc = ip.execution_count
67 ip.run_cell('')
67 ip.run_cell('')
68 self.assertEqual(ip.execution_count, old_xc)
68 self.assertEqual(ip.execution_count, old_xc)
69
69
70 def test_run_cell_multiline(self):
70 def test_run_cell_multiline(self):
71 """Multi-block, multi-line cells must execute correctly.
71 """Multi-block, multi-line cells must execute correctly.
72 """
72 """
73 src = '\n'.join(["x=1",
73 src = '\n'.join(["x=1",
74 "y=2",
74 "y=2",
75 "if 1:",
75 "if 1:",
76 " x += 1",
76 " x += 1",
77 " y += 1",])
77 " y += 1",])
78 ip.run_cell(src)
78 ip.run_cell(src)
79 self.assertEqual(ip.user_ns['x'], 2)
79 self.assertEqual(ip.user_ns['x'], 2)
80 self.assertEqual(ip.user_ns['y'], 3)
80 self.assertEqual(ip.user_ns['y'], 3)
81
81
82 def test_multiline_string_cells(self):
82 def test_multiline_string_cells(self):
83 "Code sprinkled with multiline strings should execute (GH-306)"
83 "Code sprinkled with multiline strings should execute (GH-306)"
84 ip.run_cell('tmp=0')
84 ip.run_cell('tmp=0')
85 self.assertEqual(ip.user_ns['tmp'], 0)
85 self.assertEqual(ip.user_ns['tmp'], 0)
86 ip.run_cell('tmp=1;"""a\nb"""\n')
86 ip.run_cell('tmp=1;"""a\nb"""\n')
87 self.assertEqual(ip.user_ns['tmp'], 1)
87 self.assertEqual(ip.user_ns['tmp'], 1)
88
88
89 def test_dont_cache_with_semicolon(self):
89 def test_dont_cache_with_semicolon(self):
90 "Ending a line with semicolon should not cache the returned object (GH-307)"
90 "Ending a line with semicolon should not cache the returned object (GH-307)"
91 oldlen = len(ip.user_ns['Out'])
91 oldlen = len(ip.user_ns['Out'])
92 for cell in ['1;', '1;1;']:
92 for cell in ['1;', '1;1;']:
93 ip.run_cell(cell, store_history=True)
93 ip.run_cell(cell, store_history=True)
94 newlen = len(ip.user_ns['Out'])
94 newlen = len(ip.user_ns['Out'])
95 self.assertEqual(oldlen, newlen)
95 self.assertEqual(oldlen, newlen)
96 i = 0
96 i = 0
97 #also test the default caching behavior
97 #also test the default caching behavior
98 for cell in ['1', '1;1']:
98 for cell in ['1', '1;1']:
99 ip.run_cell(cell, store_history=True)
99 ip.run_cell(cell, store_history=True)
100 newlen = len(ip.user_ns['Out'])
100 newlen = len(ip.user_ns['Out'])
101 i += 1
101 i += 1
102 self.assertEqual(oldlen+i, newlen)
102 self.assertEqual(oldlen+i, newlen)
103
103
104 def test_In_variable(self):
104 def test_In_variable(self):
105 "Verify that In variable grows with user input (GH-284)"
105 "Verify that In variable grows with user input (GH-284)"
106 oldlen = len(ip.user_ns['In'])
106 oldlen = len(ip.user_ns['In'])
107 ip.run_cell('1;', store_history=True)
107 ip.run_cell('1;', store_history=True)
108 newlen = len(ip.user_ns['In'])
108 newlen = len(ip.user_ns['In'])
109 self.assertEqual(oldlen+1, newlen)
109 self.assertEqual(oldlen+1, newlen)
110 self.assertEqual(ip.user_ns['In'][-1],'1;')
110 self.assertEqual(ip.user_ns['In'][-1],'1;')
111
111
112 def test_magic_names_in_string(self):
112 def test_magic_names_in_string(self):
113 ip.run_cell('a = """\n%exit\n"""')
113 ip.run_cell('a = """\n%exit\n"""')
114 self.assertEqual(ip.user_ns['a'], '\n%exit\n')
114 self.assertEqual(ip.user_ns['a'], '\n%exit\n')
115
115
116 def test_trailing_newline(self):
116 def test_trailing_newline(self):
117 """test that running !(command) does not raise a SyntaxError"""
117 """test that running !(command) does not raise a SyntaxError"""
118 ip.run_cell('!(true)\n', False)
118 ip.run_cell('!(true)\n', False)
119 ip.run_cell('!(true)\n\n\n', False)
119 ip.run_cell('!(true)\n\n\n', False)
120
120
121 def test_gh_597(self):
121 def test_gh_597(self):
122 """Pretty-printing lists of objects with non-ascii reprs may cause
122 """Pretty-printing lists of objects with non-ascii reprs may cause
123 problems."""
123 problems."""
124 class Spam(object):
124 class Spam(object):
125 def __repr__(self):
125 def __repr__(self):
126 return "\xe9"*50
126 return "\xe9"*50
127 import IPython.core.formatters
127 import IPython.core.formatters
128 f = IPython.core.formatters.PlainTextFormatter()
128 f = IPython.core.formatters.PlainTextFormatter()
129 f([Spam(),Spam()])
129 f([Spam(),Spam()])
130
130
131
131
132 def test_future_flags(self):
132 def test_future_flags(self):
133 """Check that future flags are used for parsing code (gh-777)"""
133 """Check that future flags are used for parsing code (gh-777)"""
134 ip.run_cell('from __future__ import print_function')
134 ip.run_cell('from __future__ import print_function')
135 try:
135 try:
136 ip.run_cell('prfunc_return_val = print(1,2, sep=" ")')
136 ip.run_cell('prfunc_return_val = print(1,2, sep=" ")')
137 assert 'prfunc_return_val' in ip.user_ns
137 assert 'prfunc_return_val' in ip.user_ns
138 finally:
138 finally:
139 # Reset compiler flags so we don't mess up other tests.
139 # Reset compiler flags so we don't mess up other tests.
140 ip.compile.reset_compiler_flags()
140 ip.compile.reset_compiler_flags()
141
141
142 def test_future_unicode(self):
142 def test_future_unicode(self):
143 """Check that unicode_literals is imported from __future__ (gh #786)"""
143 """Check that unicode_literals is imported from __future__ (gh #786)"""
144 try:
144 try:
145 ip.run_cell(u'byte_str = "a"')
145 ip.run_cell(u'byte_str = "a"')
146 assert isinstance(ip.user_ns['byte_str'], str) # string literals are byte strings by default
146 assert isinstance(ip.user_ns['byte_str'], str) # string literals are byte strings by default
147 ip.run_cell('from __future__ import unicode_literals')
147 ip.run_cell('from __future__ import unicode_literals')
148 ip.run_cell(u'unicode_str = "a"')
148 ip.run_cell(u'unicode_str = "a"')
149 assert isinstance(ip.user_ns['unicode_str'], unicode_type) # strings literals are now unicode
149 assert isinstance(ip.user_ns['unicode_str'], unicode_type) # strings literals are now unicode
150 finally:
150 finally:
151 # Reset compiler flags so we don't mess up other tests.
151 # Reset compiler flags so we don't mess up other tests.
152 ip.compile.reset_compiler_flags()
152 ip.compile.reset_compiler_flags()
153
153
154 def test_can_pickle(self):
154 def test_can_pickle(self):
155 "Can we pickle objects defined interactively (GH-29)"
155 "Can we pickle objects defined interactively (GH-29)"
156 ip = get_ipython()
156 ip = get_ipython()
157 ip.reset()
157 ip.reset()
158 ip.run_cell(("class Mylist(list):\n"
158 ip.run_cell(("class Mylist(list):\n"
159 " def __init__(self,x=[]):\n"
159 " def __init__(self,x=[]):\n"
160 " list.__init__(self,x)"))
160 " list.__init__(self,x)"))
161 ip.run_cell("w=Mylist([1,2,3])")
161 ip.run_cell("w=Mylist([1,2,3])")
162
162
163 from pickle import dumps
163 from pickle import dumps
164
164
165 # We need to swap in our main module - this is only necessary
165 # We need to swap in our main module - this is only necessary
166 # inside the test framework, because IPython puts the interactive module
166 # inside the test framework, because IPython puts the interactive module
167 # in place (but the test framework undoes this).
167 # in place (but the test framework undoes this).
168 _main = sys.modules['__main__']
168 _main = sys.modules['__main__']
169 sys.modules['__main__'] = ip.user_module
169 sys.modules['__main__'] = ip.user_module
170 try:
170 try:
171 res = dumps(ip.user_ns["w"])
171 res = dumps(ip.user_ns["w"])
172 finally:
172 finally:
173 sys.modules['__main__'] = _main
173 sys.modules['__main__'] = _main
174 self.assertTrue(isinstance(res, bytes))
174 self.assertTrue(isinstance(res, bytes))
175
175
176 def test_global_ns(self):
176 def test_global_ns(self):
177 "Code in functions must be able to access variables outside them."
177 "Code in functions must be able to access variables outside them."
178 ip = get_ipython()
178 ip = get_ipython()
179 ip.run_cell("a = 10")
179 ip.run_cell("a = 10")
180 ip.run_cell(("def f(x):\n"
180 ip.run_cell(("def f(x):\n"
181 " return x + a"))
181 " return x + a"))
182 ip.run_cell("b = f(12)")
182 ip.run_cell("b = f(12)")
183 self.assertEqual(ip.user_ns["b"], 22)
183 self.assertEqual(ip.user_ns["b"], 22)
184
184
185 def test_bad_custom_tb(self):
185 def test_bad_custom_tb(self):
186 """Check that InteractiveShell is protected from bad custom exception handlers"""
186 """Check that InteractiveShell is protected from bad custom exception handlers"""
187 from IPython.utils import io
187 from IPython.utils import io
188 save_stderr = io.stderr
188 save_stderr = io.stderr
189 try:
189 try:
190 # capture stderr
190 # capture stderr
191 io.stderr = StringIO()
191 io.stderr = StringIO()
192 ip.set_custom_exc((IOError,), lambda etype,value,tb: 1/0)
192 ip.set_custom_exc((IOError,), lambda etype,value,tb: 1/0)
193 self.assertEqual(ip.custom_exceptions, (IOError,))
193 self.assertEqual(ip.custom_exceptions, (IOError,))
194 ip.run_cell(u'raise IOError("foo")')
194 ip.run_cell(u'raise IOError("foo")')
195 self.assertEqual(ip.custom_exceptions, ())
195 self.assertEqual(ip.custom_exceptions, ())
196 self.assertTrue("Custom TB Handler failed" in io.stderr.getvalue())
196 self.assertTrue("Custom TB Handler failed" in io.stderr.getvalue())
197 finally:
197 finally:
198 io.stderr = save_stderr
198 io.stderr = save_stderr
199
199
200 def test_bad_custom_tb_return(self):
200 def test_bad_custom_tb_return(self):
201 """Check that InteractiveShell is protected from bad return types in custom exception handlers"""
201 """Check that InteractiveShell is protected from bad return types in custom exception handlers"""
202 from IPython.utils import io
202 from IPython.utils import io
203 save_stderr = io.stderr
203 save_stderr = io.stderr
204 try:
204 try:
205 # capture stderr
205 # capture stderr
206 io.stderr = StringIO()
206 io.stderr = StringIO()
207 ip.set_custom_exc((NameError,),lambda etype,value,tb, tb_offset=None: 1)
207 ip.set_custom_exc((NameError,),lambda etype,value,tb, tb_offset=None: 1)
208 self.assertEqual(ip.custom_exceptions, (NameError,))
208 self.assertEqual(ip.custom_exceptions, (NameError,))
209 ip.run_cell(u'a=abracadabra')
209 ip.run_cell(u'a=abracadabra')
210 self.assertEqual(ip.custom_exceptions, ())
210 self.assertEqual(ip.custom_exceptions, ())
211 self.assertTrue("Custom TB Handler failed" in io.stderr.getvalue())
211 self.assertTrue("Custom TB Handler failed" in io.stderr.getvalue())
212 finally:
212 finally:
213 io.stderr = save_stderr
213 io.stderr = save_stderr
214
214
215 def test_drop_by_id(self):
215 def test_drop_by_id(self):
216 myvars = {"a":object(), "b":object(), "c": object()}
216 myvars = {"a":object(), "b":object(), "c": object()}
217 ip.push(myvars, interactive=False)
217 ip.push(myvars, interactive=False)
218 for name in myvars:
218 for name in myvars:
219 assert name in ip.user_ns, name
219 assert name in ip.user_ns, name
220 assert name in ip.user_ns_hidden, name
220 assert name in ip.user_ns_hidden, name
221 ip.user_ns['b'] = 12
221 ip.user_ns['b'] = 12
222 ip.drop_by_id(myvars)
222 ip.drop_by_id(myvars)
223 for name in ["a", "c"]:
223 for name in ["a", "c"]:
224 assert name not in ip.user_ns, name
224 assert name not in ip.user_ns, name
225 assert name not in ip.user_ns_hidden, name
225 assert name not in ip.user_ns_hidden, name
226 assert ip.user_ns['b'] == 12
226 assert ip.user_ns['b'] == 12
227 ip.reset()
227 ip.reset()
228
228
229 def test_var_expand(self):
229 def test_var_expand(self):
230 ip.user_ns['f'] = u'Ca\xf1o'
230 ip.user_ns['f'] = u'Ca\xf1o'
231 self.assertEqual(ip.var_expand(u'echo $f'), u'echo Ca\xf1o')
231 self.assertEqual(ip.var_expand(u'echo $f'), u'echo Ca\xf1o')
232 self.assertEqual(ip.var_expand(u'echo {f}'), u'echo Ca\xf1o')
232 self.assertEqual(ip.var_expand(u'echo {f}'), u'echo Ca\xf1o')
233 self.assertEqual(ip.var_expand(u'echo {f[:-1]}'), u'echo Ca\xf1')
233 self.assertEqual(ip.var_expand(u'echo {f[:-1]}'), u'echo Ca\xf1')
234 self.assertEqual(ip.var_expand(u'echo {1*2}'), u'echo 2')
234 self.assertEqual(ip.var_expand(u'echo {1*2}'), u'echo 2')
235
235
236 ip.user_ns['f'] = b'Ca\xc3\xb1o'
236 ip.user_ns['f'] = b'Ca\xc3\xb1o'
237 # This should not raise any exception:
237 # This should not raise any exception:
238 ip.var_expand(u'echo $f')
238 ip.var_expand(u'echo $f')
239
239
240 def test_var_expand_local(self):
240 def test_var_expand_local(self):
241 """Test local variable expansion in !system and %magic calls"""
241 """Test local variable expansion in !system and %magic calls"""
242 # !system
242 # !system
243 ip.run_cell('def test():\n'
243 ip.run_cell('def test():\n'
244 ' lvar = "ttt"\n'
244 ' lvar = "ttt"\n'
245 ' ret = !echo {lvar}\n'
245 ' ret = !echo {lvar}\n'
246 ' return ret[0]\n')
246 ' return ret[0]\n')
247 res = ip.user_ns['test']()
247 res = ip.user_ns['test']()
248 nt.assert_in('ttt', res)
248 nt.assert_in('ttt', res)
249
249
250 # %magic
250 # %magic
251 ip.run_cell('def makemacro():\n'
251 ip.run_cell('def makemacro():\n'
252 ' macroname = "macro_var_expand_locals"\n'
252 ' macroname = "macro_var_expand_locals"\n'
253 ' %macro {macroname} codestr\n')
253 ' %macro {macroname} codestr\n')
254 ip.user_ns['codestr'] = "str(12)"
254 ip.user_ns['codestr'] = "str(12)"
255 ip.run_cell('makemacro()')
255 ip.run_cell('makemacro()')
256 nt.assert_in('macro_var_expand_locals', ip.user_ns)
256 nt.assert_in('macro_var_expand_locals', ip.user_ns)
257
257
258 def test_var_expand_self(self):
258 def test_var_expand_self(self):
259 """Test variable expansion with the name 'self', which was failing.
259 """Test variable expansion with the name 'self', which was failing.
260
260
261 See https://github.com/ipython/ipython/issues/1878#issuecomment-7698218
261 See https://github.com/ipython/ipython/issues/1878#issuecomment-7698218
262 """
262 """
263 ip.run_cell('class cTest:\n'
263 ip.run_cell('class cTest:\n'
264 ' classvar="see me"\n'
264 ' classvar="see me"\n'
265 ' def test(self):\n'
265 ' def test(self):\n'
266 ' res = !echo Variable: {self.classvar}\n'
266 ' res = !echo Variable: {self.classvar}\n'
267 ' return res[0]\n')
267 ' return res[0]\n')
268 nt.assert_in('see me', ip.user_ns['cTest']().test())
268 nt.assert_in('see me', ip.user_ns['cTest']().test())
269
269
270 def test_bad_var_expand(self):
270 def test_bad_var_expand(self):
271 """var_expand on invalid formats shouldn't raise"""
271 """var_expand on invalid formats shouldn't raise"""
272 # SyntaxError
272 # SyntaxError
273 self.assertEqual(ip.var_expand(u"{'a':5}"), u"{'a':5}")
273 self.assertEqual(ip.var_expand(u"{'a':5}"), u"{'a':5}")
274 # NameError
274 # NameError
275 self.assertEqual(ip.var_expand(u"{asdf}"), u"{asdf}")
275 self.assertEqual(ip.var_expand(u"{asdf}"), u"{asdf}")
276 # ZeroDivisionError
276 # ZeroDivisionError
277 self.assertEqual(ip.var_expand(u"{1/0}"), u"{1/0}")
277 self.assertEqual(ip.var_expand(u"{1/0}"), u"{1/0}")
278
278
279 def test_silent_postexec(self):
279 def test_silent_postexec(self):
280 """run_cell(silent=True) doesn't invoke pre/post_run_cell callbacks"""
280 """run_cell(silent=True) doesn't invoke pre/post_run_cell callbacks"""
281 pre_explicit = mock.Mock()
281 pre_explicit = mock.Mock()
282 pre_always = mock.Mock()
282 pre_always = mock.Mock()
283 post_explicit = mock.Mock()
283 post_explicit = mock.Mock()
284 post_always = mock.Mock()
284 post_always = mock.Mock()
285
285
286 ip.events.register('pre_run_cell', pre_explicit)
286 ip.events.register('pre_run_cell', pre_explicit)
287 ip.events.register('pre_execute', pre_always)
287 ip.events.register('pre_execute', pre_always)
288 ip.events.register('post_run_cell', post_explicit)
288 ip.events.register('post_run_cell', post_explicit)
289 ip.events.register('post_execute', post_always)
289 ip.events.register('post_execute', post_always)
290
290
291 try:
291 try:
292 ip.run_cell("1", silent=True)
292 ip.run_cell("1", silent=True)
293 assert pre_always.called
293 assert pre_always.called
294 assert not pre_explicit.called
294 assert not pre_explicit.called
295 assert post_always.called
295 assert post_always.called
296 assert not post_explicit.called
296 assert not post_explicit.called
297 # double-check that non-silent exec did what we expected
297 # double-check that non-silent exec did what we expected
298 # silent to avoid
298 # silent to avoid
299 ip.run_cell("1")
299 ip.run_cell("1")
300 assert pre_explicit.called
300 assert pre_explicit.called
301 assert post_explicit.called
301 assert post_explicit.called
302 finally:
302 finally:
303 # remove post-exec
303 # remove post-exec
304 ip.events.unregister('pre_run_cell', pre_explicit)
304 ip.events.unregister('pre_run_cell', pre_explicit)
305 ip.events.unregister('pre_execute', pre_always)
305 ip.events.unregister('pre_execute', pre_always)
306 ip.events.unregister('post_run_cell', post_explicit)
306 ip.events.unregister('post_run_cell', post_explicit)
307 ip.events.unregister('post_execute', post_always)
307 ip.events.unregister('post_execute', post_always)
308
308
309 def test_silent_noadvance(self):
309 def test_silent_noadvance(self):
310 """run_cell(silent=True) doesn't advance execution_count"""
310 """run_cell(silent=True) doesn't advance execution_count"""
311 ec = ip.execution_count
311 ec = ip.execution_count
312 # silent should force store_history=False
312 # silent should force store_history=False
313 ip.run_cell("1", store_history=True, silent=True)
313 ip.run_cell("1", store_history=True, silent=True)
314
314
315 self.assertEqual(ec, ip.execution_count)
315 self.assertEqual(ec, ip.execution_count)
316 # double-check that non-silent exec did what we expected
316 # double-check that non-silent exec did what we expected
317 # silent to avoid
317 # silent to avoid
318 ip.run_cell("1", store_history=True)
318 ip.run_cell("1", store_history=True)
319 self.assertEqual(ec+1, ip.execution_count)
319 self.assertEqual(ec+1, ip.execution_count)
320
320
321 def test_silent_nodisplayhook(self):
321 def test_silent_nodisplayhook(self):
322 """run_cell(silent=True) doesn't trigger displayhook"""
322 """run_cell(silent=True) doesn't trigger displayhook"""
323 d = dict(called=False)
323 d = dict(called=False)
324
324
325 trap = ip.display_trap
325 trap = ip.display_trap
326 save_hook = trap.hook
326 save_hook = trap.hook
327
327
328 def failing_hook(*args, **kwargs):
328 def failing_hook(*args, **kwargs):
329 d['called'] = True
329 d['called'] = True
330
330
331 try:
331 try:
332 trap.hook = failing_hook
332 trap.hook = failing_hook
333 ip.run_cell("1", silent=True)
333 ip.run_cell("1", silent=True)
334 self.assertFalse(d['called'])
334 self.assertFalse(d['called'])
335 # double-check that non-silent exec did what we expected
335 # double-check that non-silent exec did what we expected
336 # silent to avoid
336 # silent to avoid
337 ip.run_cell("1")
337 ip.run_cell("1")
338 self.assertTrue(d['called'])
338 self.assertTrue(d['called'])
339 finally:
339 finally:
340 trap.hook = save_hook
340 trap.hook = save_hook
341
341
342 @skipif(sys.version_info[0] >= 3, "softspace removed in py3")
342 @skipif(sys.version_info[0] >= 3, "softspace removed in py3")
343 def test_print_softspace(self):
343 def test_print_softspace(self):
344 """Verify that softspace is handled correctly when executing multiple
344 """Verify that softspace is handled correctly when executing multiple
345 statements.
345 statements.
346
346
347 In [1]: print 1; print 2
347 In [1]: print 1; print 2
348 1
348 1
349 2
349 2
350
350
351 In [2]: print 1,; print 2
351 In [2]: print 1,; print 2
352 1 2
352 1 2
353 """
353 """
354
354
355 def test_ofind_line_magic(self):
355 def test_ofind_line_magic(self):
356 from IPython.core.magic import register_line_magic
356 from IPython.core.magic import register_line_magic
357
357
358 @register_line_magic
358 @register_line_magic
359 def lmagic(line):
359 def lmagic(line):
360 "A line magic"
360 "A line magic"
361
361
362 # Get info on line magic
362 # Get info on line magic
363 lfind = ip._ofind('lmagic')
363 lfind = ip._ofind('lmagic')
364 info = dict(found=True, isalias=False, ismagic=True,
364 info = dict(found=True, isalias=False, ismagic=True,
365 namespace = 'IPython internal', obj= lmagic.__wrapped__,
365 namespace = 'IPython internal', obj= lmagic.__wrapped__,
366 parent = None)
366 parent = None)
367 nt.assert_equal(lfind, info)
367 nt.assert_equal(lfind, info)
368
368
369 def test_ofind_cell_magic(self):
369 def test_ofind_cell_magic(self):
370 from IPython.core.magic import register_cell_magic
370 from IPython.core.magic import register_cell_magic
371
371
372 @register_cell_magic
372 @register_cell_magic
373 def cmagic(line, cell):
373 def cmagic(line, cell):
374 "A cell magic"
374 "A cell magic"
375
375
376 # Get info on cell magic
376 # Get info on cell magic
377 find = ip._ofind('cmagic')
377 find = ip._ofind('cmagic')
378 info = dict(found=True, isalias=False, ismagic=True,
378 info = dict(found=True, isalias=False, ismagic=True,
379 namespace = 'IPython internal', obj= cmagic.__wrapped__,
379 namespace = 'IPython internal', obj= cmagic.__wrapped__,
380 parent = None)
380 parent = None)
381 nt.assert_equal(find, info)
381 nt.assert_equal(find, info)
382
382
383 def test_ofind_property_with_error(self):
383 def test_ofind_property_with_error(self):
384 class A(object):
384 class A(object):
385 @property
385 @property
386 def foo(self):
386 def foo(self):
387 raise NotImplementedError()
387 raise NotImplementedError()
388 a = A()
388 a = A()
389
389
390 found = ip._ofind('a.foo', [('locals', locals())])
390 found = ip._ofind('a.foo', [('locals', locals())])
391 info = dict(found=True, isalias=False, ismagic=False,
391 info = dict(found=True, isalias=False, ismagic=False,
392 namespace='locals', obj=A.foo, parent=a)
392 namespace='locals', obj=A.foo, parent=a)
393 nt.assert_equal(found, info)
393 nt.assert_equal(found, info)
394
394
395 def test_ofind_multiple_attribute_lookups(self):
395 def test_ofind_multiple_attribute_lookups(self):
396 class A(object):
396 class A(object):
397 @property
397 @property
398 def foo(self):
398 def foo(self):
399 raise NotImplementedError()
399 raise NotImplementedError()
400
400
401 a = A()
401 a = A()
402 a.a = A()
402 a.a = A()
403 a.a.a = A()
403 a.a.a = A()
404
404
405 found = ip._ofind('a.a.a.foo', [('locals', locals())])
405 found = ip._ofind('a.a.a.foo', [('locals', locals())])
406 info = dict(found=True, isalias=False, ismagic=False,
406 info = dict(found=True, isalias=False, ismagic=False,
407 namespace='locals', obj=A.foo, parent=a.a.a)
407 namespace='locals', obj=A.foo, parent=a.a.a)
408 nt.assert_equal(found, info)
408 nt.assert_equal(found, info)
409
409
410 def test_ofind_slotted_attributes(self):
410 def test_ofind_slotted_attributes(self):
411 class A(object):
411 class A(object):
412 __slots__ = ['foo']
412 __slots__ = ['foo']
413 def __init__(self):
413 def __init__(self):
414 self.foo = 'bar'
414 self.foo = 'bar'
415
415
416 a = A()
416 a = A()
417 found = ip._ofind('a.foo', [('locals', locals())])
417 found = ip._ofind('a.foo', [('locals', locals())])
418 info = dict(found=True, isalias=False, ismagic=False,
418 info = dict(found=True, isalias=False, ismagic=False,
419 namespace='locals', obj=a.foo, parent=a)
419 namespace='locals', obj=a.foo, parent=a)
420 nt.assert_equal(found, info)
420 nt.assert_equal(found, info)
421
421
422 found = ip._ofind('a.bar', [('locals', locals())])
422 found = ip._ofind('a.bar', [('locals', locals())])
423 info = dict(found=False, isalias=False, ismagic=False,
423 info = dict(found=False, isalias=False, ismagic=False,
424 namespace=None, obj=None, parent=a)
424 namespace=None, obj=None, parent=a)
425 nt.assert_equal(found, info)
425 nt.assert_equal(found, info)
426
426
427 def test_ofind_prefers_property_to_instance_level_attribute(self):
427 def test_ofind_prefers_property_to_instance_level_attribute(self):
428 class A(object):
428 class A(object):
429 @property
429 @property
430 def foo(self):
430 def foo(self):
431 return 'bar'
431 return 'bar'
432 a = A()
432 a = A()
433 a.__dict__['foo'] = 'baz'
433 a.__dict__['foo'] = 'baz'
434 nt.assert_equal(a.foo, 'bar')
434 nt.assert_equal(a.foo, 'bar')
435 found = ip._ofind('a.foo', [('locals', locals())])
435 found = ip._ofind('a.foo', [('locals', locals())])
436 nt.assert_is(found['obj'], A.foo)
436 nt.assert_is(found['obj'], A.foo)
437
437
438 def test_custom_exception(self):
438 def test_custom_exception(self):
439 called = []
439 called = []
440 def my_handler(shell, etype, value, tb, tb_offset=None):
440 def my_handler(shell, etype, value, tb, tb_offset=None):
441 called.append(etype)
441 called.append(etype)
442 shell.showtraceback((etype, value, tb), tb_offset=tb_offset)
442 shell.showtraceback((etype, value, tb), tb_offset=tb_offset)
443
443
444 ip.set_custom_exc((ValueError,), my_handler)
444 ip.set_custom_exc((ValueError,), my_handler)
445 try:
445 try:
446 ip.run_cell("raise ValueError('test')")
446 ip.run_cell("raise ValueError('test')")
447 # Check that this was called, and only once.
447 # Check that this was called, and only once.
448 self.assertEqual(called, [ValueError])
448 self.assertEqual(called, [ValueError])
449 finally:
449 finally:
450 # Reset the custom exception hook
450 # Reset the custom exception hook
451 ip.set_custom_exc((), None)
451 ip.set_custom_exc((), None)
452
452
453 @skipif(sys.version_info[0] >= 3, "no differences with __future__ in py3")
453 @skipif(sys.version_info[0] >= 3, "no differences with __future__ in py3")
454 def test_future_environment(self):
454 def test_future_environment(self):
455 "Can we run code with & without the shell's __future__ imports?"
455 "Can we run code with & without the shell's __future__ imports?"
456 ip.run_cell("from __future__ import division")
456 ip.run_cell("from __future__ import division")
457 ip.run_cell("a = 1/2", shell_futures=True)
457 ip.run_cell("a = 1/2", shell_futures=True)
458 self.assertEqual(ip.user_ns['a'], 0.5)
458 self.assertEqual(ip.user_ns['a'], 0.5)
459 ip.run_cell("b = 1/2", shell_futures=False)
459 ip.run_cell("b = 1/2", shell_futures=False)
460 self.assertEqual(ip.user_ns['b'], 0)
460 self.assertEqual(ip.user_ns['b'], 0)
461
461
462 ip.compile.reset_compiler_flags()
462 ip.compile.reset_compiler_flags()
463 # This shouldn't leak to the shell's compiler
463 # This shouldn't leak to the shell's compiler
464 ip.run_cell("from __future__ import division \nc=1/2", shell_futures=False)
464 ip.run_cell("from __future__ import division \nc=1/2", shell_futures=False)
465 self.assertEqual(ip.user_ns['c'], 0.5)
465 self.assertEqual(ip.user_ns['c'], 0.5)
466 ip.run_cell("d = 1/2", shell_futures=True)
466 ip.run_cell("d = 1/2", shell_futures=True)
467 self.assertEqual(ip.user_ns['d'], 0)
467 self.assertEqual(ip.user_ns['d'], 0)
468
468
469 def test_mktempfile(self):
469 def test_mktempfile(self):
470 filename = ip.mktempfile()
470 filename = ip.mktempfile()
471 # Check that we can open the file again on Windows
471 # Check that we can open the file again on Windows
472 with open(filename, 'w') as f:
472 with open(filename, 'w') as f:
473 f.write('abc')
473 f.write('abc')
474
474
475 filename = ip.mktempfile(data='blah')
475 filename = ip.mktempfile(data='blah')
476 with open(filename, 'r') as f:
476 with open(filename, 'r') as f:
477 self.assertEqual(f.read(), 'blah')
477 self.assertEqual(f.read(), 'blah')
478
478
479 def test_new_main_mod(self):
479 def test_new_main_mod(self):
480 # Smoketest to check that this accepts a unicode module name
480 # Smoketest to check that this accepts a unicode module name
481 name = u'jiefmw'
481 name = u'jiefmw'
482 mod = ip.new_main_mod(u'%s.py' % name, name)
482 mod = ip.new_main_mod(u'%s.py' % name, name)
483 self.assertEqual(mod.__name__, name)
483 self.assertEqual(mod.__name__, name)
484
484
485 def test_get_exception_only(self):
486 try:
487 raise KeyboardInterrupt
488 except KeyboardInterrupt:
489 msg = ip.get_exception_only()
490 self.assertEqual(msg, 'KeyboardInterrupt\n')
491
492 class DerivedInterrupt(KeyboardInterrupt):
493 pass
494 try:
495 raise DerivedInterrupt("foo")
496 except KeyboardInterrupt:
497 msg = ip.get_exception_only()
498 self.assertEqual(msg, 'DerivedInterrupt: foo\n')
499
485 class TestSafeExecfileNonAsciiPath(unittest.TestCase):
500 class TestSafeExecfileNonAsciiPath(unittest.TestCase):
486
501
487 @onlyif_unicode_paths
502 @onlyif_unicode_paths
488 def setUp(self):
503 def setUp(self):
489 self.BASETESTDIR = tempfile.mkdtemp()
504 self.BASETESTDIR = tempfile.mkdtemp()
490 self.TESTDIR = join(self.BASETESTDIR, u"Γ₯Àâ")
505 self.TESTDIR = join(self.BASETESTDIR, u"Γ₯Àâ")
491 os.mkdir(self.TESTDIR)
506 os.mkdir(self.TESTDIR)
492 with open(join(self.TESTDIR, u"Γ₯Àâtestscript.py"), "w") as sfile:
507 with open(join(self.TESTDIR, u"Γ₯Àâtestscript.py"), "w") as sfile:
493 sfile.write("pass\n")
508 sfile.write("pass\n")
494 self.oldpath = py3compat.getcwd()
509 self.oldpath = py3compat.getcwd()
495 os.chdir(self.TESTDIR)
510 os.chdir(self.TESTDIR)
496 self.fname = u"Γ₯Àâtestscript.py"
511 self.fname = u"Γ₯Àâtestscript.py"
497
512
498 def tearDown(self):
513 def tearDown(self):
499 os.chdir(self.oldpath)
514 os.chdir(self.oldpath)
500 shutil.rmtree(self.BASETESTDIR)
515 shutil.rmtree(self.BASETESTDIR)
501
516
502 @onlyif_unicode_paths
517 @onlyif_unicode_paths
503 def test_1(self):
518 def test_1(self):
504 """Test safe_execfile with non-ascii path
519 """Test safe_execfile with non-ascii path
505 """
520 """
506 ip.safe_execfile(self.fname, {}, raise_exceptions=True)
521 ip.safe_execfile(self.fname, {}, raise_exceptions=True)
507
522
508 class ExitCodeChecks(tt.TempFileMixin):
523 class ExitCodeChecks(tt.TempFileMixin):
509 def test_exit_code_ok(self):
524 def test_exit_code_ok(self):
510 self.system('exit 0')
525 self.system('exit 0')
511 self.assertEqual(ip.user_ns['_exit_code'], 0)
526 self.assertEqual(ip.user_ns['_exit_code'], 0)
512
527
513 def test_exit_code_error(self):
528 def test_exit_code_error(self):
514 self.system('exit 1')
529 self.system('exit 1')
515 self.assertEqual(ip.user_ns['_exit_code'], 1)
530 self.assertEqual(ip.user_ns['_exit_code'], 1)
516
531
517 @skipif(not hasattr(signal, 'SIGALRM'))
532 @skipif(not hasattr(signal, 'SIGALRM'))
518 def test_exit_code_signal(self):
533 def test_exit_code_signal(self):
519 self.mktmp("import signal, time\n"
534 self.mktmp("import signal, time\n"
520 "signal.setitimer(signal.ITIMER_REAL, 0.1)\n"
535 "signal.setitimer(signal.ITIMER_REAL, 0.1)\n"
521 "time.sleep(1)\n")
536 "time.sleep(1)\n")
522 self.system("%s %s" % (sys.executable, self.fname))
537 self.system("%s %s" % (sys.executable, self.fname))
523 self.assertEqual(ip.user_ns['_exit_code'], -signal.SIGALRM)
538 self.assertEqual(ip.user_ns['_exit_code'], -signal.SIGALRM)
524
539
525 @onlyif_cmds_exist("csh")
540 @onlyif_cmds_exist("csh")
526 def test_exit_code_signal_csh(self):
541 def test_exit_code_signal_csh(self):
527 SHELL = os.environ.get('SHELL', None)
542 SHELL = os.environ.get('SHELL', None)
528 os.environ['SHELL'] = find_cmd("csh")
543 os.environ['SHELL'] = find_cmd("csh")
529 try:
544 try:
530 self.test_exit_code_signal()
545 self.test_exit_code_signal()
531 finally:
546 finally:
532 if SHELL is not None:
547 if SHELL is not None:
533 os.environ['SHELL'] = SHELL
548 os.environ['SHELL'] = SHELL
534 else:
549 else:
535 del os.environ['SHELL']
550 del os.environ['SHELL']
536
551
537 class TestSystemRaw(unittest.TestCase, ExitCodeChecks):
552 class TestSystemRaw(unittest.TestCase, ExitCodeChecks):
538 system = ip.system_raw
553 system = ip.system_raw
539
554
540 @onlyif_unicode_paths
555 @onlyif_unicode_paths
541 def test_1(self):
556 def test_1(self):
542 """Test system_raw with non-ascii cmd
557 """Test system_raw with non-ascii cmd
543 """
558 """
544 cmd = u'''python -c "'Γ₯Àâ'" '''
559 cmd = u'''python -c "'Γ₯Àâ'" '''
545 ip.system_raw(cmd)
560 ip.system_raw(cmd)
546
561
547 @mock.patch('subprocess.call', side_effect=KeyboardInterrupt)
562 @mock.patch('subprocess.call', side_effect=KeyboardInterrupt)
548 @mock.patch('os.system', side_effect=KeyboardInterrupt)
563 @mock.patch('os.system', side_effect=KeyboardInterrupt)
549 def test_control_c(self, *mocks):
564 def test_control_c(self, *mocks):
550 try:
565 try:
551 self.system("sleep 1 # wont happen")
566 self.system("sleep 1 # wont happen")
552 except KeyboardInterrupt:
567 except KeyboardInterrupt:
553 self.fail("system call should intercept "
568 self.fail("system call should intercept "
554 "keyboard interrupt from subprocess.call")
569 "keyboard interrupt from subprocess.call")
555 self.assertEqual(ip.user_ns['_exit_code'], -signal.SIGINT)
570 self.assertEqual(ip.user_ns['_exit_code'], -signal.SIGINT)
556
571
557 # TODO: Exit codes are currently ignored on Windows.
572 # TODO: Exit codes are currently ignored on Windows.
558 class TestSystemPipedExitCode(unittest.TestCase, ExitCodeChecks):
573 class TestSystemPipedExitCode(unittest.TestCase, ExitCodeChecks):
559 system = ip.system_piped
574 system = ip.system_piped
560
575
561 @skip_win32
576 @skip_win32
562 def test_exit_code_ok(self):
577 def test_exit_code_ok(self):
563 ExitCodeChecks.test_exit_code_ok(self)
578 ExitCodeChecks.test_exit_code_ok(self)
564
579
565 @skip_win32
580 @skip_win32
566 def test_exit_code_error(self):
581 def test_exit_code_error(self):
567 ExitCodeChecks.test_exit_code_error(self)
582 ExitCodeChecks.test_exit_code_error(self)
568
583
569 @skip_win32
584 @skip_win32
570 def test_exit_code_signal(self):
585 def test_exit_code_signal(self):
571 ExitCodeChecks.test_exit_code_signal(self)
586 ExitCodeChecks.test_exit_code_signal(self)
572
587
573 class TestModules(unittest.TestCase, tt.TempFileMixin):
588 class TestModules(unittest.TestCase, tt.TempFileMixin):
574 def test_extraneous_loads(self):
589 def test_extraneous_loads(self):
575 """Test we're not loading modules on startup that we shouldn't.
590 """Test we're not loading modules on startup that we shouldn't.
576 """
591 """
577 self.mktmp("import sys\n"
592 self.mktmp("import sys\n"
578 "print('numpy' in sys.modules)\n"
593 "print('numpy' in sys.modules)\n"
579 "print('IPython.parallel' in sys.modules)\n"
594 "print('IPython.parallel' in sys.modules)\n"
580 "print('IPython.kernel.zmq' in sys.modules)\n"
595 "print('IPython.kernel.zmq' in sys.modules)\n"
581 )
596 )
582 out = "False\nFalse\nFalse\n"
597 out = "False\nFalse\nFalse\n"
583 tt.ipexec_validate(self.fname, out)
598 tt.ipexec_validate(self.fname, out)
584
599
585 class Negator(ast.NodeTransformer):
600 class Negator(ast.NodeTransformer):
586 """Negates all number literals in an AST."""
601 """Negates all number literals in an AST."""
587 def visit_Num(self, node):
602 def visit_Num(self, node):
588 node.n = -node.n
603 node.n = -node.n
589 return node
604 return node
590
605
591 class TestAstTransform(unittest.TestCase):
606 class TestAstTransform(unittest.TestCase):
592 def setUp(self):
607 def setUp(self):
593 self.negator = Negator()
608 self.negator = Negator()
594 ip.ast_transformers.append(self.negator)
609 ip.ast_transformers.append(self.negator)
595
610
596 def tearDown(self):
611 def tearDown(self):
597 ip.ast_transformers.remove(self.negator)
612 ip.ast_transformers.remove(self.negator)
598
613
599 def test_run_cell(self):
614 def test_run_cell(self):
600 with tt.AssertPrints('-34'):
615 with tt.AssertPrints('-34'):
601 ip.run_cell('print (12 + 22)')
616 ip.run_cell('print (12 + 22)')
602
617
603 # A named reference to a number shouldn't be transformed.
618 # A named reference to a number shouldn't be transformed.
604 ip.user_ns['n'] = 55
619 ip.user_ns['n'] = 55
605 with tt.AssertNotPrints('-55'):
620 with tt.AssertNotPrints('-55'):
606 ip.run_cell('print (n)')
621 ip.run_cell('print (n)')
607
622
608 def test_timeit(self):
623 def test_timeit(self):
609 called = set()
624 called = set()
610 def f(x):
625 def f(x):
611 called.add(x)
626 called.add(x)
612 ip.push({'f':f})
627 ip.push({'f':f})
613
628
614 with tt.AssertPrints("best of "):
629 with tt.AssertPrints("best of "):
615 ip.run_line_magic("timeit", "-n1 f(1)")
630 ip.run_line_magic("timeit", "-n1 f(1)")
616 self.assertEqual(called, set([-1]))
631 self.assertEqual(called, set([-1]))
617 called.clear()
632 called.clear()
618
633
619 with tt.AssertPrints("best of "):
634 with tt.AssertPrints("best of "):
620 ip.run_cell_magic("timeit", "-n1 f(2)", "f(3)")
635 ip.run_cell_magic("timeit", "-n1 f(2)", "f(3)")
621 self.assertEqual(called, set([-2, -3]))
636 self.assertEqual(called, set([-2, -3]))
622
637
623 def test_time(self):
638 def test_time(self):
624 called = []
639 called = []
625 def f(x):
640 def f(x):
626 called.append(x)
641 called.append(x)
627 ip.push({'f':f})
642 ip.push({'f':f})
628
643
629 # Test with an expression
644 # Test with an expression
630 with tt.AssertPrints("Wall time: "):
645 with tt.AssertPrints("Wall time: "):
631 ip.run_line_magic("time", "f(5+9)")
646 ip.run_line_magic("time", "f(5+9)")
632 self.assertEqual(called, [-14])
647 self.assertEqual(called, [-14])
633 called[:] = []
648 called[:] = []
634
649
635 # Test with a statement (different code path)
650 # Test with a statement (different code path)
636 with tt.AssertPrints("Wall time: "):
651 with tt.AssertPrints("Wall time: "):
637 ip.run_line_magic("time", "a = f(-3 + -2)")
652 ip.run_line_magic("time", "a = f(-3 + -2)")
638 self.assertEqual(called, [5])
653 self.assertEqual(called, [5])
639
654
640 def test_macro(self):
655 def test_macro(self):
641 ip.push({'a':10})
656 ip.push({'a':10})
642 # The AST transformation makes this do a+=-1
657 # The AST transformation makes this do a+=-1
643 ip.define_macro("amacro", "a+=1\nprint(a)")
658 ip.define_macro("amacro", "a+=1\nprint(a)")
644
659
645 with tt.AssertPrints("9"):
660 with tt.AssertPrints("9"):
646 ip.run_cell("amacro")
661 ip.run_cell("amacro")
647 with tt.AssertPrints("8"):
662 with tt.AssertPrints("8"):
648 ip.run_cell("amacro")
663 ip.run_cell("amacro")
649
664
650 class IntegerWrapper(ast.NodeTransformer):
665 class IntegerWrapper(ast.NodeTransformer):
651 """Wraps all integers in a call to Integer()"""
666 """Wraps all integers in a call to Integer()"""
652 def visit_Num(self, node):
667 def visit_Num(self, node):
653 if isinstance(node.n, int):
668 if isinstance(node.n, int):
654 return ast.Call(func=ast.Name(id='Integer', ctx=ast.Load()),
669 return ast.Call(func=ast.Name(id='Integer', ctx=ast.Load()),
655 args=[node], keywords=[])
670 args=[node], keywords=[])
656 return node
671 return node
657
672
658 class TestAstTransform2(unittest.TestCase):
673 class TestAstTransform2(unittest.TestCase):
659 def setUp(self):
674 def setUp(self):
660 self.intwrapper = IntegerWrapper()
675 self.intwrapper = IntegerWrapper()
661 ip.ast_transformers.append(self.intwrapper)
676 ip.ast_transformers.append(self.intwrapper)
662
677
663 self.calls = []
678 self.calls = []
664 def Integer(*args):
679 def Integer(*args):
665 self.calls.append(args)
680 self.calls.append(args)
666 return args
681 return args
667 ip.push({"Integer": Integer})
682 ip.push({"Integer": Integer})
668
683
669 def tearDown(self):
684 def tearDown(self):
670 ip.ast_transformers.remove(self.intwrapper)
685 ip.ast_transformers.remove(self.intwrapper)
671 del ip.user_ns['Integer']
686 del ip.user_ns['Integer']
672
687
673 def test_run_cell(self):
688 def test_run_cell(self):
674 ip.run_cell("n = 2")
689 ip.run_cell("n = 2")
675 self.assertEqual(self.calls, [(2,)])
690 self.assertEqual(self.calls, [(2,)])
676
691
677 # This shouldn't throw an error
692 # This shouldn't throw an error
678 ip.run_cell("o = 2.0")
693 ip.run_cell("o = 2.0")
679 self.assertEqual(ip.user_ns['o'], 2.0)
694 self.assertEqual(ip.user_ns['o'], 2.0)
680
695
681 def test_timeit(self):
696 def test_timeit(self):
682 called = set()
697 called = set()
683 def f(x):
698 def f(x):
684 called.add(x)
699 called.add(x)
685 ip.push({'f':f})
700 ip.push({'f':f})
686
701
687 with tt.AssertPrints("best of "):
702 with tt.AssertPrints("best of "):
688 ip.run_line_magic("timeit", "-n1 f(1)")
703 ip.run_line_magic("timeit", "-n1 f(1)")
689 self.assertEqual(called, set([(1,)]))
704 self.assertEqual(called, set([(1,)]))
690 called.clear()
705 called.clear()
691
706
692 with tt.AssertPrints("best of "):
707 with tt.AssertPrints("best of "):
693 ip.run_cell_magic("timeit", "-n1 f(2)", "f(3)")
708 ip.run_cell_magic("timeit", "-n1 f(2)", "f(3)")
694 self.assertEqual(called, set([(2,), (3,)]))
709 self.assertEqual(called, set([(2,), (3,)]))
695
710
696 class ErrorTransformer(ast.NodeTransformer):
711 class ErrorTransformer(ast.NodeTransformer):
697 """Throws an error when it sees a number."""
712 """Throws an error when it sees a number."""
698 def visit_Num(self, node):
713 def visit_Num(self, node):
699 raise ValueError("test")
714 raise ValueError("test")
700
715
701 class TestAstTransformError(unittest.TestCase):
716 class TestAstTransformError(unittest.TestCase):
702 def test_unregistering(self):
717 def test_unregistering(self):
703 err_transformer = ErrorTransformer()
718 err_transformer = ErrorTransformer()
704 ip.ast_transformers.append(err_transformer)
719 ip.ast_transformers.append(err_transformer)
705
720
706 with tt.AssertPrints("unregister", channel='stderr'):
721 with tt.AssertPrints("unregister", channel='stderr'):
707 ip.run_cell("1 + 2")
722 ip.run_cell("1 + 2")
708
723
709 # This should have been removed.
724 # This should have been removed.
710 nt.assert_not_in(err_transformer, ip.ast_transformers)
725 nt.assert_not_in(err_transformer, ip.ast_transformers)
711
726
712
727
713 class StringRejector(ast.NodeTransformer):
728 class StringRejector(ast.NodeTransformer):
714 """Throws an InputRejected when it sees a string literal.
729 """Throws an InputRejected when it sees a string literal.
715
730
716 Used to verify that NodeTransformers can signal that a piece of code should
731 Used to verify that NodeTransformers can signal that a piece of code should
717 not be executed by throwing an InputRejected.
732 not be executed by throwing an InputRejected.
718 """
733 """
719
734
720 def visit_Str(self, node):
735 def visit_Str(self, node):
721 raise InputRejected("test")
736 raise InputRejected("test")
722
737
723
738
724 class TestAstTransformInputRejection(unittest.TestCase):
739 class TestAstTransformInputRejection(unittest.TestCase):
725
740
726 def setUp(self):
741 def setUp(self):
727 self.transformer = StringRejector()
742 self.transformer = StringRejector()
728 ip.ast_transformers.append(self.transformer)
743 ip.ast_transformers.append(self.transformer)
729
744
730 def tearDown(self):
745 def tearDown(self):
731 ip.ast_transformers.remove(self.transformer)
746 ip.ast_transformers.remove(self.transformer)
732
747
733 def test_input_rejection(self):
748 def test_input_rejection(self):
734 """Check that NodeTransformers can reject input."""
749 """Check that NodeTransformers can reject input."""
735
750
736 expect_exception_tb = tt.AssertPrints("InputRejected: test")
751 expect_exception_tb = tt.AssertPrints("InputRejected: test")
737 expect_no_cell_output = tt.AssertNotPrints("'unsafe'", suppress=False)
752 expect_no_cell_output = tt.AssertNotPrints("'unsafe'", suppress=False)
738
753
739 # Run the same check twice to verify that the transformer is not
754 # Run the same check twice to verify that the transformer is not
740 # disabled after raising.
755 # disabled after raising.
741 with expect_exception_tb, expect_no_cell_output:
756 with expect_exception_tb, expect_no_cell_output:
742 ip.run_cell("'unsafe'")
757 ip.run_cell("'unsafe'")
743
758
744 with expect_exception_tb, expect_no_cell_output:
759 with expect_exception_tb, expect_no_cell_output:
745 ip.run_cell("'unsafe'")
760 ip.run_cell("'unsafe'")
746
761
747 def test__IPYTHON__():
762 def test__IPYTHON__():
748 # This shouldn't raise a NameError, that's all
763 # This shouldn't raise a NameError, that's all
749 __IPYTHON__
764 __IPYTHON__
750
765
751
766
752 class DummyRepr(object):
767 class DummyRepr(object):
753 def __repr__(self):
768 def __repr__(self):
754 return "DummyRepr"
769 return "DummyRepr"
755
770
756 def _repr_html_(self):
771 def _repr_html_(self):
757 return "<b>dummy</b>"
772 return "<b>dummy</b>"
758
773
759 def _repr_javascript_(self):
774 def _repr_javascript_(self):
760 return "console.log('hi');", {'key': 'value'}
775 return "console.log('hi');", {'key': 'value'}
761
776
762
777
763 def test_user_variables():
778 def test_user_variables():
764 # enable all formatters
779 # enable all formatters
765 ip.display_formatter.active_types = ip.display_formatter.format_types
780 ip.display_formatter.active_types = ip.display_formatter.format_types
766
781
767 ip.user_ns['dummy'] = d = DummyRepr()
782 ip.user_ns['dummy'] = d = DummyRepr()
768 keys = set(['dummy', 'doesnotexist'])
783 keys = set(['dummy', 'doesnotexist'])
769 r = ip.user_expressions({ key:key for key in keys})
784 r = ip.user_expressions({ key:key for key in keys})
770
785
771 nt.assert_equal(keys, set(r.keys()))
786 nt.assert_equal(keys, set(r.keys()))
772 dummy = r['dummy']
787 dummy = r['dummy']
773 nt.assert_equal(set(['status', 'data', 'metadata']), set(dummy.keys()))
788 nt.assert_equal(set(['status', 'data', 'metadata']), set(dummy.keys()))
774 nt.assert_equal(dummy['status'], 'ok')
789 nt.assert_equal(dummy['status'], 'ok')
775 data = dummy['data']
790 data = dummy['data']
776 metadata = dummy['metadata']
791 metadata = dummy['metadata']
777 nt.assert_equal(data.get('text/html'), d._repr_html_())
792 nt.assert_equal(data.get('text/html'), d._repr_html_())
778 js, jsmd = d._repr_javascript_()
793 js, jsmd = d._repr_javascript_()
779 nt.assert_equal(data.get('application/javascript'), js)
794 nt.assert_equal(data.get('application/javascript'), js)
780 nt.assert_equal(metadata.get('application/javascript'), jsmd)
795 nt.assert_equal(metadata.get('application/javascript'), jsmd)
781
796
782 dne = r['doesnotexist']
797 dne = r['doesnotexist']
783 nt.assert_equal(dne['status'], 'error')
798 nt.assert_equal(dne['status'], 'error')
784 nt.assert_equal(dne['ename'], 'NameError')
799 nt.assert_equal(dne['ename'], 'NameError')
785
800
786 # back to text only
801 # back to text only
787 ip.display_formatter.active_types = ['text/plain']
802 ip.display_formatter.active_types = ['text/plain']
788
803
789 def test_user_expression():
804 def test_user_expression():
790 # enable all formatters
805 # enable all formatters
791 ip.display_formatter.active_types = ip.display_formatter.format_types
806 ip.display_formatter.active_types = ip.display_formatter.format_types
792 query = {
807 query = {
793 'a' : '1 + 2',
808 'a' : '1 + 2',
794 'b' : '1/0',
809 'b' : '1/0',
795 }
810 }
796 r = ip.user_expressions(query)
811 r = ip.user_expressions(query)
797 import pprint
812 import pprint
798 pprint.pprint(r)
813 pprint.pprint(r)
799 nt.assert_equal(set(r.keys()), set(query.keys()))
814 nt.assert_equal(set(r.keys()), set(query.keys()))
800 a = r['a']
815 a = r['a']
801 nt.assert_equal(set(['status', 'data', 'metadata']), set(a.keys()))
816 nt.assert_equal(set(['status', 'data', 'metadata']), set(a.keys()))
802 nt.assert_equal(a['status'], 'ok')
817 nt.assert_equal(a['status'], 'ok')
803 data = a['data']
818 data = a['data']
804 metadata = a['metadata']
819 metadata = a['metadata']
805 nt.assert_equal(data.get('text/plain'), '3')
820 nt.assert_equal(data.get('text/plain'), '3')
806
821
807 b = r['b']
822 b = r['b']
808 nt.assert_equal(b['status'], 'error')
823 nt.assert_equal(b['status'], 'error')
809 nt.assert_equal(b['ename'], 'ZeroDivisionError')
824 nt.assert_equal(b['ename'], 'ZeroDivisionError')
810
825
811 # back to text only
826 # back to text only
812 ip.display_formatter.active_types = ['text/plain']
827 ip.display_formatter.active_types = ['text/plain']
813
828
814
829
815
830
816
831
817
832
818 class TestSyntaxErrorTransformer(unittest.TestCase):
833 class TestSyntaxErrorTransformer(unittest.TestCase):
819 """Check that SyntaxError raised by an input transformer is handled by run_cell()"""
834 """Check that SyntaxError raised by an input transformer is handled by run_cell()"""
820
835
821 class SyntaxErrorTransformer(InputTransformer):
836 class SyntaxErrorTransformer(InputTransformer):
822
837
823 def push(self, line):
838 def push(self, line):
824 pos = line.find('syntaxerror')
839 pos = line.find('syntaxerror')
825 if pos >= 0:
840 if pos >= 0:
826 e = SyntaxError('input contains "syntaxerror"')
841 e = SyntaxError('input contains "syntaxerror"')
827 e.text = line
842 e.text = line
828 e.offset = pos + 1
843 e.offset = pos + 1
829 raise e
844 raise e
830 return line
845 return line
831
846
832 def reset(self):
847 def reset(self):
833 pass
848 pass
834
849
835 def setUp(self):
850 def setUp(self):
836 self.transformer = TestSyntaxErrorTransformer.SyntaxErrorTransformer()
851 self.transformer = TestSyntaxErrorTransformer.SyntaxErrorTransformer()
837 ip.input_splitter.python_line_transforms.append(self.transformer)
852 ip.input_splitter.python_line_transforms.append(self.transformer)
838 ip.input_transformer_manager.python_line_transforms.append(self.transformer)
853 ip.input_transformer_manager.python_line_transforms.append(self.transformer)
839
854
840 def tearDown(self):
855 def tearDown(self):
841 ip.input_splitter.python_line_transforms.remove(self.transformer)
856 ip.input_splitter.python_line_transforms.remove(self.transformer)
842 ip.input_transformer_manager.python_line_transforms.remove(self.transformer)
857 ip.input_transformer_manager.python_line_transforms.remove(self.transformer)
843
858
844 def test_syntaxerror_input_transformer(self):
859 def test_syntaxerror_input_transformer(self):
845 with tt.AssertPrints('1234'):
860 with tt.AssertPrints('1234'):
846 ip.run_cell('1234')
861 ip.run_cell('1234')
847 with tt.AssertPrints('SyntaxError: invalid syntax'):
862 with tt.AssertPrints('SyntaxError: invalid syntax'):
848 ip.run_cell('1 2 3') # plain python syntax error
863 ip.run_cell('1 2 3') # plain python syntax error
849 with tt.AssertPrints('SyntaxError: input contains "syntaxerror"'):
864 with tt.AssertPrints('SyntaxError: input contains "syntaxerror"'):
850 ip.run_cell('2345 # syntaxerror') # input transformer syntax error
865 ip.run_cell('2345 # syntaxerror') # input transformer syntax error
851 with tt.AssertPrints('3456'):
866 with tt.AssertPrints('3456'):
852 ip.run_cell('3456')
867 ip.run_cell('3456')
853
868
854
869
855
870
856 def test_warning_suppression():
871 def test_warning_suppression():
857 ip.run_cell("import warnings")
872 ip.run_cell("import warnings")
858 try:
873 try:
859 with tt.AssertPrints("UserWarning: asdf", channel="stderr"):
874 with tt.AssertPrints("UserWarning: asdf", channel="stderr"):
860 ip.run_cell("warnings.warn('asdf')")
875 ip.run_cell("warnings.warn('asdf')")
861 # Here's the real test -- if we run that again, we should get the
876 # Here's the real test -- if we run that again, we should get the
862 # warning again. Traditionally, each warning was only issued once per
877 # warning again. Traditionally, each warning was only issued once per
863 # IPython session (approximately), even if the user typed in new and
878 # IPython session (approximately), even if the user typed in new and
864 # different code that should have also triggered the warning, leading
879 # different code that should have also triggered the warning, leading
865 # to much confusion.
880 # to much confusion.
866 with tt.AssertPrints("UserWarning: asdf", channel="stderr"):
881 with tt.AssertPrints("UserWarning: asdf", channel="stderr"):
867 ip.run_cell("warnings.warn('asdf')")
882 ip.run_cell("warnings.warn('asdf')")
868 finally:
883 finally:
869 ip.run_cell("del warnings")
884 ip.run_cell("del warnings")
@@ -1,578 +1,578 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """terminal client to the IPython kernel"""
2 """terminal client to the IPython kernel"""
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 __future__ import print_function
7 from __future__ import print_function
8
8
9 import base64
9 import base64
10 import bdb
10 import bdb
11 import signal
11 import signal
12 import os
12 import os
13 import sys
13 import sys
14 import time
14 import time
15 import subprocess
15 import subprocess
16 from getpass import getpass
16 from getpass import getpass
17 from io import BytesIO
17 from io import BytesIO
18
18
19 try:
19 try:
20 from queue import Empty # Py 3
20 from queue import Empty # Py 3
21 except ImportError:
21 except ImportError:
22 from Queue import Empty # Py 2
22 from Queue import Empty # Py 2
23
23
24 from IPython.core import page
24 from IPython.core import page
25 from IPython.core import release
25 from IPython.core import release
26 from IPython.terminal.console.zmqhistory import ZMQHistoryManager
26 from IPython.terminal.console.zmqhistory import ZMQHistoryManager
27 from IPython.utils.warn import warn, error
27 from IPython.utils.warn import warn, error
28 from IPython.utils import io
28 from IPython.utils import io
29 from IPython.utils.py3compat import string_types, input
29 from IPython.utils.py3compat import string_types, input
30 from IPython.utils.traitlets import List, Enum, Any, Instance, Unicode, Float, Bool
30 from IPython.utils.traitlets import List, Enum, Any, Instance, Unicode, Float, Bool
31 from IPython.utils.tempdir import NamedFileInTemporaryDirectory
31 from IPython.utils.tempdir import NamedFileInTemporaryDirectory
32
32
33 from IPython.terminal.interactiveshell import TerminalInteractiveShell
33 from IPython.terminal.interactiveshell import TerminalInteractiveShell
34 from IPython.terminal.console.completer import ZMQCompleter
34 from IPython.terminal.console.completer import ZMQCompleter
35
35
36 class ZMQTerminalInteractiveShell(TerminalInteractiveShell):
36 class ZMQTerminalInteractiveShell(TerminalInteractiveShell):
37 """A subclass of TerminalInteractiveShell that uses the 0MQ kernel"""
37 """A subclass of TerminalInteractiveShell that uses the 0MQ kernel"""
38 _executing = False
38 _executing = False
39 _execution_state = Unicode('')
39 _execution_state = Unicode('')
40 _pending_clearoutput = False
40 _pending_clearoutput = False
41 kernel_banner = Unicode('')
41 kernel_banner = Unicode('')
42 kernel_timeout = Float(60, config=True,
42 kernel_timeout = Float(60, config=True,
43 help="""Timeout for giving up on a kernel (in seconds).
43 help="""Timeout for giving up on a kernel (in seconds).
44
44
45 On first connect and restart, the console tests whether the
45 On first connect and restart, the console tests whether the
46 kernel is running and responsive by sending kernel_info_requests.
46 kernel is running and responsive by sending kernel_info_requests.
47 This sets the timeout in seconds for how long the kernel can take
47 This sets the timeout in seconds for how long the kernel can take
48 before being presumed dead.
48 before being presumed dead.
49 """
49 """
50 )
50 )
51
51
52 image_handler = Enum(('PIL', 'stream', 'tempfile', 'callable'),
52 image_handler = Enum(('PIL', 'stream', 'tempfile', 'callable'),
53 config=True, help=
53 config=True, help=
54 """
54 """
55 Handler for image type output. This is useful, for example,
55 Handler for image type output. This is useful, for example,
56 when connecting to the kernel in which pylab inline backend is
56 when connecting to the kernel in which pylab inline backend is
57 activated. There are four handlers defined. 'PIL': Use
57 activated. There are four handlers defined. 'PIL': Use
58 Python Imaging Library to popup image; 'stream': Use an
58 Python Imaging Library to popup image; 'stream': Use an
59 external program to show the image. Image will be fed into
59 external program to show the image. Image will be fed into
60 the STDIN of the program. You will need to configure
60 the STDIN of the program. You will need to configure
61 `stream_image_handler`; 'tempfile': Use an external program to
61 `stream_image_handler`; 'tempfile': Use an external program to
62 show the image. Image will be saved in a temporally file and
62 show the image. Image will be saved in a temporally file and
63 the program is called with the temporally file. You will need
63 the program is called with the temporally file. You will need
64 to configure `tempfile_image_handler`; 'callable': You can set
64 to configure `tempfile_image_handler`; 'callable': You can set
65 any Python callable which is called with the image data. You
65 any Python callable which is called with the image data. You
66 will need to configure `callable_image_handler`.
66 will need to configure `callable_image_handler`.
67 """
67 """
68 )
68 )
69
69
70 stream_image_handler = List(config=True, help=
70 stream_image_handler = List(config=True, help=
71 """
71 """
72 Command to invoke an image viewer program when you are using
72 Command to invoke an image viewer program when you are using
73 'stream' image handler. This option is a list of string where
73 'stream' image handler. This option is a list of string where
74 the first element is the command itself and reminders are the
74 the first element is the command itself and reminders are the
75 options for the command. Raw image data is given as STDIN to
75 options for the command. Raw image data is given as STDIN to
76 the program.
76 the program.
77 """
77 """
78 )
78 )
79
79
80 tempfile_image_handler = List(config=True, help=
80 tempfile_image_handler = List(config=True, help=
81 """
81 """
82 Command to invoke an image viewer program when you are using
82 Command to invoke an image viewer program when you are using
83 'tempfile' image handler. This option is a list of string
83 'tempfile' image handler. This option is a list of string
84 where the first element is the command itself and reminders
84 where the first element is the command itself and reminders
85 are the options for the command. You can use {file} and
85 are the options for the command. You can use {file} and
86 {format} in the string to represent the location of the
86 {format} in the string to represent the location of the
87 generated image file and image format.
87 generated image file and image format.
88 """
88 """
89 )
89 )
90
90
91 callable_image_handler = Any(config=True, help=
91 callable_image_handler = Any(config=True, help=
92 """
92 """
93 Callable object called via 'callable' image handler with one
93 Callable object called via 'callable' image handler with one
94 argument, `data`, which is `msg["content"]["data"]` where
94 argument, `data`, which is `msg["content"]["data"]` where
95 `msg` is the message from iopub channel. For exmaple, you can
95 `msg` is the message from iopub channel. For exmaple, you can
96 find base64 encoded PNG data as `data['image/png']`.
96 find base64 encoded PNG data as `data['image/png']`.
97 """
97 """
98 )
98 )
99
99
100 mime_preference = List(
100 mime_preference = List(
101 default_value=['image/png', 'image/jpeg', 'image/svg+xml'],
101 default_value=['image/png', 'image/jpeg', 'image/svg+xml'],
102 config=True, allow_none=False, help=
102 config=True, allow_none=False, help=
103 """
103 """
104 Preferred object representation MIME type in order. First
104 Preferred object representation MIME type in order. First
105 matched MIME type will be used.
105 matched MIME type will be used.
106 """
106 """
107 )
107 )
108
108
109 manager = Instance('IPython.kernel.KernelManager')
109 manager = Instance('IPython.kernel.KernelManager')
110 client = Instance('IPython.kernel.KernelClient')
110 client = Instance('IPython.kernel.KernelClient')
111 def _client_changed(self, name, old, new):
111 def _client_changed(self, name, old, new):
112 self.session_id = new.session.session
112 self.session_id = new.session.session
113 session_id = Unicode()
113 session_id = Unicode()
114
114
115 def init_completer(self):
115 def init_completer(self):
116 """Initialize the completion machinery.
116 """Initialize the completion machinery.
117
117
118 This creates completion machinery that can be used by client code,
118 This creates completion machinery that can be used by client code,
119 either interactively in-process (typically triggered by the readline
119 either interactively in-process (typically triggered by the readline
120 library), programmatically (such as in test suites) or out-of-process
120 library), programmatically (such as in test suites) or out-of-process
121 (typically over the network by remote frontends).
121 (typically over the network by remote frontends).
122 """
122 """
123 from IPython.core.completerlib import (module_completer,
123 from IPython.core.completerlib import (module_completer,
124 magic_run_completer, cd_completer)
124 magic_run_completer, cd_completer)
125
125
126 self.Completer = ZMQCompleter(self, self.client, config=self.config)
126 self.Completer = ZMQCompleter(self, self.client, config=self.config)
127
127
128
128
129 self.set_hook('complete_command', module_completer, str_key = 'import')
129 self.set_hook('complete_command', module_completer, str_key = 'import')
130 self.set_hook('complete_command', module_completer, str_key = 'from')
130 self.set_hook('complete_command', module_completer, str_key = 'from')
131 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
131 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
132 self.set_hook('complete_command', cd_completer, str_key = '%cd')
132 self.set_hook('complete_command', cd_completer, str_key = '%cd')
133
133
134 # Only configure readline if we truly are using readline. IPython can
134 # Only configure readline if we truly are using readline. IPython can
135 # do tab-completion over the network, in GUIs, etc, where readline
135 # do tab-completion over the network, in GUIs, etc, where readline
136 # itself may be absent
136 # itself may be absent
137 if self.has_readline:
137 if self.has_readline:
138 self.set_readline_completer()
138 self.set_readline_completer()
139
139
140 def run_cell(self, cell, store_history=True):
140 def run_cell(self, cell, store_history=True):
141 """Run a complete IPython cell.
141 """Run a complete IPython cell.
142
142
143 Parameters
143 Parameters
144 ----------
144 ----------
145 cell : str
145 cell : str
146 The code (including IPython code such as %magic functions) to run.
146 The code (including IPython code such as %magic functions) to run.
147 store_history : bool
147 store_history : bool
148 If True, the raw and translated cell will be stored in IPython's
148 If True, the raw and translated cell will be stored in IPython's
149 history. For user code calling back into IPython's machinery, this
149 history. For user code calling back into IPython's machinery, this
150 should be set to False.
150 should be set to False.
151 """
151 """
152 if (not cell) or cell.isspace():
152 if (not cell) or cell.isspace():
153 # pressing enter flushes any pending display
153 # pressing enter flushes any pending display
154 self.handle_iopub()
154 self.handle_iopub()
155 return
155 return
156
156
157 # flush stale replies, which could have been ignored, due to missed heartbeats
157 # flush stale replies, which could have been ignored, due to missed heartbeats
158 while self.client.shell_channel.msg_ready():
158 while self.client.shell_channel.msg_ready():
159 self.client.shell_channel.get_msg()
159 self.client.shell_channel.get_msg()
160 # shell_channel.execute takes 'hidden', which is the inverse of store_hist
160 # shell_channel.execute takes 'hidden', which is the inverse of store_hist
161 msg_id = self.client.shell_channel.execute(cell, not store_history)
161 msg_id = self.client.shell_channel.execute(cell, not store_history)
162
162
163 # first thing is wait for any side effects (output, stdin, etc.)
163 # first thing is wait for any side effects (output, stdin, etc.)
164 self._executing = True
164 self._executing = True
165 self._execution_state = "busy"
165 self._execution_state = "busy"
166 while self._execution_state != 'idle' and self.client.is_alive():
166 while self._execution_state != 'idle' and self.client.is_alive():
167 try:
167 try:
168 self.handle_input_request(msg_id, timeout=0.05)
168 self.handle_input_request(msg_id, timeout=0.05)
169 except Empty:
169 except Empty:
170 # display intermediate print statements, etc.
170 # display intermediate print statements, etc.
171 self.handle_iopub(msg_id)
171 self.handle_iopub(msg_id)
172
172
173 # after all of that is done, wait for the execute reply
173 # after all of that is done, wait for the execute reply
174 while self.client.is_alive():
174 while self.client.is_alive():
175 try:
175 try:
176 self.handle_execute_reply(msg_id, timeout=0.05)
176 self.handle_execute_reply(msg_id, timeout=0.05)
177 except Empty:
177 except Empty:
178 pass
178 pass
179 else:
179 else:
180 break
180 break
181 self._executing = False
181 self._executing = False
182
182
183 #-----------------
183 #-----------------
184 # message handlers
184 # message handlers
185 #-----------------
185 #-----------------
186
186
187 def handle_execute_reply(self, msg_id, timeout=None):
187 def handle_execute_reply(self, msg_id, timeout=None):
188 msg = self.client.shell_channel.get_msg(block=False, timeout=timeout)
188 msg = self.client.shell_channel.get_msg(block=False, timeout=timeout)
189 if msg["parent_header"].get("msg_id", None) == msg_id:
189 if msg["parent_header"].get("msg_id", None) == msg_id:
190
190
191 self.handle_iopub(msg_id)
191 self.handle_iopub(msg_id)
192
192
193 content = msg["content"]
193 content = msg["content"]
194 status = content['status']
194 status = content['status']
195
195
196 if status == 'aborted':
196 if status == 'aborted':
197 self.write('Aborted\n')
197 self.write('Aborted\n')
198 return
198 return
199 elif status == 'ok':
199 elif status == 'ok':
200 # handle payloads
200 # handle payloads
201 for item in content["payload"]:
201 for item in content["payload"]:
202 source = item['source']
202 source = item['source']
203 if source == 'page':
203 if source == 'page':
204 page.page(item['data']['text/plain'])
204 page.page(item['data']['text/plain'])
205 elif source == 'set_next_input':
205 elif source == 'set_next_input':
206 self.set_next_input(item['text'])
206 self.set_next_input(item['text'])
207 elif source == 'ask_exit':
207 elif source == 'ask_exit':
208 self.ask_exit()
208 self.ask_exit()
209
209
210 elif status == 'error':
210 elif status == 'error':
211 for frame in content["traceback"]:
211 for frame in content["traceback"]:
212 print(frame, file=io.stderr)
212 print(frame, file=io.stderr)
213
213
214 self.execution_count = int(content["execution_count"] + 1)
214 self.execution_count = int(content["execution_count"] + 1)
215
215
216 include_other_output = Bool(False, config=True,
216 include_other_output = Bool(False, config=True,
217 help="""Whether to include output from clients
217 help="""Whether to include output from clients
218 other than this one sharing the same kernel.
218 other than this one sharing the same kernel.
219
219
220 Outputs are not displayed until enter is pressed.
220 Outputs are not displayed until enter is pressed.
221 """
221 """
222 )
222 )
223 other_output_prefix = Unicode("[remote] ", config=True,
223 other_output_prefix = Unicode("[remote] ", config=True,
224 help="""Prefix to add to outputs coming from clients other than this one.
224 help="""Prefix to add to outputs coming from clients other than this one.
225
225
226 Only relevant if include_other_output is True.
226 Only relevant if include_other_output is True.
227 """
227 """
228 )
228 )
229
229
230 def from_here(self, msg):
230 def from_here(self, msg):
231 """Return whether a message is from this session"""
231 """Return whether a message is from this session"""
232 return msg['parent_header'].get("session", self.session_id) == self.session_id
232 return msg['parent_header'].get("session", self.session_id) == self.session_id
233
233
234 def include_output(self, msg):
234 def include_output(self, msg):
235 """Return whether we should include a given output message"""
235 """Return whether we should include a given output message"""
236 from_here = self.from_here(msg)
236 from_here = self.from_here(msg)
237 if msg['msg_type'] == 'execute_input':
237 if msg['msg_type'] == 'execute_input':
238 # only echo inputs not from here
238 # only echo inputs not from here
239 return self.include_other_output and not from_here
239 return self.include_other_output and not from_here
240
240
241 if self.include_other_output:
241 if self.include_other_output:
242 return True
242 return True
243 else:
243 else:
244 return from_here
244 return from_here
245
245
246 def handle_iopub(self, msg_id=''):
246 def handle_iopub(self, msg_id=''):
247 """Process messages on the IOPub channel
247 """Process messages on the IOPub channel
248
248
249 This method consumes and processes messages on the IOPub channel,
249 This method consumes and processes messages on the IOPub channel,
250 such as stdout, stderr, execute_result and status.
250 such as stdout, stderr, execute_result and status.
251
251
252 It only displays output that is caused by this session.
252 It only displays output that is caused by this session.
253 """
253 """
254 while self.client.iopub_channel.msg_ready():
254 while self.client.iopub_channel.msg_ready():
255 sub_msg = self.client.iopub_channel.get_msg()
255 sub_msg = self.client.iopub_channel.get_msg()
256 msg_type = sub_msg['header']['msg_type']
256 msg_type = sub_msg['header']['msg_type']
257 parent = sub_msg["parent_header"]
257 parent = sub_msg["parent_header"]
258
258
259 if self.include_output(sub_msg):
259 if self.include_output(sub_msg):
260 if msg_type == 'status':
260 if msg_type == 'status':
261 self._execution_state = sub_msg["content"]["execution_state"]
261 self._execution_state = sub_msg["content"]["execution_state"]
262 elif msg_type == 'stream':
262 elif msg_type == 'stream':
263 if sub_msg["content"]["name"] == "stdout":
263 if sub_msg["content"]["name"] == "stdout":
264 if self._pending_clearoutput:
264 if self._pending_clearoutput:
265 print("\r", file=io.stdout, end="")
265 print("\r", file=io.stdout, end="")
266 self._pending_clearoutput = False
266 self._pending_clearoutput = False
267 print(sub_msg["content"]["text"], file=io.stdout, end="")
267 print(sub_msg["content"]["text"], file=io.stdout, end="")
268 io.stdout.flush()
268 io.stdout.flush()
269 elif sub_msg["content"]["name"] == "stderr":
269 elif sub_msg["content"]["name"] == "stderr":
270 if self._pending_clearoutput:
270 if self._pending_clearoutput:
271 print("\r", file=io.stderr, end="")
271 print("\r", file=io.stderr, end="")
272 self._pending_clearoutput = False
272 self._pending_clearoutput = False
273 print(sub_msg["content"]["text"], file=io.stderr, end="")
273 print(sub_msg["content"]["text"], file=io.stderr, end="")
274 io.stderr.flush()
274 io.stderr.flush()
275
275
276 elif msg_type == 'execute_result':
276 elif msg_type == 'execute_result':
277 if self._pending_clearoutput:
277 if self._pending_clearoutput:
278 print("\r", file=io.stdout, end="")
278 print("\r", file=io.stdout, end="")
279 self._pending_clearoutput = False
279 self._pending_clearoutput = False
280 self.execution_count = int(sub_msg["content"]["execution_count"])
280 self.execution_count = int(sub_msg["content"]["execution_count"])
281 if not self.from_here(sub_msg):
281 if not self.from_here(sub_msg):
282 sys.stdout.write(self.other_output_prefix)
282 sys.stdout.write(self.other_output_prefix)
283 format_dict = sub_msg["content"]["data"]
283 format_dict = sub_msg["content"]["data"]
284 self.handle_rich_data(format_dict)
284 self.handle_rich_data(format_dict)
285
285
286 # taken from DisplayHook.__call__:
286 # taken from DisplayHook.__call__:
287 hook = self.displayhook
287 hook = self.displayhook
288 hook.start_displayhook()
288 hook.start_displayhook()
289 hook.write_output_prompt()
289 hook.write_output_prompt()
290 hook.write_format_data(format_dict)
290 hook.write_format_data(format_dict)
291 hook.log_output(format_dict)
291 hook.log_output(format_dict)
292 hook.finish_displayhook()
292 hook.finish_displayhook()
293
293
294 elif msg_type == 'display_data':
294 elif msg_type == 'display_data':
295 data = sub_msg["content"]["data"]
295 data = sub_msg["content"]["data"]
296 handled = self.handle_rich_data(data)
296 handled = self.handle_rich_data(data)
297 if not handled:
297 if not handled:
298 if not self.from_here(sub_msg):
298 if not self.from_here(sub_msg):
299 sys.stdout.write(self.other_output_prefix)
299 sys.stdout.write(self.other_output_prefix)
300 # if it was an image, we handled it by now
300 # if it was an image, we handled it by now
301 if 'text/plain' in data:
301 if 'text/plain' in data:
302 print(data['text/plain'])
302 print(data['text/plain'])
303
303
304 elif msg_type == 'execute_input':
304 elif msg_type == 'execute_input':
305 content = sub_msg['content']
305 content = sub_msg['content']
306 self.execution_count = content['execution_count']
306 self.execution_count = content['execution_count']
307 if not self.from_here(sub_msg):
307 if not self.from_here(sub_msg):
308 sys.stdout.write(self.other_output_prefix)
308 sys.stdout.write(self.other_output_prefix)
309 sys.stdout.write(self.prompt_manager.render('in'))
309 sys.stdout.write(self.prompt_manager.render('in'))
310 sys.stdout.write(content['code'])
310 sys.stdout.write(content['code'])
311
311
312 elif msg_type == 'clear_output':
312 elif msg_type == 'clear_output':
313 if sub_msg["content"]["wait"]:
313 if sub_msg["content"]["wait"]:
314 self._pending_clearoutput = True
314 self._pending_clearoutput = True
315 else:
315 else:
316 print("\r", file=io.stdout, end="")
316 print("\r", file=io.stdout, end="")
317
317
318 _imagemime = {
318 _imagemime = {
319 'image/png': 'png',
319 'image/png': 'png',
320 'image/jpeg': 'jpeg',
320 'image/jpeg': 'jpeg',
321 'image/svg+xml': 'svg',
321 'image/svg+xml': 'svg',
322 }
322 }
323
323
324 def handle_rich_data(self, data):
324 def handle_rich_data(self, data):
325 for mime in self.mime_preference:
325 for mime in self.mime_preference:
326 if mime in data and mime in self._imagemime:
326 if mime in data and mime in self._imagemime:
327 self.handle_image(data, mime)
327 self.handle_image(data, mime)
328 return True
328 return True
329
329
330 def handle_image(self, data, mime):
330 def handle_image(self, data, mime):
331 handler = getattr(
331 handler = getattr(
332 self, 'handle_image_{0}'.format(self.image_handler), None)
332 self, 'handle_image_{0}'.format(self.image_handler), None)
333 if handler:
333 if handler:
334 handler(data, mime)
334 handler(data, mime)
335
335
336 def handle_image_PIL(self, data, mime):
336 def handle_image_PIL(self, data, mime):
337 if mime not in ('image/png', 'image/jpeg'):
337 if mime not in ('image/png', 'image/jpeg'):
338 return
338 return
339 import PIL.Image
339 import PIL.Image
340 raw = base64.decodestring(data[mime].encode('ascii'))
340 raw = base64.decodestring(data[mime].encode('ascii'))
341 img = PIL.Image.open(BytesIO(raw))
341 img = PIL.Image.open(BytesIO(raw))
342 img.show()
342 img.show()
343
343
344 def handle_image_stream(self, data, mime):
344 def handle_image_stream(self, data, mime):
345 raw = base64.decodestring(data[mime].encode('ascii'))
345 raw = base64.decodestring(data[mime].encode('ascii'))
346 imageformat = self._imagemime[mime]
346 imageformat = self._imagemime[mime]
347 fmt = dict(format=imageformat)
347 fmt = dict(format=imageformat)
348 args = [s.format(**fmt) for s in self.stream_image_handler]
348 args = [s.format(**fmt) for s in self.stream_image_handler]
349 with open(os.devnull, 'w') as devnull:
349 with open(os.devnull, 'w') as devnull:
350 proc = subprocess.Popen(
350 proc = subprocess.Popen(
351 args, stdin=subprocess.PIPE,
351 args, stdin=subprocess.PIPE,
352 stdout=devnull, stderr=devnull)
352 stdout=devnull, stderr=devnull)
353 proc.communicate(raw)
353 proc.communicate(raw)
354
354
355 def handle_image_tempfile(self, data, mime):
355 def handle_image_tempfile(self, data, mime):
356 raw = base64.decodestring(data[mime].encode('ascii'))
356 raw = base64.decodestring(data[mime].encode('ascii'))
357 imageformat = self._imagemime[mime]
357 imageformat = self._imagemime[mime]
358 filename = 'tmp.{0}'.format(imageformat)
358 filename = 'tmp.{0}'.format(imageformat)
359 with NamedFileInTemporaryDirectory(filename) as f, \
359 with NamedFileInTemporaryDirectory(filename) as f, \
360 open(os.devnull, 'w') as devnull:
360 open(os.devnull, 'w') as devnull:
361 f.write(raw)
361 f.write(raw)
362 f.flush()
362 f.flush()
363 fmt = dict(file=f.name, format=imageformat)
363 fmt = dict(file=f.name, format=imageformat)
364 args = [s.format(**fmt) for s in self.tempfile_image_handler]
364 args = [s.format(**fmt) for s in self.tempfile_image_handler]
365 subprocess.call(args, stdout=devnull, stderr=devnull)
365 subprocess.call(args, stdout=devnull, stderr=devnull)
366
366
367 def handle_image_callable(self, data, mime):
367 def handle_image_callable(self, data, mime):
368 self.callable_image_handler(data)
368 self.callable_image_handler(data)
369
369
370 def handle_input_request(self, msg_id, timeout=0.1):
370 def handle_input_request(self, msg_id, timeout=0.1):
371 """ Method to capture raw_input
371 """ Method to capture raw_input
372 """
372 """
373 req = self.client.stdin_channel.get_msg(timeout=timeout)
373 req = self.client.stdin_channel.get_msg(timeout=timeout)
374 # in case any iopub came while we were waiting:
374 # in case any iopub came while we were waiting:
375 self.handle_iopub(msg_id)
375 self.handle_iopub(msg_id)
376 if msg_id == req["parent_header"].get("msg_id"):
376 if msg_id == req["parent_header"].get("msg_id"):
377 # wrap SIGINT handler
377 # wrap SIGINT handler
378 real_handler = signal.getsignal(signal.SIGINT)
378 real_handler = signal.getsignal(signal.SIGINT)
379 def double_int(sig,frame):
379 def double_int(sig,frame):
380 # call real handler (forwards sigint to kernel),
380 # call real handler (forwards sigint to kernel),
381 # then raise local interrupt, stopping local raw_input
381 # then raise local interrupt, stopping local raw_input
382 real_handler(sig,frame)
382 real_handler(sig,frame)
383 raise KeyboardInterrupt
383 raise KeyboardInterrupt
384 signal.signal(signal.SIGINT, double_int)
384 signal.signal(signal.SIGINT, double_int)
385 content = req['content']
385 content = req['content']
386 read = getpass if content.get('password', False) else input
386 read = getpass if content.get('password', False) else input
387 try:
387 try:
388 raw_data = read(content["prompt"])
388 raw_data = read(content["prompt"])
389 except EOFError:
389 except EOFError:
390 # turn EOFError into EOF character
390 # turn EOFError into EOF character
391 raw_data = '\x04'
391 raw_data = '\x04'
392 except KeyboardInterrupt:
392 except KeyboardInterrupt:
393 sys.stdout.write('\n')
393 sys.stdout.write('\n')
394 return
394 return
395 finally:
395 finally:
396 # restore SIGINT handler
396 # restore SIGINT handler
397 signal.signal(signal.SIGINT, real_handler)
397 signal.signal(signal.SIGINT, real_handler)
398
398
399 # only send stdin reply if there *was not* another request
399 # only send stdin reply if there *was not* another request
400 # or execution finished while we were reading.
400 # or execution finished while we were reading.
401 if not (self.client.stdin_channel.msg_ready() or self.client.shell_channel.msg_ready()):
401 if not (self.client.stdin_channel.msg_ready() or self.client.shell_channel.msg_ready()):
402 self.client.stdin_channel.input(raw_data)
402 self.client.stdin_channel.input(raw_data)
403
403
404 def mainloop(self, display_banner=False):
404 def mainloop(self, display_banner=False):
405 while True:
405 while True:
406 try:
406 try:
407 self.interact(display_banner=display_banner)
407 self.interact(display_banner=display_banner)
408 #self.interact_with_readline()
408 #self.interact_with_readline()
409 # XXX for testing of a readline-decoupled repl loop, call
409 # XXX for testing of a readline-decoupled repl loop, call
410 # interact_with_readline above
410 # interact_with_readline above
411 break
411 break
412 except KeyboardInterrupt:
412 except KeyboardInterrupt:
413 # this should not be necessary, but KeyboardInterrupt
413 # this should not be necessary, but KeyboardInterrupt
414 # handling seems rather unpredictable...
414 # handling seems rather unpredictable...
415 self.write("\nKeyboardInterrupt in interact()\n")
415 self.write("\nKeyboardInterrupt in interact()\n")
416
416
417 self.client.shell_channel.shutdown()
417 self.client.shell_channel.shutdown()
418
418
419 def _banner1_default(self):
419 def _banner1_default(self):
420 return "IPython Console {version}\n".format(version=release.version)
420 return "IPython Console {version}\n".format(version=release.version)
421
421
422 def compute_banner(self):
422 def compute_banner(self):
423 super(ZMQTerminalInteractiveShell, self).compute_banner()
423 super(ZMQTerminalInteractiveShell, self).compute_banner()
424 if self.client and not self.kernel_banner:
424 if self.client and not self.kernel_banner:
425 msg_id = self.client.kernel_info()
425 msg_id = self.client.kernel_info()
426 while True:
426 while True:
427 try:
427 try:
428 reply = self.client.get_shell_msg(timeout=1)
428 reply = self.client.get_shell_msg(timeout=1)
429 except Empty:
429 except Empty:
430 break
430 break
431 else:
431 else:
432 if reply['parent_header'].get('msg_id') == msg_id:
432 if reply['parent_header'].get('msg_id') == msg_id:
433 self.kernel_banner = reply['content'].get('banner', '')
433 self.kernel_banner = reply['content'].get('banner', '')
434 break
434 break
435 self.banner += self.kernel_banner
435 self.banner += self.kernel_banner
436
436
437 def wait_for_kernel(self, timeout=None):
437 def wait_for_kernel(self, timeout=None):
438 """method to wait for a kernel to be ready"""
438 """method to wait for a kernel to be ready"""
439 tic = time.time()
439 tic = time.time()
440 self.client.hb_channel.unpause()
440 self.client.hb_channel.unpause()
441 while True:
441 while True:
442 msg_id = self.client.kernel_info()
442 msg_id = self.client.kernel_info()
443 reply = None
443 reply = None
444 while True:
444 while True:
445 try:
445 try:
446 reply = self.client.get_shell_msg(timeout=1)
446 reply = self.client.get_shell_msg(timeout=1)
447 except Empty:
447 except Empty:
448 break
448 break
449 else:
449 else:
450 if reply['parent_header'].get('msg_id') == msg_id:
450 if reply['parent_header'].get('msg_id') == msg_id:
451 return True
451 return True
452 if timeout is not None \
452 if timeout is not None \
453 and (time.time() - tic) > timeout \
453 and (time.time() - tic) > timeout \
454 and not self.client.hb_channel.is_beating():
454 and not self.client.hb_channel.is_beating():
455 # heart failed
455 # heart failed
456 return False
456 return False
457 return True
457 return True
458
458
459 def interact(self, display_banner=None):
459 def interact(self, display_banner=None):
460 """Closely emulate the interactive Python console."""
460 """Closely emulate the interactive Python console."""
461
461
462 # batch run -> do not interact
462 # batch run -> do not interact
463 if self.exit_now:
463 if self.exit_now:
464 return
464 return
465
465
466 if display_banner is None:
466 if display_banner is None:
467 display_banner = self.display_banner
467 display_banner = self.display_banner
468
468
469 if isinstance(display_banner, string_types):
469 if isinstance(display_banner, string_types):
470 self.show_banner(display_banner)
470 self.show_banner(display_banner)
471 elif display_banner:
471 elif display_banner:
472 self.show_banner()
472 self.show_banner()
473
473
474 more = False
474 more = False
475
475
476 # run a non-empty no-op, so that we don't get a prompt until
476 # run a non-empty no-op, so that we don't get a prompt until
477 # we know the kernel is ready. This keeps the connection
477 # we know the kernel is ready. This keeps the connection
478 # message above the first prompt.
478 # message above the first prompt.
479 if not self.wait_for_kernel(self.kernel_timeout):
479 if not self.wait_for_kernel(self.kernel_timeout):
480 error("Kernel did not respond\n")
480 error("Kernel did not respond\n")
481 return
481 return
482
482
483 if self.has_readline:
483 if self.has_readline:
484 self.readline_startup_hook(self.pre_readline)
484 self.readline_startup_hook(self.pre_readline)
485 hlen_b4_cell = self.readline.get_current_history_length()
485 hlen_b4_cell = self.readline.get_current_history_length()
486 else:
486 else:
487 hlen_b4_cell = 0
487 hlen_b4_cell = 0
488 # exit_now is set by a call to %Exit or %Quit, through the
488 # exit_now is set by a call to %Exit or %Quit, through the
489 # ask_exit callback.
489 # ask_exit callback.
490
490
491 while not self.exit_now:
491 while not self.exit_now:
492 if not self.client.is_alive():
492 if not self.client.is_alive():
493 # kernel died, prompt for action or exit
493 # kernel died, prompt for action or exit
494
494
495 action = "restart" if self.manager else "wait for restart"
495 action = "restart" if self.manager else "wait for restart"
496 ans = self.ask_yes_no("kernel died, %s ([y]/n)?" % action, default='y')
496 ans = self.ask_yes_no("kernel died, %s ([y]/n)?" % action, default='y')
497 if ans:
497 if ans:
498 if self.manager:
498 if self.manager:
499 self.manager.restart_kernel(True)
499 self.manager.restart_kernel(True)
500 self.wait_for_kernel(self.kernel_timeout)
500 self.wait_for_kernel(self.kernel_timeout)
501 else:
501 else:
502 self.exit_now = True
502 self.exit_now = True
503 continue
503 continue
504 try:
504 try:
505 # protect prompt block from KeyboardInterrupt
505 # protect prompt block from KeyboardInterrupt
506 # when sitting on ctrl-C
506 # when sitting on ctrl-C
507 self.hooks.pre_prompt_hook()
507 self.hooks.pre_prompt_hook()
508 if more:
508 if more:
509 try:
509 try:
510 prompt = self.prompt_manager.render('in2')
510 prompt = self.prompt_manager.render('in2')
511 except Exception:
511 except Exception:
512 self.showtraceback()
512 self.showtraceback()
513 if self.autoindent:
513 if self.autoindent:
514 self.rl_do_indent = True
514 self.rl_do_indent = True
515
515
516 else:
516 else:
517 try:
517 try:
518 prompt = self.separate_in + self.prompt_manager.render('in')
518 prompt = self.separate_in + self.prompt_manager.render('in')
519 except Exception:
519 except Exception:
520 self.showtraceback()
520 self.showtraceback()
521
521
522 line = self.raw_input(prompt)
522 line = self.raw_input(prompt)
523 if self.exit_now:
523 if self.exit_now:
524 # quick exit on sys.std[in|out] close
524 # quick exit on sys.std[in|out] close
525 break
525 break
526 if self.autoindent:
526 if self.autoindent:
527 self.rl_do_indent = False
527 self.rl_do_indent = False
528
528
529 except KeyboardInterrupt:
529 except KeyboardInterrupt:
530 #double-guard against keyboardinterrupts during kbdint handling
530 #double-guard against keyboardinterrupts during kbdint handling
531 try:
531 try:
532 self.write('\nKeyboardInterrupt\n')
532 self.write('\n' + self.get_exception_only())
533 source_raw = self.input_splitter.raw_reset()
533 source_raw = self.input_splitter.raw_reset()
534 hlen_b4_cell = self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
534 hlen_b4_cell = self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
535 more = False
535 more = False
536 except KeyboardInterrupt:
536 except KeyboardInterrupt:
537 pass
537 pass
538 except EOFError:
538 except EOFError:
539 if self.autoindent:
539 if self.autoindent:
540 self.rl_do_indent = False
540 self.rl_do_indent = False
541 if self.has_readline:
541 if self.has_readline:
542 self.readline_startup_hook(None)
542 self.readline_startup_hook(None)
543 self.write('\n')
543 self.write('\n')
544 self.exit()
544 self.exit()
545 except bdb.BdbQuit:
545 except bdb.BdbQuit:
546 warn('The Python debugger has exited with a BdbQuit exception.\n'
546 warn('The Python debugger has exited with a BdbQuit exception.\n'
547 'Because of how pdb handles the stack, it is impossible\n'
547 'Because of how pdb handles the stack, it is impossible\n'
548 'for IPython to properly format this particular exception.\n'
548 'for IPython to properly format this particular exception.\n'
549 'IPython will resume normal operation.')
549 'IPython will resume normal operation.')
550 except:
550 except:
551 # exceptions here are VERY RARE, but they can be triggered
551 # exceptions here are VERY RARE, but they can be triggered
552 # asynchronously by signal handlers, for example.
552 # asynchronously by signal handlers, for example.
553 self.showtraceback()
553 self.showtraceback()
554 else:
554 else:
555 try:
555 try:
556 self.input_splitter.push(line)
556 self.input_splitter.push(line)
557 more = self.input_splitter.push_accepts_more()
557 more = self.input_splitter.push_accepts_more()
558 except SyntaxError:
558 except SyntaxError:
559 # Run the code directly - run_cell takes care of displaying
559 # Run the code directly - run_cell takes care of displaying
560 # the exception.
560 # the exception.
561 more = False
561 more = False
562 if (self.SyntaxTB.last_syntax_error and
562 if (self.SyntaxTB.last_syntax_error and
563 self.autoedit_syntax):
563 self.autoedit_syntax):
564 self.edit_syntax_error()
564 self.edit_syntax_error()
565 if not more:
565 if not more:
566 source_raw = self.input_splitter.raw_reset()
566 source_raw = self.input_splitter.raw_reset()
567 hlen_b4_cell = self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
567 hlen_b4_cell = self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
568 self.run_cell(source_raw)
568 self.run_cell(source_raw)
569
569
570
570
571 # Turn off the exit flag, so the mainloop can be restarted if desired
571 # Turn off the exit flag, so the mainloop can be restarted if desired
572 self.exit_now = False
572 self.exit_now = False
573
573
574 def init_history(self):
574 def init_history(self):
575 """Sets up the command history. """
575 """Sets up the command history. """
576 self.history_manager = ZMQHistoryManager(client=self.client)
576 self.history_manager = ZMQHistoryManager(client=self.client)
577 self.configurables.append(self.history_manager)
577 self.configurables.append(self.history_manager)
578
578
@@ -1,642 +1,642 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Subclass of InteractiveShell for terminal based frontends."""
2 """Subclass of InteractiveShell for terminal based frontends."""
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 # Imports
14 # Imports
15 #-----------------------------------------------------------------------------
15 #-----------------------------------------------------------------------------
16 from __future__ import print_function
16 from __future__ import print_function
17
17
18 import bdb
18 import bdb
19 import os
19 import os
20 import sys
20 import sys
21
21
22 from IPython.core.error import TryNext, UsageError
22 from IPython.core.error import TryNext, UsageError
23 from IPython.core.usage import interactive_usage
23 from IPython.core.usage import interactive_usage
24 from IPython.core.inputsplitter import IPythonInputSplitter
24 from IPython.core.inputsplitter import IPythonInputSplitter
25 from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
25 from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
26 from IPython.core.magic import Magics, magics_class, line_magic
26 from IPython.core.magic import Magics, magics_class, line_magic
27 from IPython.lib.clipboard import ClipboardEmpty
27 from IPython.lib.clipboard import ClipboardEmpty
28 from IPython.testing.skipdoctest import skip_doctest
28 from IPython.testing.skipdoctest import skip_doctest
29 from IPython.utils.encoding import get_stream_enc
29 from IPython.utils.encoding import get_stream_enc
30 from IPython.utils import py3compat
30 from IPython.utils import py3compat
31 from IPython.utils.terminal import toggle_set_term_title, set_term_title
31 from IPython.utils.terminal import toggle_set_term_title, set_term_title
32 from IPython.utils.process import abbrev_cwd
32 from IPython.utils.process import abbrev_cwd
33 from IPython.utils.warn import warn, error
33 from IPython.utils.warn import warn, error
34 from IPython.utils.text import num_ini_spaces, SList, strip_email_quotes
34 from IPython.utils.text import num_ini_spaces, SList, strip_email_quotes
35 from IPython.utils.traitlets import Integer, CBool, Unicode
35 from IPython.utils.traitlets import Integer, CBool, Unicode
36
36
37 #-----------------------------------------------------------------------------
37 #-----------------------------------------------------------------------------
38 # Utilities
38 # Utilities
39 #-----------------------------------------------------------------------------
39 #-----------------------------------------------------------------------------
40
40
41 def get_default_editor():
41 def get_default_editor():
42 try:
42 try:
43 ed = os.environ['EDITOR']
43 ed = os.environ['EDITOR']
44 if not py3compat.PY3:
44 if not py3compat.PY3:
45 ed = ed.decode()
45 ed = ed.decode()
46 return ed
46 return ed
47 except KeyError:
47 except KeyError:
48 pass
48 pass
49 except UnicodeError:
49 except UnicodeError:
50 warn("$EDITOR environment variable is not pure ASCII. Using platform "
50 warn("$EDITOR environment variable is not pure ASCII. Using platform "
51 "default editor.")
51 "default editor.")
52
52
53 if os.name == 'posix':
53 if os.name == 'posix':
54 return 'vi' # the only one guaranteed to be there!
54 return 'vi' # the only one guaranteed to be there!
55 else:
55 else:
56 return 'notepad' # same in Windows!
56 return 'notepad' # same in Windows!
57
57
58 def get_pasted_lines(sentinel, l_input=py3compat.input, quiet=False):
58 def get_pasted_lines(sentinel, l_input=py3compat.input, quiet=False):
59 """ Yield pasted lines until the user enters the given sentinel value.
59 """ Yield pasted lines until the user enters the given sentinel value.
60 """
60 """
61 if not quiet:
61 if not quiet:
62 print("Pasting code; enter '%s' alone on the line to stop or use Ctrl-D." \
62 print("Pasting code; enter '%s' alone on the line to stop or use Ctrl-D." \
63 % sentinel)
63 % sentinel)
64 prompt = ":"
64 prompt = ":"
65 else:
65 else:
66 prompt = ""
66 prompt = ""
67 while True:
67 while True:
68 try:
68 try:
69 l = l_input(prompt)
69 l = l_input(prompt)
70 if l == sentinel:
70 if l == sentinel:
71 return
71 return
72 else:
72 else:
73 yield l
73 yield l
74 except EOFError:
74 except EOFError:
75 print('<EOF>')
75 print('<EOF>')
76 return
76 return
77
77
78
78
79 #------------------------------------------------------------------------
79 #------------------------------------------------------------------------
80 # Terminal-specific magics
80 # Terminal-specific magics
81 #------------------------------------------------------------------------
81 #------------------------------------------------------------------------
82
82
83 @magics_class
83 @magics_class
84 class TerminalMagics(Magics):
84 class TerminalMagics(Magics):
85 def __init__(self, shell):
85 def __init__(self, shell):
86 super(TerminalMagics, self).__init__(shell)
86 super(TerminalMagics, self).__init__(shell)
87 self.input_splitter = IPythonInputSplitter()
87 self.input_splitter = IPythonInputSplitter()
88
88
89 def store_or_execute(self, block, name):
89 def store_or_execute(self, block, name):
90 """ Execute a block, or store it in a variable, per the user's request.
90 """ Execute a block, or store it in a variable, per the user's request.
91 """
91 """
92 if name:
92 if name:
93 # If storing it for further editing
93 # If storing it for further editing
94 self.shell.user_ns[name] = SList(block.splitlines())
94 self.shell.user_ns[name] = SList(block.splitlines())
95 print("Block assigned to '%s'" % name)
95 print("Block assigned to '%s'" % name)
96 else:
96 else:
97 b = self.preclean_input(block)
97 b = self.preclean_input(block)
98 self.shell.user_ns['pasted_block'] = b
98 self.shell.user_ns['pasted_block'] = b
99 self.shell.using_paste_magics = True
99 self.shell.using_paste_magics = True
100 try:
100 try:
101 self.shell.run_cell(b)
101 self.shell.run_cell(b)
102 finally:
102 finally:
103 self.shell.using_paste_magics = False
103 self.shell.using_paste_magics = False
104
104
105 def preclean_input(self, block):
105 def preclean_input(self, block):
106 lines = block.splitlines()
106 lines = block.splitlines()
107 while lines and not lines[0].strip():
107 while lines and not lines[0].strip():
108 lines = lines[1:]
108 lines = lines[1:]
109 return strip_email_quotes('\n'.join(lines))
109 return strip_email_quotes('\n'.join(lines))
110
110
111 def rerun_pasted(self, name='pasted_block'):
111 def rerun_pasted(self, name='pasted_block'):
112 """ Rerun a previously pasted command.
112 """ Rerun a previously pasted command.
113 """
113 """
114 b = self.shell.user_ns.get(name)
114 b = self.shell.user_ns.get(name)
115
115
116 # Sanity checks
116 # Sanity checks
117 if b is None:
117 if b is None:
118 raise UsageError('No previous pasted block available')
118 raise UsageError('No previous pasted block available')
119 if not isinstance(b, py3compat.string_types):
119 if not isinstance(b, py3compat.string_types):
120 raise UsageError(
120 raise UsageError(
121 "Variable 'pasted_block' is not a string, can't execute")
121 "Variable 'pasted_block' is not a string, can't execute")
122
122
123 print("Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b)))
123 print("Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b)))
124 self.shell.run_cell(b)
124 self.shell.run_cell(b)
125
125
126 @line_magic
126 @line_magic
127 def autoindent(self, parameter_s = ''):
127 def autoindent(self, parameter_s = ''):
128 """Toggle autoindent on/off (if available)."""
128 """Toggle autoindent on/off (if available)."""
129
129
130 self.shell.set_autoindent()
130 self.shell.set_autoindent()
131 print("Automatic indentation is:",['OFF','ON'][self.shell.autoindent])
131 print("Automatic indentation is:",['OFF','ON'][self.shell.autoindent])
132
132
133 @skip_doctest
133 @skip_doctest
134 @line_magic
134 @line_magic
135 def cpaste(self, parameter_s=''):
135 def cpaste(self, parameter_s=''):
136 """Paste & execute a pre-formatted code block from clipboard.
136 """Paste & execute a pre-formatted code block from clipboard.
137
137
138 You must terminate the block with '--' (two minus-signs) or Ctrl-D
138 You must terminate the block with '--' (two minus-signs) or Ctrl-D
139 alone on the line. You can also provide your own sentinel with '%paste
139 alone on the line. You can also provide your own sentinel with '%paste
140 -s %%' ('%%' is the new sentinel for this operation).
140 -s %%' ('%%' is the new sentinel for this operation).
141
141
142 The block is dedented prior to execution to enable execution of method
142 The block is dedented prior to execution to enable execution of method
143 definitions. '>' and '+' characters at the beginning of a line are
143 definitions. '>' and '+' characters at the beginning of a line are
144 ignored, to allow pasting directly from e-mails, diff files and
144 ignored, to allow pasting directly from e-mails, diff files and
145 doctests (the '...' continuation prompt is also stripped). The
145 doctests (the '...' continuation prompt is also stripped). The
146 executed block is also assigned to variable named 'pasted_block' for
146 executed block is also assigned to variable named 'pasted_block' for
147 later editing with '%edit pasted_block'.
147 later editing with '%edit pasted_block'.
148
148
149 You can also pass a variable name as an argument, e.g. '%cpaste foo'.
149 You can also pass a variable name as an argument, e.g. '%cpaste foo'.
150 This assigns the pasted block to variable 'foo' as string, without
150 This assigns the pasted block to variable 'foo' as string, without
151 dedenting or executing it (preceding >>> and + is still stripped)
151 dedenting or executing it (preceding >>> and + is still stripped)
152
152
153 '%cpaste -r' re-executes the block previously entered by cpaste.
153 '%cpaste -r' re-executes the block previously entered by cpaste.
154 '%cpaste -q' suppresses any additional output messages.
154 '%cpaste -q' suppresses any additional output messages.
155
155
156 Do not be alarmed by garbled output on Windows (it's a readline bug).
156 Do not be alarmed by garbled output on Windows (it's a readline bug).
157 Just press enter and type -- (and press enter again) and the block
157 Just press enter and type -- (and press enter again) and the block
158 will be what was just pasted.
158 will be what was just pasted.
159
159
160 IPython statements (magics, shell escapes) are not supported (yet).
160 IPython statements (magics, shell escapes) are not supported (yet).
161
161
162 See also
162 See also
163 --------
163 --------
164 paste: automatically pull code from clipboard.
164 paste: automatically pull code from clipboard.
165
165
166 Examples
166 Examples
167 --------
167 --------
168 ::
168 ::
169
169
170 In [8]: %cpaste
170 In [8]: %cpaste
171 Pasting code; enter '--' alone on the line to stop.
171 Pasting code; enter '--' alone on the line to stop.
172 :>>> a = ["world!", "Hello"]
172 :>>> a = ["world!", "Hello"]
173 :>>> print " ".join(sorted(a))
173 :>>> print " ".join(sorted(a))
174 :--
174 :--
175 Hello world!
175 Hello world!
176 """
176 """
177 opts, name = self.parse_options(parameter_s, 'rqs:', mode='string')
177 opts, name = self.parse_options(parameter_s, 'rqs:', mode='string')
178 if 'r' in opts:
178 if 'r' in opts:
179 self.rerun_pasted()
179 self.rerun_pasted()
180 return
180 return
181
181
182 quiet = ('q' in opts)
182 quiet = ('q' in opts)
183
183
184 sentinel = opts.get('s', '--')
184 sentinel = opts.get('s', '--')
185 block = '\n'.join(get_pasted_lines(sentinel, quiet=quiet))
185 block = '\n'.join(get_pasted_lines(sentinel, quiet=quiet))
186 self.store_or_execute(block, name)
186 self.store_or_execute(block, name)
187
187
188 @line_magic
188 @line_magic
189 def paste(self, parameter_s=''):
189 def paste(self, parameter_s=''):
190 """Paste & execute a pre-formatted code block from clipboard.
190 """Paste & execute a pre-formatted code block from clipboard.
191
191
192 The text is pulled directly from the clipboard without user
192 The text is pulled directly from the clipboard without user
193 intervention and printed back on the screen before execution (unless
193 intervention and printed back on the screen before execution (unless
194 the -q flag is given to force quiet mode).
194 the -q flag is given to force quiet mode).
195
195
196 The block is dedented prior to execution to enable execution of method
196 The block is dedented prior to execution to enable execution of method
197 definitions. '>' and '+' characters at the beginning of a line are
197 definitions. '>' and '+' characters at the beginning of a line are
198 ignored, to allow pasting directly from e-mails, diff files and
198 ignored, to allow pasting directly from e-mails, diff files and
199 doctests (the '...' continuation prompt is also stripped). The
199 doctests (the '...' continuation prompt is also stripped). The
200 executed block is also assigned to variable named 'pasted_block' for
200 executed block is also assigned to variable named 'pasted_block' for
201 later editing with '%edit pasted_block'.
201 later editing with '%edit pasted_block'.
202
202
203 You can also pass a variable name as an argument, e.g. '%paste foo'.
203 You can also pass a variable name as an argument, e.g. '%paste foo'.
204 This assigns the pasted block to variable 'foo' as string, without
204 This assigns the pasted block to variable 'foo' as string, without
205 executing it (preceding >>> and + is still stripped).
205 executing it (preceding >>> and + is still stripped).
206
206
207 Options:
207 Options:
208
208
209 -r: re-executes the block previously entered by cpaste.
209 -r: re-executes the block previously entered by cpaste.
210
210
211 -q: quiet mode: do not echo the pasted text back to the terminal.
211 -q: quiet mode: do not echo the pasted text back to the terminal.
212
212
213 IPython statements (magics, shell escapes) are not supported (yet).
213 IPython statements (magics, shell escapes) are not supported (yet).
214
214
215 See also
215 See also
216 --------
216 --------
217 cpaste: manually paste code into terminal until you mark its end.
217 cpaste: manually paste code into terminal until you mark its end.
218 """
218 """
219 opts, name = self.parse_options(parameter_s, 'rq', mode='string')
219 opts, name = self.parse_options(parameter_s, 'rq', mode='string')
220 if 'r' in opts:
220 if 'r' in opts:
221 self.rerun_pasted()
221 self.rerun_pasted()
222 return
222 return
223 try:
223 try:
224 block = self.shell.hooks.clipboard_get()
224 block = self.shell.hooks.clipboard_get()
225 except TryNext as clipboard_exc:
225 except TryNext as clipboard_exc:
226 message = getattr(clipboard_exc, 'args')
226 message = getattr(clipboard_exc, 'args')
227 if message:
227 if message:
228 error(message[0])
228 error(message[0])
229 else:
229 else:
230 error('Could not get text from the clipboard.')
230 error('Could not get text from the clipboard.')
231 return
231 return
232 except ClipboardEmpty:
232 except ClipboardEmpty:
233 raise UsageError("The clipboard appears to be empty")
233 raise UsageError("The clipboard appears to be empty")
234
234
235 # By default, echo back to terminal unless quiet mode is requested
235 # By default, echo back to terminal unless quiet mode is requested
236 if 'q' not in opts:
236 if 'q' not in opts:
237 write = self.shell.write
237 write = self.shell.write
238 write(self.shell.pycolorize(block))
238 write(self.shell.pycolorize(block))
239 if not block.endswith('\n'):
239 if not block.endswith('\n'):
240 write('\n')
240 write('\n')
241 write("## -- End pasted text --\n")
241 write("## -- End pasted text --\n")
242
242
243 self.store_or_execute(block, name)
243 self.store_or_execute(block, name)
244
244
245 # Class-level: add a '%cls' magic only on Windows
245 # Class-level: add a '%cls' magic only on Windows
246 if sys.platform == 'win32':
246 if sys.platform == 'win32':
247 @line_magic
247 @line_magic
248 def cls(self, s):
248 def cls(self, s):
249 """Clear screen.
249 """Clear screen.
250 """
250 """
251 os.system("cls")
251 os.system("cls")
252
252
253 #-----------------------------------------------------------------------------
253 #-----------------------------------------------------------------------------
254 # Main class
254 # Main class
255 #-----------------------------------------------------------------------------
255 #-----------------------------------------------------------------------------
256
256
257 class TerminalInteractiveShell(InteractiveShell):
257 class TerminalInteractiveShell(InteractiveShell):
258
258
259 autoedit_syntax = CBool(False, config=True,
259 autoedit_syntax = CBool(False, config=True,
260 help="auto editing of files with syntax errors.")
260 help="auto editing of files with syntax errors.")
261 confirm_exit = CBool(True, config=True,
261 confirm_exit = CBool(True, config=True,
262 help="""
262 help="""
263 Set to confirm when you try to exit IPython with an EOF (Control-D
263 Set to confirm when you try to exit IPython with an EOF (Control-D
264 in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
264 in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
265 you can force a direct exit without any confirmation.""",
265 you can force a direct exit without any confirmation.""",
266 )
266 )
267 # This display_banner only controls whether or not self.show_banner()
267 # This display_banner only controls whether or not self.show_banner()
268 # is called when mainloop/interact are called. The default is False
268 # is called when mainloop/interact are called. The default is False
269 # because for the terminal based application, the banner behavior
269 # because for the terminal based application, the banner behavior
270 # is controlled by the application.
270 # is controlled by the application.
271 display_banner = CBool(False) # This isn't configurable!
271 display_banner = CBool(False) # This isn't configurable!
272 embedded = CBool(False)
272 embedded = CBool(False)
273 embedded_active = CBool(False)
273 embedded_active = CBool(False)
274 editor = Unicode(get_default_editor(), config=True,
274 editor = Unicode(get_default_editor(), config=True,
275 help="Set the editor used by IPython (default to $EDITOR/vi/notepad)."
275 help="Set the editor used by IPython (default to $EDITOR/vi/notepad)."
276 )
276 )
277 pager = Unicode('less', config=True,
277 pager = Unicode('less', config=True,
278 help="The shell program to be used for paging.")
278 help="The shell program to be used for paging.")
279
279
280 screen_length = Integer(0, config=True,
280 screen_length = Integer(0, config=True,
281 help=
281 help=
282 """Number of lines of your screen, used to control printing of very
282 """Number of lines of your screen, used to control printing of very
283 long strings. Strings longer than this number of lines will be sent
283 long strings. Strings longer than this number of lines will be sent
284 through a pager instead of directly printed. The default value for
284 through a pager instead of directly printed. The default value for
285 this is 0, which means IPython will auto-detect your screen size every
285 this is 0, which means IPython will auto-detect your screen size every
286 time it needs to print certain potentially long strings (this doesn't
286 time it needs to print certain potentially long strings (this doesn't
287 change the behavior of the 'print' keyword, it's only triggered
287 change the behavior of the 'print' keyword, it's only triggered
288 internally). If for some reason this isn't working well (it needs
288 internally). If for some reason this isn't working well (it needs
289 curses support), specify it yourself. Otherwise don't change the
289 curses support), specify it yourself. Otherwise don't change the
290 default.""",
290 default.""",
291 )
291 )
292 term_title = CBool(False, config=True,
292 term_title = CBool(False, config=True,
293 help="Enable auto setting the terminal title."
293 help="Enable auto setting the terminal title."
294 )
294 )
295 usage = Unicode(interactive_usage)
295 usage = Unicode(interactive_usage)
296
296
297 # This `using_paste_magics` is used to detect whether the code is being
297 # This `using_paste_magics` is used to detect whether the code is being
298 # executed via paste magics functions
298 # executed via paste magics functions
299 using_paste_magics = CBool(False)
299 using_paste_magics = CBool(False)
300
300
301 # In the terminal, GUI control is done via PyOS_InputHook
301 # In the terminal, GUI control is done via PyOS_InputHook
302 @staticmethod
302 @staticmethod
303 def enable_gui(gui=None, app=None):
303 def enable_gui(gui=None, app=None):
304 """Switch amongst GUI input hooks by name.
304 """Switch amongst GUI input hooks by name.
305 """
305 """
306 # Deferred import
306 # Deferred import
307 from IPython.lib.inputhook import enable_gui as real_enable_gui
307 from IPython.lib.inputhook import enable_gui as real_enable_gui
308 try:
308 try:
309 return real_enable_gui(gui, app)
309 return real_enable_gui(gui, app)
310 except ValueError as e:
310 except ValueError as e:
311 raise UsageError("%s" % e)
311 raise UsageError("%s" % e)
312
312
313 system = InteractiveShell.system_raw
313 system = InteractiveShell.system_raw
314
314
315 #-------------------------------------------------------------------------
315 #-------------------------------------------------------------------------
316 # Overrides of init stages
316 # Overrides of init stages
317 #-------------------------------------------------------------------------
317 #-------------------------------------------------------------------------
318
318
319 def init_display_formatter(self):
319 def init_display_formatter(self):
320 super(TerminalInteractiveShell, self).init_display_formatter()
320 super(TerminalInteractiveShell, self).init_display_formatter()
321 # terminal only supports plaintext
321 # terminal only supports plaintext
322 self.display_formatter.active_types = ['text/plain']
322 self.display_formatter.active_types = ['text/plain']
323
323
324 #-------------------------------------------------------------------------
324 #-------------------------------------------------------------------------
325 # Things related to the terminal
325 # Things related to the terminal
326 #-------------------------------------------------------------------------
326 #-------------------------------------------------------------------------
327
327
328 @property
328 @property
329 def usable_screen_length(self):
329 def usable_screen_length(self):
330 if self.screen_length == 0:
330 if self.screen_length == 0:
331 return 0
331 return 0
332 else:
332 else:
333 num_lines_bot = self.separate_in.count('\n')+1
333 num_lines_bot = self.separate_in.count('\n')+1
334 return self.screen_length - num_lines_bot
334 return self.screen_length - num_lines_bot
335
335
336 def _term_title_changed(self, name, new_value):
336 def _term_title_changed(self, name, new_value):
337 self.init_term_title()
337 self.init_term_title()
338
338
339 def init_term_title(self):
339 def init_term_title(self):
340 # Enable or disable the terminal title.
340 # Enable or disable the terminal title.
341 if self.term_title:
341 if self.term_title:
342 toggle_set_term_title(True)
342 toggle_set_term_title(True)
343 set_term_title('IPython: ' + abbrev_cwd())
343 set_term_title('IPython: ' + abbrev_cwd())
344 else:
344 else:
345 toggle_set_term_title(False)
345 toggle_set_term_title(False)
346
346
347 #-------------------------------------------------------------------------
347 #-------------------------------------------------------------------------
348 # Things related to aliases
348 # Things related to aliases
349 #-------------------------------------------------------------------------
349 #-------------------------------------------------------------------------
350
350
351 def init_alias(self):
351 def init_alias(self):
352 # The parent class defines aliases that can be safely used with any
352 # The parent class defines aliases that can be safely used with any
353 # frontend.
353 # frontend.
354 super(TerminalInteractiveShell, self).init_alias()
354 super(TerminalInteractiveShell, self).init_alias()
355
355
356 # Now define aliases that only make sense on the terminal, because they
356 # Now define aliases that only make sense on the terminal, because they
357 # need direct access to the console in a way that we can't emulate in
357 # need direct access to the console in a way that we can't emulate in
358 # GUI or web frontend
358 # GUI or web frontend
359 if os.name == 'posix':
359 if os.name == 'posix':
360 aliases = [('clear', 'clear'), ('more', 'more'), ('less', 'less'),
360 aliases = [('clear', 'clear'), ('more', 'more'), ('less', 'less'),
361 ('man', 'man')]
361 ('man', 'man')]
362 else :
362 else :
363 aliases = []
363 aliases = []
364
364
365 for name, cmd in aliases:
365 for name, cmd in aliases:
366 self.alias_manager.soft_define_alias(name, cmd)
366 self.alias_manager.soft_define_alias(name, cmd)
367
367
368 #-------------------------------------------------------------------------
368 #-------------------------------------------------------------------------
369 # Mainloop and code execution logic
369 # Mainloop and code execution logic
370 #-------------------------------------------------------------------------
370 #-------------------------------------------------------------------------
371
371
372 def mainloop(self, display_banner=None):
372 def mainloop(self, display_banner=None):
373 """Start the mainloop.
373 """Start the mainloop.
374
374
375 If an optional banner argument is given, it will override the
375 If an optional banner argument is given, it will override the
376 internally created default banner.
376 internally created default banner.
377 """
377 """
378
378
379 with self.builtin_trap, self.display_trap:
379 with self.builtin_trap, self.display_trap:
380
380
381 while 1:
381 while 1:
382 try:
382 try:
383 self.interact(display_banner=display_banner)
383 self.interact(display_banner=display_banner)
384 #self.interact_with_readline()
384 #self.interact_with_readline()
385 # XXX for testing of a readline-decoupled repl loop, call
385 # XXX for testing of a readline-decoupled repl loop, call
386 # interact_with_readline above
386 # interact_with_readline above
387 break
387 break
388 except KeyboardInterrupt:
388 except KeyboardInterrupt:
389 # this should not be necessary, but KeyboardInterrupt
389 # this should not be necessary, but KeyboardInterrupt
390 # handling seems rather unpredictable...
390 # handling seems rather unpredictable...
391 self.write("\nKeyboardInterrupt in interact()\n")
391 self.write("\nKeyboardInterrupt in interact()\n")
392
392
393 def _replace_rlhist_multiline(self, source_raw, hlen_before_cell):
393 def _replace_rlhist_multiline(self, source_raw, hlen_before_cell):
394 """Store multiple lines as a single entry in history"""
394 """Store multiple lines as a single entry in history"""
395
395
396 # do nothing without readline or disabled multiline
396 # do nothing without readline or disabled multiline
397 if not self.has_readline or not self.multiline_history:
397 if not self.has_readline or not self.multiline_history:
398 return hlen_before_cell
398 return hlen_before_cell
399
399
400 # windows rl has no remove_history_item
400 # windows rl has no remove_history_item
401 if not hasattr(self.readline, "remove_history_item"):
401 if not hasattr(self.readline, "remove_history_item"):
402 return hlen_before_cell
402 return hlen_before_cell
403
403
404 # skip empty cells
404 # skip empty cells
405 if not source_raw.rstrip():
405 if not source_raw.rstrip():
406 return hlen_before_cell
406 return hlen_before_cell
407
407
408 # nothing changed do nothing, e.g. when rl removes consecutive dups
408 # nothing changed do nothing, e.g. when rl removes consecutive dups
409 hlen = self.readline.get_current_history_length()
409 hlen = self.readline.get_current_history_length()
410 if hlen == hlen_before_cell:
410 if hlen == hlen_before_cell:
411 return hlen_before_cell
411 return hlen_before_cell
412
412
413 for i in range(hlen - hlen_before_cell):
413 for i in range(hlen - hlen_before_cell):
414 self.readline.remove_history_item(hlen - i - 1)
414 self.readline.remove_history_item(hlen - i - 1)
415 stdin_encoding = get_stream_enc(sys.stdin, 'utf-8')
415 stdin_encoding = get_stream_enc(sys.stdin, 'utf-8')
416 self.readline.add_history(py3compat.unicode_to_str(source_raw.rstrip(),
416 self.readline.add_history(py3compat.unicode_to_str(source_raw.rstrip(),
417 stdin_encoding))
417 stdin_encoding))
418 return self.readline.get_current_history_length()
418 return self.readline.get_current_history_length()
419
419
420 def interact(self, display_banner=None):
420 def interact(self, display_banner=None):
421 """Closely emulate the interactive Python console."""
421 """Closely emulate the interactive Python console."""
422
422
423 # batch run -> do not interact
423 # batch run -> do not interact
424 if self.exit_now:
424 if self.exit_now:
425 return
425 return
426
426
427 if display_banner is None:
427 if display_banner is None:
428 display_banner = self.display_banner
428 display_banner = self.display_banner
429
429
430 if isinstance(display_banner, py3compat.string_types):
430 if isinstance(display_banner, py3compat.string_types):
431 self.show_banner(display_banner)
431 self.show_banner(display_banner)
432 elif display_banner:
432 elif display_banner:
433 self.show_banner()
433 self.show_banner()
434
434
435 more = False
435 more = False
436
436
437 if self.has_readline:
437 if self.has_readline:
438 self.readline_startup_hook(self.pre_readline)
438 self.readline_startup_hook(self.pre_readline)
439 hlen_b4_cell = self.readline.get_current_history_length()
439 hlen_b4_cell = self.readline.get_current_history_length()
440 else:
440 else:
441 hlen_b4_cell = 0
441 hlen_b4_cell = 0
442 # exit_now is set by a call to %Exit or %Quit, through the
442 # exit_now is set by a call to %Exit or %Quit, through the
443 # ask_exit callback.
443 # ask_exit callback.
444
444
445 while not self.exit_now:
445 while not self.exit_now:
446 self.hooks.pre_prompt_hook()
446 self.hooks.pre_prompt_hook()
447 if more:
447 if more:
448 try:
448 try:
449 prompt = self.prompt_manager.render('in2')
449 prompt = self.prompt_manager.render('in2')
450 except:
450 except:
451 self.showtraceback()
451 self.showtraceback()
452 if self.autoindent:
452 if self.autoindent:
453 self.rl_do_indent = True
453 self.rl_do_indent = True
454
454
455 else:
455 else:
456 try:
456 try:
457 prompt = self.separate_in + self.prompt_manager.render('in')
457 prompt = self.separate_in + self.prompt_manager.render('in')
458 except:
458 except:
459 self.showtraceback()
459 self.showtraceback()
460 try:
460 try:
461 line = self.raw_input(prompt)
461 line = self.raw_input(prompt)
462 if self.exit_now:
462 if self.exit_now:
463 # quick exit on sys.std[in|out] close
463 # quick exit on sys.std[in|out] close
464 break
464 break
465 if self.autoindent:
465 if self.autoindent:
466 self.rl_do_indent = False
466 self.rl_do_indent = False
467
467
468 except KeyboardInterrupt:
468 except KeyboardInterrupt:
469 #double-guard against keyboardinterrupts during kbdint handling
469 #double-guard against keyboardinterrupts during kbdint handling
470 try:
470 try:
471 self.write('\nKeyboardInterrupt\n')
471 self.write('\n' + self.get_exception_only())
472 source_raw = self.input_splitter.raw_reset()
472 source_raw = self.input_splitter.raw_reset()
473 hlen_b4_cell = \
473 hlen_b4_cell = \
474 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
474 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
475 more = False
475 more = False
476 except KeyboardInterrupt:
476 except KeyboardInterrupt:
477 pass
477 pass
478 except EOFError:
478 except EOFError:
479 if self.autoindent:
479 if self.autoindent:
480 self.rl_do_indent = False
480 self.rl_do_indent = False
481 if self.has_readline:
481 if self.has_readline:
482 self.readline_startup_hook(None)
482 self.readline_startup_hook(None)
483 self.write('\n')
483 self.write('\n')
484 self.exit()
484 self.exit()
485 except bdb.BdbQuit:
485 except bdb.BdbQuit:
486 warn('The Python debugger has exited with a BdbQuit exception.\n'
486 warn('The Python debugger has exited with a BdbQuit exception.\n'
487 'Because of how pdb handles the stack, it is impossible\n'
487 'Because of how pdb handles the stack, it is impossible\n'
488 'for IPython to properly format this particular exception.\n'
488 'for IPython to properly format this particular exception.\n'
489 'IPython will resume normal operation.')
489 'IPython will resume normal operation.')
490 except:
490 except:
491 # exceptions here are VERY RARE, but they can be triggered
491 # exceptions here are VERY RARE, but they can be triggered
492 # asynchronously by signal handlers, for example.
492 # asynchronously by signal handlers, for example.
493 self.showtraceback()
493 self.showtraceback()
494 else:
494 else:
495 try:
495 try:
496 self.input_splitter.push(line)
496 self.input_splitter.push(line)
497 more = self.input_splitter.push_accepts_more()
497 more = self.input_splitter.push_accepts_more()
498 except SyntaxError:
498 except SyntaxError:
499 # Run the code directly - run_cell takes care of displaying
499 # Run the code directly - run_cell takes care of displaying
500 # the exception.
500 # the exception.
501 more = False
501 more = False
502 if (self.SyntaxTB.last_syntax_error and
502 if (self.SyntaxTB.last_syntax_error and
503 self.autoedit_syntax):
503 self.autoedit_syntax):
504 self.edit_syntax_error()
504 self.edit_syntax_error()
505 if not more:
505 if not more:
506 source_raw = self.input_splitter.raw_reset()
506 source_raw = self.input_splitter.raw_reset()
507 self.run_cell(source_raw, store_history=True)
507 self.run_cell(source_raw, store_history=True)
508 hlen_b4_cell = \
508 hlen_b4_cell = \
509 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
509 self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
510
510
511 # Turn off the exit flag, so the mainloop can be restarted if desired
511 # Turn off the exit flag, so the mainloop can be restarted if desired
512 self.exit_now = False
512 self.exit_now = False
513
513
514 def raw_input(self, prompt=''):
514 def raw_input(self, prompt=''):
515 """Write a prompt and read a line.
515 """Write a prompt and read a line.
516
516
517 The returned line does not include the trailing newline.
517 The returned line does not include the trailing newline.
518 When the user enters the EOF key sequence, EOFError is raised.
518 When the user enters the EOF key sequence, EOFError is raised.
519
519
520 Parameters
520 Parameters
521 ----------
521 ----------
522
522
523 prompt : str, optional
523 prompt : str, optional
524 A string to be printed to prompt the user.
524 A string to be printed to prompt the user.
525 """
525 """
526 # raw_input expects str, but we pass it unicode sometimes
526 # raw_input expects str, but we pass it unicode sometimes
527 prompt = py3compat.cast_bytes_py2(prompt)
527 prompt = py3compat.cast_bytes_py2(prompt)
528
528
529 try:
529 try:
530 line = py3compat.str_to_unicode(self.raw_input_original(prompt))
530 line = py3compat.str_to_unicode(self.raw_input_original(prompt))
531 except ValueError:
531 except ValueError:
532 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
532 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
533 " or sys.stdout.close()!\nExiting IPython!\n")
533 " or sys.stdout.close()!\nExiting IPython!\n")
534 self.ask_exit()
534 self.ask_exit()
535 return ""
535 return ""
536
536
537 # Try to be reasonably smart about not re-indenting pasted input more
537 # Try to be reasonably smart about not re-indenting pasted input more
538 # than necessary. We do this by trimming out the auto-indent initial
538 # than necessary. We do this by trimming out the auto-indent initial
539 # spaces, if the user's actual input started itself with whitespace.
539 # spaces, if the user's actual input started itself with whitespace.
540 if self.autoindent:
540 if self.autoindent:
541 if num_ini_spaces(line) > self.indent_current_nsp:
541 if num_ini_spaces(line) > self.indent_current_nsp:
542 line = line[self.indent_current_nsp:]
542 line = line[self.indent_current_nsp:]
543 self.indent_current_nsp = 0
543 self.indent_current_nsp = 0
544
544
545 return line
545 return line
546
546
547 #-------------------------------------------------------------------------
547 #-------------------------------------------------------------------------
548 # Methods to support auto-editing of SyntaxErrors.
548 # Methods to support auto-editing of SyntaxErrors.
549 #-------------------------------------------------------------------------
549 #-------------------------------------------------------------------------
550
550
551 def edit_syntax_error(self):
551 def edit_syntax_error(self):
552 """The bottom half of the syntax error handler called in the main loop.
552 """The bottom half of the syntax error handler called in the main loop.
553
553
554 Loop until syntax error is fixed or user cancels.
554 Loop until syntax error is fixed or user cancels.
555 """
555 """
556
556
557 while self.SyntaxTB.last_syntax_error:
557 while self.SyntaxTB.last_syntax_error:
558 # copy and clear last_syntax_error
558 # copy and clear last_syntax_error
559 err = self.SyntaxTB.clear_err_state()
559 err = self.SyntaxTB.clear_err_state()
560 if not self._should_recompile(err):
560 if not self._should_recompile(err):
561 return
561 return
562 try:
562 try:
563 # may set last_syntax_error again if a SyntaxError is raised
563 # may set last_syntax_error again if a SyntaxError is raised
564 self.safe_execfile(err.filename,self.user_ns)
564 self.safe_execfile(err.filename,self.user_ns)
565 except:
565 except:
566 self.showtraceback()
566 self.showtraceback()
567 else:
567 else:
568 try:
568 try:
569 f = open(err.filename)
569 f = open(err.filename)
570 try:
570 try:
571 # This should be inside a display_trap block and I
571 # This should be inside a display_trap block and I
572 # think it is.
572 # think it is.
573 sys.displayhook(f.read())
573 sys.displayhook(f.read())
574 finally:
574 finally:
575 f.close()
575 f.close()
576 except:
576 except:
577 self.showtraceback()
577 self.showtraceback()
578
578
579 def _should_recompile(self,e):
579 def _should_recompile(self,e):
580 """Utility routine for edit_syntax_error"""
580 """Utility routine for edit_syntax_error"""
581
581
582 if e.filename in ('<ipython console>','<input>','<string>',
582 if e.filename in ('<ipython console>','<input>','<string>',
583 '<console>','<BackgroundJob compilation>',
583 '<console>','<BackgroundJob compilation>',
584 None):
584 None):
585
585
586 return False
586 return False
587 try:
587 try:
588 if (self.autoedit_syntax and
588 if (self.autoedit_syntax and
589 not self.ask_yes_no('Return to editor to correct syntax error? '
589 not self.ask_yes_no('Return to editor to correct syntax error? '
590 '[Y/n] ','y')):
590 '[Y/n] ','y')):
591 return False
591 return False
592 except EOFError:
592 except EOFError:
593 return False
593 return False
594
594
595 def int0(x):
595 def int0(x):
596 try:
596 try:
597 return int(x)
597 return int(x)
598 except TypeError:
598 except TypeError:
599 return 0
599 return 0
600 # always pass integer line and offset values to editor hook
600 # always pass integer line and offset values to editor hook
601 try:
601 try:
602 self.hooks.fix_error_editor(e.filename,
602 self.hooks.fix_error_editor(e.filename,
603 int0(e.lineno),int0(e.offset),e.msg)
603 int0(e.lineno),int0(e.offset),e.msg)
604 except TryNext:
604 except TryNext:
605 warn('Could not open editor')
605 warn('Could not open editor')
606 return False
606 return False
607 return True
607 return True
608
608
609 #-------------------------------------------------------------------------
609 #-------------------------------------------------------------------------
610 # Things related to exiting
610 # Things related to exiting
611 #-------------------------------------------------------------------------
611 #-------------------------------------------------------------------------
612
612
613 def ask_exit(self):
613 def ask_exit(self):
614 """ Ask the shell to exit. Can be overiden and used as a callback. """
614 """ Ask the shell to exit. Can be overiden and used as a callback. """
615 self.exit_now = True
615 self.exit_now = True
616
616
617 def exit(self):
617 def exit(self):
618 """Handle interactive exit.
618 """Handle interactive exit.
619
619
620 This method calls the ask_exit callback."""
620 This method calls the ask_exit callback."""
621 if self.confirm_exit:
621 if self.confirm_exit:
622 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
622 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
623 self.ask_exit()
623 self.ask_exit()
624 else:
624 else:
625 self.ask_exit()
625 self.ask_exit()
626
626
627 #-------------------------------------------------------------------------
627 #-------------------------------------------------------------------------
628 # Things related to magics
628 # Things related to magics
629 #-------------------------------------------------------------------------
629 #-------------------------------------------------------------------------
630
630
631 def init_magics(self):
631 def init_magics(self):
632 super(TerminalInteractiveShell, self).init_magics()
632 super(TerminalInteractiveShell, self).init_magics()
633 self.register_magics(TerminalMagics)
633 self.register_magics(TerminalMagics)
634
634
635 def showindentationerror(self):
635 def showindentationerror(self):
636 super(TerminalInteractiveShell, self).showindentationerror()
636 super(TerminalInteractiveShell, self).showindentationerror()
637 if not self.using_paste_magics:
637 if not self.using_paste_magics:
638 print("If you want to paste code into IPython, try the "
638 print("If you want to paste code into IPython, try the "
639 "%paste and %cpaste magic functions.")
639 "%paste and %cpaste magic functions.")
640
640
641
641
642 InteractiveShellABC.register(TerminalInteractiveShell)
642 InteractiveShellABC.register(TerminalInteractiveShell)
General Comments 0
You need to be logged in to leave comments. Login now