##// END OF EJS Templates
Fixed the %debug magic.
Brian Granger -
Show More
@@ -1,524 +1,479 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
27
28 import bdb
28 import bdb
29 import cmd
29 import cmd
30 import linecache
30 import linecache
31 import os
31 import os
32 import sys
32 import sys
33
33
34 from IPython.utils import PyColorize
34 from IPython.utils import PyColorize
35 from IPython.core import ipapi
35 from IPython.core import ipapi
36 from IPython.utils import coloransi
36 from IPython.utils import coloransi
37 from IPython.utils.genutils import Term
37 from IPython.utils.genutils import Term
38 from IPython.core.excolors import exception_colors
38 from IPython.core.excolors import exception_colors
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):
64 def BdbQuit_excepthook(et,ev,tb):
65 if et==bdb.BdbQuit:
65 if et==bdb.BdbQuit:
66 print 'Exiting Debugger.'
66 print 'Exiting Debugger.'
67 else:
67 else:
68 BdbQuit_excepthook.excepthook_ori(et,ev,tb)
68 BdbQuit_excepthook.excepthook_ori(et,ev,tb)
69
69
70 def BdbQuit_IPython_excepthook(self,et,ev,tb):
70 def BdbQuit_IPython_excepthook(self,et,ev,tb):
71 print 'Exiting Debugger.'
71 print 'Exiting Debugger.'
72
72
73
73 class Tracer(object):
74 class Tracer(object):
74 """Class for local debugging, similar to pdb.set_trace.
75 """Class for local debugging, similar to pdb.set_trace.
75
76
76 Instances of this class, when called, behave like pdb.set_trace, but
77 Instances of this class, when called, behave like pdb.set_trace, but
77 providing IPython's enhanced capabilities.
78 providing IPython's enhanced capabilities.
78
79
79 This is implemented as a class which must be initialized in your own code
80 This is implemented as a class which must be initialized in your own code
80 and not as a standalone function because we need to detect at runtime
81 and not as a standalone function because we need to detect at runtime
81 whether IPython is already active or not. That detection is done in the
82 whether IPython is already active or not. That detection is done in the
82 constructor, ensuring that this code plays nicely with a running IPython,
83 constructor, ensuring that this code plays nicely with a running IPython,
83 while functioning acceptably (though with limitations) if outside of it.
84 while functioning acceptably (though with limitations) if outside of it.
84 """
85 """
85
86
86 def __init__(self,colors=None):
87 def __init__(self,colors=None):
87 """Create a local debugger instance.
88 """Create a local debugger instance.
88
89
89 :Parameters:
90 :Parameters:
90
91
91 - `colors` (None): a string containing the name of the color scheme to
92 - `colors` (None): a string containing the name of the color scheme to
92 use, it must be one of IPython's valid color schemes. If not given, the
93 use, it must be one of IPython's valid color schemes. If not given, the
93 function will default to the current IPython scheme when running inside
94 function will default to the current IPython scheme when running inside
94 IPython, and to 'NoColor' otherwise.
95 IPython, and to 'NoColor' otherwise.
95
96
96 Usage example:
97 Usage example:
97
98
98 from IPython.core.debugger import Tracer; debug_here = Tracer()
99 from IPython.core.debugger import Tracer; debug_here = Tracer()
99
100
100 ... later in your code
101 ... later in your code
101 debug_here() # -> will open up the debugger at that point.
102 debug_here() # -> will open up the debugger at that point.
102
103
103 Once the debugger activates, you can use all of its regular commands to
104 Once the debugger activates, you can use all of its regular commands to
104 step through code, set breakpoints, etc. See the pdb documentation
105 step through code, set breakpoints, etc. See the pdb documentation
105 from the Python standard library for usage details.
106 from the Python standard library for usage details.
106 """
107 """
107
108
108 global __IPYTHON__
109 try:
109 try:
110 __IPYTHON__
110 ip = ipapi.get()
111 except NameError:
111 except:
112 # Outside of ipython, we set our own exception hook manually
112 # Outside of ipython, we set our own exception hook manually
113 __IPYTHON__ = ipapi.get()
114 BdbQuit_excepthook.excepthook_ori = sys.excepthook
113 BdbQuit_excepthook.excepthook_ori = sys.excepthook
115 sys.excepthook = BdbQuit_excepthook
114 sys.excepthook = BdbQuit_excepthook
116 def_colors = 'NoColor'
115 def_colors = 'NoColor'
117 try:
116 try:
118 # Limited tab completion support
117 # Limited tab completion support
119 import readline
118 import readline
120 readline.parse_and_bind('tab: complete')
119 readline.parse_and_bind('tab: complete')
121 except ImportError:
120 except ImportError:
122 pass
121 pass
123 else:
122 else:
124 # In ipython, we use its custom exception handler mechanism
123 # In ipython, we use its custom exception handler mechanism
125 ip = ipapi.get()
126 def_colors = ip.colors
124 def_colors = ip.colors
127 ip.set_custom_exc((bdb.BdbQuit,),BdbQuit_IPython_excepthook)
125 ip.set_custom_exc((bdb.BdbQuit,), BdbQuit_IPython_excepthook)
128
126
129 if colors is None:
127 if colors is None:
130 colors = def_colors
128 colors = def_colors
131 self.debugger = Pdb(colors)
129 self.debugger = Pdb(colors)
132
130
133 def __call__(self):
131 def __call__(self):
134 """Starts an interactive debugger at the point where called.
132 """Starts an interactive debugger at the point where called.
135
133
136 This is similar to the pdb.set_trace() function from the std lib, but
134 This is similar to the pdb.set_trace() function from the std lib, but
137 using IPython's enhanced debugger."""
135 using IPython's enhanced debugger."""
138
136
139 self.debugger.set_trace(sys._getframe().f_back)
137 self.debugger.set_trace(sys._getframe().f_back)
140
138
139
141 def decorate_fn_with_doc(new_fn, old_fn, additional_text=""):
140 def decorate_fn_with_doc(new_fn, old_fn, additional_text=""):
142 """Make new_fn have old_fn's doc string. This is particularly useful
141 """Make new_fn have old_fn's doc string. This is particularly useful
143 for the do_... commands that hook into the help system.
142 for the do_... commands that hook into the help system.
144 Adapted from from a comp.lang.python posting
143 Adapted from from a comp.lang.python posting
145 by Duncan Booth."""
144 by Duncan Booth."""
146 def wrapper(*args, **kw):
145 def wrapper(*args, **kw):
147 return new_fn(*args, **kw)
146 return new_fn(*args, **kw)
148 if old_fn.__doc__:
147 if old_fn.__doc__:
149 wrapper.__doc__ = old_fn.__doc__ + additional_text
148 wrapper.__doc__ = old_fn.__doc__ + additional_text
150 return wrapper
149 return wrapper
151
150
151
152 def _file_lines(fname):
152 def _file_lines(fname):
153 """Return the contents of a named file as a list of lines.
153 """Return the contents of a named file as a list of lines.
154
154
155 This function never raises an IOError exception: if the file can't be
155 This function never raises an IOError exception: if the file can't be
156 read, it simply returns an empty list."""
156 read, it simply returns an empty list."""
157
157
158 try:
158 try:
159 outfile = open(fname)
159 outfile = open(fname)
160 except IOError:
160 except IOError:
161 return []
161 return []
162 else:
162 else:
163 out = outfile.readlines()
163 out = outfile.readlines()
164 outfile.close()
164 outfile.close()
165 return out
165 return out
166
166
167
167 class Pdb(OldPdb):
168 class Pdb(OldPdb):
168 """Modified Pdb class, does not load readline."""
169 """Modified Pdb class, does not load readline."""
169
170
170 if sys.version[:3] >= '2.5' or has_pydb:
171 def __init__(self,color_scheme='NoColor',completekey=None,
171 def __init__(self,color_scheme='NoColor',completekey=None,
172 stdin=None, stdout=None):
172 stdin=None, stdout=None):
173
173
174 # Parent constructor:
174 # Parent constructor:
175 if has_pydb and completekey is None:
175 if has_pydb and completekey is None:
176 OldPdb.__init__(self,stdin=stdin,stdout=Term.cout)
176 OldPdb.__init__(self,stdin=stdin,stdout=Term.cout)
177 else:
177 else:
178 OldPdb.__init__(self,completekey,stdin,stdout)
178 OldPdb.__init__(self,completekey,stdin,stdout)
179
180 self.prompt = prompt # The default prompt is '(Pdb)'
181
179
182 # IPython changes...
180 self.prompt = prompt # The default prompt is '(Pdb)'
183 self.is_pydb = has_pydb
181
184
182 # IPython changes...
185 if self.is_pydb:
183 self.is_pydb = has_pydb
186
187 # iplib.py's ipalias seems to want pdb's checkline
188 # which located in pydb.fn
189 import pydb.fns
190 self.checkline = lambda filename, lineno: \
191 pydb.fns.checkline(self, filename, lineno)
192
193 self.curframe = None
194 self.do_restart = self.new_do_restart
195
196 self.old_all_completions = __IPYTHON__.Completer.all_completions
197 __IPYTHON__.Completer.all_completions=self.all_completions
198
199 self.do_list = decorate_fn_with_doc(self.list_command_pydb,
200 OldPdb.do_list)
201 self.do_l = self.do_list
202 self.do_frame = decorate_fn_with_doc(self.new_do_frame,
203 OldPdb.do_frame)
204
205 self.aliases = {}
206
207 # Create color table: we copy the default one from the traceback
208 # module and add a few attributes needed for debugging
209 self.color_scheme_table = exception_colors()
210
184
211 # shorthands
185 self.shell = ipapi.get()
212 C = coloransi.TermColors
213 cst = self.color_scheme_table
214
186
215 cst['NoColor'].colors.breakpoint_enabled = C.NoColor
187 if self.is_pydb:
216 cst['NoColor'].colors.breakpoint_disabled = C.NoColor
217
188
218 cst['Linux'].colors.breakpoint_enabled = C.LightRed
189 # iplib.py's ipalias seems to want pdb's checkline
219 cst['Linux'].colors.breakpoint_disabled = C.Red
190 # which located in pydb.fn
191 import pydb.fns
192 self.checkline = lambda filename, lineno: \
193 pydb.fns.checkline(self, filename, lineno)
220
194
221 cst['LightBG'].colors.breakpoint_enabled = C.LightRed
195 self.curframe = None
222 cst['LightBG'].colors.breakpoint_disabled = C.Red
196 self.do_restart = self.new_do_restart
223
197
224 self.set_colors(color_scheme)
198 self.old_all_completions = self.shell.Completer.all_completions
199 self.shell.Completer.all_completions=self.all_completions
225
200
226 # Add a python parser so we can syntax highlight source while
201 self.do_list = decorate_fn_with_doc(self.list_command_pydb,
227 # debugging.
202 OldPdb.do_list)
228 self.parser = PyColorize.Parser()
203 self.do_l = self.do_list
204 self.do_frame = decorate_fn_with_doc(self.new_do_frame,
205 OldPdb.do_frame)
229
206
207 self.aliases = {}
230
208
231 else:
209 # Create color table: we copy the default one from the traceback
232 # Ugly hack: for Python 2.3-2.4, we can't call the parent constructor,
210 # module and add a few attributes needed for debugging
233 # because it binds readline and breaks tab-completion. This means we
211 self.color_scheme_table = exception_colors()
234 # have to COPY the constructor here.
235 def __init__(self,color_scheme='NoColor'):
236 bdb.Bdb.__init__(self)
237 cmd.Cmd.__init__(self,completekey=None) # don't load readline
238 self.prompt = 'ipdb> ' # The default prompt is '(Pdb)'
239 self.aliases = {}
240
241 # These two lines are part of the py2.4 constructor, let's put them
242 # unconditionally here as they won't cause any problems in 2.3.
243 self.mainpyfile = ''
244 self._wait_for_mainpyfile = 0
245
246 # Read $HOME/.pdbrc and ./.pdbrc
247 try:
248 self.rcLines = _file_lines(os.path.join(os.environ['HOME'],
249 ".pdbrc"))
250 except KeyError:
251 self.rcLines = []
252 self.rcLines.extend(_file_lines(".pdbrc"))
253
212
254 # Create color table: we copy the default one from the traceback
213 # shorthands
255 # module and add a few attributes needed for debugging
214 C = coloransi.TermColors
256 self.color_scheme_table = exception_colors()
215 cst = self.color_scheme_table
257
216
258 # shorthands
217 cst['NoColor'].colors.breakpoint_enabled = C.NoColor
259 C = coloransi.TermColors
218 cst['NoColor'].colors.breakpoint_disabled = C.NoColor
260 cst = self.color_scheme_table
261
219
262 cst['NoColor'].colors.breakpoint_enabled = C.NoColor
220 cst['Linux'].colors.breakpoint_enabled = C.LightRed
263 cst['NoColor'].colors.breakpoint_disabled = C.NoColor
221 cst['Linux'].colors.breakpoint_disabled = C.Red
264
222
265 cst['Linux'].colors.breakpoint_enabled = C.LightRed
223 cst['LightBG'].colors.breakpoint_enabled = C.LightRed
266 cst['Linux'].colors.breakpoint_disabled = C.Red
224 cst['LightBG'].colors.breakpoint_disabled = C.Red
267
225
268 cst['LightBG'].colors.breakpoint_enabled = C.LightRed
226 self.set_colors(color_scheme)
269 cst['LightBG'].colors.breakpoint_disabled = C.Red
270
227
271 self.set_colors(color_scheme)
228 # Add a python parser so we can syntax highlight source while
229 # debugging.
230 self.parser = PyColorize.Parser()
272
231
273 # Add a python parser so we can syntax highlight source while
274 # debugging.
275 self.parser = PyColorize.Parser()
276
277 def set_colors(self, scheme):
232 def set_colors(self, scheme):
278 """Shorthand access to the color table scheme selector method."""
233 """Shorthand access to the color table scheme selector method."""
279 self.color_scheme_table.set_active_scheme(scheme)
234 self.color_scheme_table.set_active_scheme(scheme)
280
235
281 def interaction(self, frame, traceback):
236 def interaction(self, frame, traceback):
282 __IPYTHON__.set_completer_frame(frame)
237 self.shell.set_completer_frame(frame)
283 OldPdb.interaction(self, frame, traceback)
238 OldPdb.interaction(self, frame, traceback)
284
239
285 def new_do_up(self, arg):
240 def new_do_up(self, arg):
286 OldPdb.do_up(self, arg)
241 OldPdb.do_up(self, arg)
287 __IPYTHON__.set_completer_frame(self.curframe)
242 self.shell.set_completer_frame(self.curframe)
288 do_u = do_up = decorate_fn_with_doc(new_do_up, OldPdb.do_up)
243 do_u = do_up = decorate_fn_with_doc(new_do_up, OldPdb.do_up)
289
244
290 def new_do_down(self, arg):
245 def new_do_down(self, arg):
291 OldPdb.do_down(self, arg)
246 OldPdb.do_down(self, arg)
292 __IPYTHON__.set_completer_frame(self.curframe)
247 self.shell.set_completer_frame(self.curframe)
293
248
294 do_d = do_down = decorate_fn_with_doc(new_do_down, OldPdb.do_down)
249 do_d = do_down = decorate_fn_with_doc(new_do_down, OldPdb.do_down)
295
250
296 def new_do_frame(self, arg):
251 def new_do_frame(self, arg):
297 OldPdb.do_frame(self, arg)
252 OldPdb.do_frame(self, arg)
298 __IPYTHON__.set_completer_frame(self.curframe)
253 self.shell.set_completer_frame(self.curframe)
299
254
300 def new_do_quit(self, arg):
255 def new_do_quit(self, arg):
301
256
302 if hasattr(self, 'old_all_completions'):
257 if hasattr(self, 'old_all_completions'):
303 __IPYTHON__.Completer.all_completions=self.old_all_completions
258 self.shell.Completer.all_completions=self.old_all_completions
304
259
305
260
306 return OldPdb.do_quit(self, arg)
261 return OldPdb.do_quit(self, arg)
307
262
308 do_q = do_quit = decorate_fn_with_doc(new_do_quit, OldPdb.do_quit)
263 do_q = do_quit = decorate_fn_with_doc(new_do_quit, OldPdb.do_quit)
309
264
310 def new_do_restart(self, arg):
265 def new_do_restart(self, arg):
311 """Restart command. In the context of ipython this is exactly the same
266 """Restart command. In the context of ipython this is exactly the same
312 thing as 'quit'."""
267 thing as 'quit'."""
313 self.msg("Restart doesn't make sense here. Using 'quit' instead.")
268 self.msg("Restart doesn't make sense here. Using 'quit' instead.")
314 return self.do_quit(arg)
269 return self.do_quit(arg)
315
270
316 def postloop(self):
271 def postloop(self):
317 __IPYTHON__.set_completer_frame(None)
272 self.shell.set_completer_frame(None)
318
273
319 def print_stack_trace(self):
274 def print_stack_trace(self):
320 try:
275 try:
321 for frame_lineno in self.stack:
276 for frame_lineno in self.stack:
322 self.print_stack_entry(frame_lineno, context = 5)
277 self.print_stack_entry(frame_lineno, context = 5)
323 except KeyboardInterrupt:
278 except KeyboardInterrupt:
324 pass
279 pass
325
280
326 def print_stack_entry(self,frame_lineno,prompt_prefix='\n-> ',
281 def print_stack_entry(self,frame_lineno,prompt_prefix='\n-> ',
327 context = 3):
282 context = 3):
328 #frame, lineno = frame_lineno
283 #frame, lineno = frame_lineno
329 print >>Term.cout, self.format_stack_entry(frame_lineno, '', context)
284 print >>Term.cout, self.format_stack_entry(frame_lineno, '', context)
330
285
331 # vds: >>
286 # vds: >>
332 frame, lineno = frame_lineno
287 frame, lineno = frame_lineno
333 filename = frame.f_code.co_filename
288 filename = frame.f_code.co_filename
334 __IPYTHON__.hooks.synchronize_with_editor(filename, lineno, 0)
289 self.shell.hooks.synchronize_with_editor(filename, lineno, 0)
335 # vds: <<
290 # vds: <<
336
291
337 def format_stack_entry(self, frame_lineno, lprefix=': ', context = 3):
292 def format_stack_entry(self, frame_lineno, lprefix=': ', context = 3):
338 import linecache, repr
293 import linecache, repr
339
294
340 ret = []
295 ret = []
341
296
342 Colors = self.color_scheme_table.active_colors
297 Colors = self.color_scheme_table.active_colors
343 ColorsNormal = Colors.Normal
298 ColorsNormal = Colors.Normal
344 tpl_link = '%s%%s%s' % (Colors.filenameEm, ColorsNormal)
299 tpl_link = '%s%%s%s' % (Colors.filenameEm, ColorsNormal)
345 tpl_call = '%s%%s%s%%s%s' % (Colors.vName, Colors.valEm, ColorsNormal)
300 tpl_call = '%s%%s%s%%s%s' % (Colors.vName, Colors.valEm, ColorsNormal)
346 tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
301 tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
347 tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line,
302 tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line,
348 ColorsNormal)
303 ColorsNormal)
349
304
350 frame, lineno = frame_lineno
305 frame, lineno = frame_lineno
351
306
352 return_value = ''
307 return_value = ''
353 if '__return__' in frame.f_locals:
308 if '__return__' in frame.f_locals:
354 rv = frame.f_locals['__return__']
309 rv = frame.f_locals['__return__']
355 #return_value += '->'
310 #return_value += '->'
356 return_value += repr.repr(rv) + '\n'
311 return_value += repr.repr(rv) + '\n'
357 ret.append(return_value)
312 ret.append(return_value)
358
313
359 #s = filename + '(' + `lineno` + ')'
314 #s = filename + '(' + `lineno` + ')'
360 filename = self.canonic(frame.f_code.co_filename)
315 filename = self.canonic(frame.f_code.co_filename)
361 link = tpl_link % filename
316 link = tpl_link % filename
362
317
363 if frame.f_code.co_name:
318 if frame.f_code.co_name:
364 func = frame.f_code.co_name
319 func = frame.f_code.co_name
365 else:
320 else:
366 func = "<lambda>"
321 func = "<lambda>"
367
322
368 call = ''
323 call = ''
369 if func != '?':
324 if func != '?':
370 if '__args__' in frame.f_locals:
325 if '__args__' in frame.f_locals:
371 args = repr.repr(frame.f_locals['__args__'])
326 args = repr.repr(frame.f_locals['__args__'])
372 else:
327 else:
373 args = '()'
328 args = '()'
374 call = tpl_call % (func, args)
329 call = tpl_call % (func, args)
375
330
376 # The level info should be generated in the same format pdb uses, to
331 # The level info should be generated in the same format pdb uses, to
377 # avoid breaking the pdbtrack functionality of python-mode in *emacs.
332 # avoid breaking the pdbtrack functionality of python-mode in *emacs.
378 if frame is self.curframe:
333 if frame is self.curframe:
379 ret.append('> ')
334 ret.append('> ')
380 else:
335 else:
381 ret.append(' ')
336 ret.append(' ')
382 ret.append('%s(%s)%s\n' % (link,lineno,call))
337 ret.append('%s(%s)%s\n' % (link,lineno,call))
383
338
384 start = lineno - 1 - context//2
339 start = lineno - 1 - context//2
385 lines = linecache.getlines(filename)
340 lines = linecache.getlines(filename)
386 start = max(start, 0)
341 start = max(start, 0)
387 start = min(start, len(lines) - context)
342 start = min(start, len(lines) - context)
388 lines = lines[start : start + context]
343 lines = lines[start : start + context]
389
344
390 for i,line in enumerate(lines):
345 for i,line in enumerate(lines):
391 show_arrow = (start + 1 + i == lineno)
346 show_arrow = (start + 1 + i == lineno)
392 linetpl = (frame is self.curframe or show_arrow) \
347 linetpl = (frame is self.curframe or show_arrow) \
393 and tpl_line_em \
348 and tpl_line_em \
394 or tpl_line
349 or tpl_line
395 ret.append(self.__format_line(linetpl, filename,
350 ret.append(self.__format_line(linetpl, filename,
396 start + 1 + i, line,
351 start + 1 + i, line,
397 arrow = show_arrow) )
352 arrow = show_arrow) )
398
353
399 return ''.join(ret)
354 return ''.join(ret)
400
355
401 def __format_line(self, tpl_line, filename, lineno, line, arrow = False):
356 def __format_line(self, tpl_line, filename, lineno, line, arrow = False):
402 bp_mark = ""
357 bp_mark = ""
403 bp_mark_color = ""
358 bp_mark_color = ""
404
359
405 scheme = self.color_scheme_table.active_scheme_name
360 scheme = self.color_scheme_table.active_scheme_name
406 new_line, err = self.parser.format2(line, 'str', scheme)
361 new_line, err = self.parser.format2(line, 'str', scheme)
407 if not err: line = new_line
362 if not err: line = new_line
408
363
409 bp = None
364 bp = None
410 if lineno in self.get_file_breaks(filename):
365 if lineno in self.get_file_breaks(filename):
411 bps = self.get_breaks(filename, lineno)
366 bps = self.get_breaks(filename, lineno)
412 bp = bps[-1]
367 bp = bps[-1]
413
368
414 if bp:
369 if bp:
415 Colors = self.color_scheme_table.active_colors
370 Colors = self.color_scheme_table.active_colors
416 bp_mark = str(bp.number)
371 bp_mark = str(bp.number)
417 bp_mark_color = Colors.breakpoint_enabled
372 bp_mark_color = Colors.breakpoint_enabled
418 if not bp.enabled:
373 if not bp.enabled:
419 bp_mark_color = Colors.breakpoint_disabled
374 bp_mark_color = Colors.breakpoint_disabled
420
375
421 numbers_width = 7
376 numbers_width = 7
422 if arrow:
377 if arrow:
423 # This is the line with the error
378 # This is the line with the error
424 pad = numbers_width - len(str(lineno)) - len(bp_mark)
379 pad = numbers_width - len(str(lineno)) - len(bp_mark)
425 if pad >= 3:
380 if pad >= 3:
426 marker = '-'*(pad-3) + '-> '
381 marker = '-'*(pad-3) + '-> '
427 elif pad == 2:
382 elif pad == 2:
428 marker = '> '
383 marker = '> '
429 elif pad == 1:
384 elif pad == 1:
430 marker = '>'
385 marker = '>'
431 else:
386 else:
432 marker = ''
387 marker = ''
433 num = '%s%s' % (marker, str(lineno))
388 num = '%s%s' % (marker, str(lineno))
434 line = tpl_line % (bp_mark_color + bp_mark, num, line)
389 line = tpl_line % (bp_mark_color + bp_mark, num, line)
435 else:
390 else:
436 num = '%*s' % (numbers_width - len(bp_mark), str(lineno))
391 num = '%*s' % (numbers_width - len(bp_mark), str(lineno))
437 line = tpl_line % (bp_mark_color + bp_mark, num, line)
392 line = tpl_line % (bp_mark_color + bp_mark, num, line)
438
393
439 return line
394 return line
440
395
441 def list_command_pydb(self, arg):
396 def list_command_pydb(self, arg):
442 """List command to use if we have a newer pydb installed"""
397 """List command to use if we have a newer pydb installed"""
443 filename, first, last = OldPdb.parse_list_cmd(self, arg)
398 filename, first, last = OldPdb.parse_list_cmd(self, arg)
444 if filename is not None:
399 if filename is not None:
445 self.print_list_lines(filename, first, last)
400 self.print_list_lines(filename, first, last)
446
401
447 def print_list_lines(self, filename, first, last):
402 def print_list_lines(self, filename, first, last):
448 """The printing (as opposed to the parsing part of a 'list'
403 """The printing (as opposed to the parsing part of a 'list'
449 command."""
404 command."""
450 try:
405 try:
451 Colors = self.color_scheme_table.active_colors
406 Colors = self.color_scheme_table.active_colors
452 ColorsNormal = Colors.Normal
407 ColorsNormal = Colors.Normal
453 tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
408 tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
454 tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line, ColorsNormal)
409 tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line, ColorsNormal)
455 src = []
410 src = []
456 for lineno in range(first, last+1):
411 for lineno in range(first, last+1):
457 line = linecache.getline(filename, lineno)
412 line = linecache.getline(filename, lineno)
458 if not line:
413 if not line:
459 break
414 break
460
415
461 if lineno == self.curframe.f_lineno:
416 if lineno == self.curframe.f_lineno:
462 line = self.__format_line(tpl_line_em, filename, lineno, line, arrow = True)
417 line = self.__format_line(tpl_line_em, filename, lineno, line, arrow = True)
463 else:
418 else:
464 line = self.__format_line(tpl_line, filename, lineno, line, arrow = False)
419 line = self.__format_line(tpl_line, filename, lineno, line, arrow = False)
465
420
466 src.append(line)
421 src.append(line)
467 self.lineno = lineno
422 self.lineno = lineno
468
423
469 print >>Term.cout, ''.join(src)
424 print >>Term.cout, ''.join(src)
470
425
471 except KeyboardInterrupt:
426 except KeyboardInterrupt:
472 pass
427 pass
473
428
474 def do_list(self, arg):
429 def do_list(self, arg):
475 self.lastcmd = 'list'
430 self.lastcmd = 'list'
476 last = None
431 last = None
477 if arg:
432 if arg:
478 try:
433 try:
479 x = eval(arg, {}, {})
434 x = eval(arg, {}, {})
480 if type(x) == type(()):
435 if type(x) == type(()):
481 first, last = x
436 first, last = x
482 first = int(first)
437 first = int(first)
483 last = int(last)
438 last = int(last)
484 if last < first:
439 if last < first:
485 # Assume it's a count
440 # Assume it's a count
486 last = first + last
441 last = first + last
487 else:
442 else:
488 first = max(1, int(x) - 5)
443 first = max(1, int(x) - 5)
489 except:
444 except:
490 print '*** Error in argument:', `arg`
445 print '*** Error in argument:', `arg`
491 return
446 return
492 elif self.lineno is None:
447 elif self.lineno is None:
493 first = max(1, self.curframe.f_lineno - 5)
448 first = max(1, self.curframe.f_lineno - 5)
494 else:
449 else:
495 first = self.lineno + 1
450 first = self.lineno + 1
496 if last is None:
451 if last is None:
497 last = first + 10
452 last = first + 10
498 self.print_list_lines(self.curframe.f_code.co_filename, first, last)
453 self.print_list_lines(self.curframe.f_code.co_filename, first, last)
499
454
500 # vds: >>
455 # vds: >>
501 lineno = first
456 lineno = first
502 filename = self.curframe.f_code.co_filename
457 filename = self.curframe.f_code.co_filename
503 __IPYTHON__.hooks.synchronize_with_editor(filename, lineno, 0)
458 self.shell.hooks.synchronize_with_editor(filename, lineno, 0)
504 # vds: <<
459 # vds: <<
505
460
506 do_l = do_list
461 do_l = do_list
507
462
508 def do_pdef(self, arg):
463 def do_pdef(self, arg):
509 """The debugger interface to magic_pdef"""
464 """The debugger interface to magic_pdef"""
510 namespaces = [('Locals', self.curframe.f_locals),
465 namespaces = [('Locals', self.curframe.f_locals),
511 ('Globals', self.curframe.f_globals)]
466 ('Globals', self.curframe.f_globals)]
512 __IPYTHON__.magic_pdef(arg, namespaces=namespaces)
467 self.shell.magic_pdef(arg, namespaces=namespaces)
513
468
514 def do_pdoc(self, arg):
469 def do_pdoc(self, arg):
515 """The debugger interface to magic_pdoc"""
470 """The debugger interface to magic_pdoc"""
516 namespaces = [('Locals', self.curframe.f_locals),
471 namespaces = [('Locals', self.curframe.f_locals),
517 ('Globals', self.curframe.f_globals)]
472 ('Globals', self.curframe.f_globals)]
518 __IPYTHON__.magic_pdoc(arg, namespaces=namespaces)
473 self.shell.magic_pdoc(arg, namespaces=namespaces)
519
474
520 def do_pinfo(self, arg):
475 def do_pinfo(self, arg):
521 """The debugger equivalant of ?obj"""
476 """The debugger equivalant of ?obj"""
522 namespaces = [('Locals', self.curframe.f_locals),
477 namespaces = [('Locals', self.curframe.f_locals),
523 ('Globals', self.curframe.f_globals)]
478 ('Globals', self.curframe.f_globals)]
524 __IPYTHON__.magic_pinfo("pinfo %s" % arg, namespaces=namespaces)
479 self.shell.magic_pinfo("pinfo %s" % arg, namespaces=namespaces)
@@ -1,280 +1,272 b''
1 #!/usr/bin/env python
1 #!/usr/bin/env python
2 # encoding: utf-8
2 # encoding: utf-8
3 """
3 """
4 An embedded IPython shell.
4 An embedded IPython shell.
5
5
6 Authors:
6 Authors:
7
7
8 * Brian Granger
8 * Brian Granger
9 * Fernando Perez
9 * Fernando Perez
10
10
11 Notes
11 Notes
12 -----
12 -----
13 """
13 """
14
14
15 #-----------------------------------------------------------------------------
15 #-----------------------------------------------------------------------------
16 # Copyright (C) 2008-2009 The IPython Development Team
16 # Copyright (C) 2008-2009 The IPython Development Team
17 #
17 #
18 # Distributed under the terms of the BSD License. The full license is in
18 # Distributed under the terms of the BSD License. The full license is in
19 # the file COPYING, distributed as part of this software.
19 # the file COPYING, distributed as part of this software.
20 #-----------------------------------------------------------------------------
20 #-----------------------------------------------------------------------------
21
21
22 #-----------------------------------------------------------------------------
22 #-----------------------------------------------------------------------------
23 # Imports
23 # Imports
24 #-----------------------------------------------------------------------------
24 #-----------------------------------------------------------------------------
25
25
26 from __future__ import with_statement
26 from __future__ import with_statement
27
27
28 import sys
28 import sys
29 from contextlib import nested
29 from contextlib import nested
30
30
31 from IPython.core import ultratb
31 from IPython.core import ultratb
32 from IPython.core.iplib import InteractiveShell
32 from IPython.core.iplib import InteractiveShell
33 from IPython.core.ipapp import load_default_config
33 from IPython.core.ipapp import load_default_config
34
34
35 from IPython.utils.traitlets import Bool, Str, CBool
35 from IPython.utils.traitlets import Bool, Str, CBool
36 from IPython.utils.genutils import ask_yes_no
36 from IPython.utils.genutils import ask_yes_no
37
37
38
38
39 #-----------------------------------------------------------------------------
39 #-----------------------------------------------------------------------------
40 # Classes and functions
40 # Classes and functions
41 #-----------------------------------------------------------------------------
41 #-----------------------------------------------------------------------------
42
42
43 # This is an additional magic that is exposed in embedded shells.
43 # This is an additional magic that is exposed in embedded shells.
44 def kill_embedded(self,parameter_s=''):
44 def kill_embedded(self,parameter_s=''):
45 """%kill_embedded : deactivate for good the current embedded IPython.
45 """%kill_embedded : deactivate for good the current embedded IPython.
46
46
47 This function (after asking for confirmation) sets an internal flag so that
47 This function (after asking for confirmation) sets an internal flag so that
48 an embedded IPython will never activate again. This is useful to
48 an embedded IPython will never activate again. This is useful to
49 permanently disable a shell that is being called inside a loop: once you've
49 permanently disable a shell that is being called inside a loop: once you've
50 figured out what you needed from it, you may then kill it and the program
50 figured out what you needed from it, you may then kill it and the program
51 will then continue to run without the interactive shell interfering again.
51 will then continue to run without the interactive shell interfering again.
52 """
52 """
53
53
54 kill = ask_yes_no("Are you sure you want to kill this embedded instance "
54 kill = ask_yes_no("Are you sure you want to kill this embedded instance "
55 "(y/n)? [y/N] ",'n')
55 "(y/n)? [y/N] ",'n')
56 if kill:
56 if kill:
57 self.embedded_active = False
57 self.embedded_active = False
58 print "This embedded IPython will not reactivate anymore once you exit."
58 print "This embedded IPython will not reactivate anymore once you exit."
59
59
60
60
61 class InteractiveShellEmbed(InteractiveShell):
61 class InteractiveShellEmbed(InteractiveShell):
62
62
63 dummy_mode = Bool(False)
63 dummy_mode = Bool(False)
64 exit_msg = Str('')
64 exit_msg = Str('')
65 embedded = CBool(True)
65 embedded = CBool(True)
66 embedded_active = CBool(True)
66 embedded_active = CBool(True)
67 # Like the base class display_banner is not configurable, but here it
67 # Like the base class display_banner is not configurable, but here it
68 # is True by default.
68 # is True by default.
69 display_banner = CBool(True)
69 display_banner = CBool(True)
70
70
71 def __init__(self, parent=None, config=None, ipythondir=None, usage=None,
71 def __init__(self, parent=None, config=None, ipythondir=None, usage=None,
72 user_ns=None, user_global_ns=None,
72 user_ns=None, user_global_ns=None,
73 banner1=None, banner2=None, display_banner=None,
73 banner1=None, banner2=None, display_banner=None,
74 custom_exceptions=((),None), exit_msg=''):
74 custom_exceptions=((),None), exit_msg=''):
75
75
76 self.save_sys_ipcompleter()
76 self.save_sys_ipcompleter()
77
77
78 super(InteractiveShellEmbed,self).__init__(
78 super(InteractiveShellEmbed,self).__init__(
79 parent=parent, config=config, ipythondir=ipythondir, usage=usage,
79 parent=parent, config=config, ipythondir=ipythondir, usage=usage,
80 user_ns=user_ns, user_global_ns=user_global_ns,
80 user_ns=user_ns, user_global_ns=user_global_ns,
81 banner1=banner1, banner2=banner2, display_banner=display_banner,
81 banner1=banner1, banner2=banner2, display_banner=display_banner,
82 custom_exceptions=custom_exceptions)
82 custom_exceptions=custom_exceptions)
83
83
84 self.exit_msg = exit_msg
84 self.exit_msg = exit_msg
85 self.define_magic("kill_embedded", kill_embedded)
85 self.define_magic("kill_embedded", kill_embedded)
86
86
87 # don't use the ipython crash handler so that user exceptions aren't
87 # don't use the ipython crash handler so that user exceptions aren't
88 # trapped
88 # trapped
89 sys.excepthook = ultratb.FormattedTB(color_scheme=self.colors,
89 sys.excepthook = ultratb.FormattedTB(color_scheme=self.colors,
90 mode=self.xmode,
90 mode=self.xmode,
91 call_pdb=self.pdb)
91 call_pdb=self.pdb)
92
92
93 self.restore_sys_ipcompleter()
93 self.restore_sys_ipcompleter()
94
94
95 def init_sys_modules(self):
95 def init_sys_modules(self):
96 pass
96 pass
97
97
98 def save_sys_ipcompleter(self):
98 def save_sys_ipcompleter(self):
99 """Save readline completer status."""
99 """Save readline completer status."""
100 try:
100 try:
101 #print 'Save completer',sys.ipcompleter # dbg
101 #print 'Save completer',sys.ipcompleter # dbg
102 self.sys_ipcompleter_orig = sys.ipcompleter
102 self.sys_ipcompleter_orig = sys.ipcompleter
103 except:
103 except:
104 pass # not nested with IPython
104 pass # not nested with IPython
105
105
106 def restore_sys_ipcompleter(self):
106 def restore_sys_ipcompleter(self):
107 """Restores the readline completer which was in place.
107 """Restores the readline completer which was in place.
108
108
109 This allows embedded IPython within IPython not to disrupt the
109 This allows embedded IPython within IPython not to disrupt the
110 parent's completion.
110 parent's completion.
111 """
111 """
112 try:
112 try:
113 self.readline.set_completer(self.sys_ipcompleter_orig)
113 self.readline.set_completer(self.sys_ipcompleter_orig)
114 sys.ipcompleter = self.sys_ipcompleter_orig
114 sys.ipcompleter = self.sys_ipcompleter_orig
115 except:
115 except:
116 pass
116 pass
117
117
118 def __call__(self, header='', local_ns=None, global_ns=None, dummy=None,
118 def __call__(self, header='', local_ns=None, global_ns=None, dummy=None,
119 stack_depth=1):
119 stack_depth=1):
120 """Activate the interactive interpreter.
120 """Activate the interactive interpreter.
121
121
122 __call__(self,header='',local_ns=None,global_ns,dummy=None) -> Start
122 __call__(self,header='',local_ns=None,global_ns,dummy=None) -> Start
123 the interpreter shell with the given local and global namespaces, and
123 the interpreter shell with the given local and global namespaces, and
124 optionally print a header string at startup.
124 optionally print a header string at startup.
125
125
126 The shell can be globally activated/deactivated using the
126 The shell can be globally activated/deactivated using the
127 set/get_dummy_mode methods. This allows you to turn off a shell used
127 set/get_dummy_mode methods. This allows you to turn off a shell used
128 for debugging globally.
128 for debugging globally.
129
129
130 However, *each* time you call the shell you can override the current
130 However, *each* time you call the shell you can override the current
131 state of dummy_mode with the optional keyword parameter 'dummy'. For
131 state of dummy_mode with the optional keyword parameter 'dummy'. For
132 example, if you set dummy mode on with IPShell.set_dummy_mode(1), you
132 example, if you set dummy mode on with IPShell.set_dummy_mode(1), you
133 can still have a specific call work by making it as IPShell(dummy=0).
133 can still have a specific call work by making it as IPShell(dummy=0).
134
134
135 The optional keyword parameter dummy controls whether the call
135 The optional keyword parameter dummy controls whether the call
136 actually does anything.
136 actually does anything.
137 """
137 """
138
138
139 # If the user has turned it off, go away
139 # If the user has turned it off, go away
140 if not self.embedded_active:
140 if not self.embedded_active:
141 return
141 return
142
142
143 # Normal exits from interactive mode set this flag, so the shell can't
143 # Normal exits from interactive mode set this flag, so the shell can't
144 # re-enter (it checks this variable at the start of interactive mode).
144 # re-enter (it checks this variable at the start of interactive mode).
145 self.exit_now = False
145 self.exit_now = False
146
146
147 # Allow the dummy parameter to override the global __dummy_mode
147 # Allow the dummy parameter to override the global __dummy_mode
148 if dummy or (dummy != 0 and self.dummy_mode):
148 if dummy or (dummy != 0 and self.dummy_mode):
149 return
149 return
150
150
151 if self.has_readline:
151 if self.has_readline:
152 self.set_completer()
152 self.set_completer()
153
153
154 # self.banner is auto computed
154 # self.banner is auto computed
155 if header:
155 if header:
156 self.old_banner2 = self.banner2
156 self.old_banner2 = self.banner2
157 self.banner2 = self.banner2 + '\n' + header + '\n'
157 self.banner2 = self.banner2 + '\n' + header + '\n'
158
158
159 # Call the embedding code with a stack depth of 1 so it can skip over
159 # Call the embedding code with a stack depth of 1 so it can skip over
160 # our call and get the original caller's namespaces.
160 # our call and get the original caller's namespaces.
161 self.mainloop(local_ns, global_ns, stack_depth=stack_depth)
161 self.mainloop(local_ns, global_ns, stack_depth=stack_depth)
162
162
163 self.banner2 = self.old_banner2
163 self.banner2 = self.old_banner2
164
164
165 if self.exit_msg is not None:
165 if self.exit_msg is not None:
166 print self.exit_msg
166 print self.exit_msg
167
167
168 self.restore_sys_ipcompleter()
168 self.restore_sys_ipcompleter()
169
169
170 def mainloop(self, local_ns=None, global_ns=None, stack_depth=0,
170 def mainloop(self, local_ns=None, global_ns=None, stack_depth=0,
171 display_banner=None):
171 display_banner=None):
172 """Embeds IPython into a running python program.
172 """Embeds IPython into a running python program.
173
173
174 Input:
174 Input:
175
175
176 - header: An optional header message can be specified.
176 - header: An optional header message can be specified.
177
177
178 - local_ns, global_ns: working namespaces. If given as None, the
178 - local_ns, global_ns: working namespaces. If given as None, the
179 IPython-initialized one is updated with __main__.__dict__, so that
179 IPython-initialized one is updated with __main__.__dict__, so that
180 program variables become visible but user-specific configuration
180 program variables become visible but user-specific configuration
181 remains possible.
181 remains possible.
182
182
183 - stack_depth: specifies how many levels in the stack to go to
183 - stack_depth: specifies how many levels in the stack to go to
184 looking for namespaces (when local_ns and global_ns are None). This
184 looking for namespaces (when local_ns and global_ns are None). This
185 allows an intermediate caller to make sure that this function gets
185 allows an intermediate caller to make sure that this function gets
186 the namespace from the intended level in the stack. By default (0)
186 the namespace from the intended level in the stack. By default (0)
187 it will get its locals and globals from the immediate caller.
187 it will get its locals and globals from the immediate caller.
188
188
189 Warning: it's possible to use this in a program which is being run by
189 Warning: it's possible to use this in a program which is being run by
190 IPython itself (via %run), but some funny things will happen (a few
190 IPython itself (via %run), but some funny things will happen (a few
191 globals get overwritten). In the future this will be cleaned up, as
191 globals get overwritten). In the future this will be cleaned up, as
192 there is no fundamental reason why it can't work perfectly."""
192 there is no fundamental reason why it can't work perfectly."""
193
193
194 # Get locals and globals from caller
194 # Get locals and globals from caller
195 if local_ns is None or global_ns is None:
195 if local_ns is None or global_ns is None:
196 call_frame = sys._getframe(stack_depth).f_back
196 call_frame = sys._getframe(stack_depth).f_back
197
197
198 if local_ns is None:
198 if local_ns is None:
199 local_ns = call_frame.f_locals
199 local_ns = call_frame.f_locals
200 if global_ns is None:
200 if global_ns is None:
201 global_ns = call_frame.f_globals
201 global_ns = call_frame.f_globals
202
202
203 # Update namespaces and fire up interpreter
203 # Update namespaces and fire up interpreter
204
204
205 # The global one is easy, we can just throw it in
205 # The global one is easy, we can just throw it in
206 self.user_global_ns = global_ns
206 self.user_global_ns = global_ns
207
207
208 # but the user/local one is tricky: ipython needs it to store internal
208 # but the user/local one is tricky: ipython needs it to store internal
209 # data, but we also need the locals. We'll copy locals in the user
209 # data, but we also need the locals. We'll copy locals in the user
210 # one, but will track what got copied so we can delete them at exit.
210 # one, but will track what got copied so we can delete them at exit.
211 # This is so that a later embedded call doesn't see locals from a
211 # This is so that a later embedded call doesn't see locals from a
212 # previous call (which most likely existed in a separate scope).
212 # previous call (which most likely existed in a separate scope).
213 local_varnames = local_ns.keys()
213 local_varnames = local_ns.keys()
214 self.user_ns.update(local_ns)
214 self.user_ns.update(local_ns)
215 #self.user_ns['local_ns'] = local_ns # dbg
215 #self.user_ns['local_ns'] = local_ns # dbg
216
216
217 # Patch for global embedding to make sure that things don't overwrite
217 # Patch for global embedding to make sure that things don't overwrite
218 # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
218 # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
219 # FIXME. Test this a bit more carefully (the if.. is new)
219 # FIXME. Test this a bit more carefully (the if.. is new)
220 if local_ns is None and global_ns is None:
220 if local_ns is None and global_ns is None:
221 self.user_global_ns.update(__main__.__dict__)
221 self.user_global_ns.update(__main__.__dict__)
222
222
223 # make sure the tab-completer has the correct frame information, so it
223 # make sure the tab-completer has the correct frame information, so it
224 # actually completes using the frame's locals/globals
224 # actually completes using the frame's locals/globals
225 self.set_completer_frame()
225 self.set_completer_frame()
226
226
227 with nested(self.builtin_trap, self.display_trap):
227 with nested(self.builtin_trap, self.display_trap):
228 self.interact(display_banner=display_banner)
228 self.interact(display_banner=display_banner)
229
229
230 # now, purge out the user namespace from anything we might have added
230 # now, purge out the user namespace from anything we might have added
231 # from the caller's local namespace
231 # from the caller's local namespace
232 delvar = self.user_ns.pop
232 delvar = self.user_ns.pop
233 for var in local_varnames:
233 for var in local_varnames:
234 delvar(var,None)
234 delvar(var,None)
235
235
236 def set_completer_frame(self, frame=None):
237 if frame:
238 self.Completer.namespace = frame.f_locals
239 self.Completer.global_namespace = frame.f_globals
240 else:
241 self.Completer.namespace = self.user_ns
242 self.Completer.global_namespace = self.user_global_ns
243
244
236
245 _embedded_shell = None
237 _embedded_shell = None
246
238
247
239
248 def embed(header='', config=None, usage=None, banner1=None, banner2=None,
240 def embed(header='', config=None, usage=None, banner1=None, banner2=None,
249 display_banner=True, exit_msg=''):
241 display_banner=True, exit_msg=''):
250 """Call this to embed IPython at the current point in your program.
242 """Call this to embed IPython at the current point in your program.
251
243
252 The first invocation of this will create an :class:`InteractiveShellEmbed`
244 The first invocation of this will create an :class:`InteractiveShellEmbed`
253 instance and then call it. Consecutive calls just call the already
245 instance and then call it. Consecutive calls just call the already
254 created instance.
246 created instance.
255
247
256 Here is a simple example::
248 Here is a simple example::
257
249
258 from IPython import embed
250 from IPython import embed
259 a = 10
251 a = 10
260 b = 20
252 b = 20
261 embed('First time')
253 embed('First time')
262 c = 30
254 c = 30
263 d = 40
255 d = 40
264 embed
256 embed
265
257
266 Full customization can be done by passing a :class:`Struct` in as the
258 Full customization can be done by passing a :class:`Struct` in as the
267 config argument.
259 config argument.
268 """
260 """
269 if config is None:
261 if config is None:
270 config = load_default_config()
262 config = load_default_config()
271 config.InteractiveShellEmbed = config.InteractiveShell
263 config.InteractiveShellEmbed = config.InteractiveShell
272 global _embedded_shell
264 global _embedded_shell
273 if _embedded_shell is None:
265 if _embedded_shell is None:
274 _embedded_shell = InteractiveShellEmbed(
266 _embedded_shell = InteractiveShellEmbed(
275 config=config, usage=usage,
267 config=config, usage=usage,
276 banner1=banner1, banner2=banner2,
268 banner1=banner1, banner2=banner2,
277 display_banner=display_banner, exit_msg=exit_msg
269 display_banner=display_banner, exit_msg=exit_msg
278 )
270 )
279 _embedded_shell(header=header, stack_depth=2)
271 _embedded_shell(header=header, stack_depth=2)
280
272
@@ -1,2470 +1,2477 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """
2 """
3 Main IPython Component
3 Main IPython Component
4 """
4 """
5
5
6 #-----------------------------------------------------------------------------
6 #-----------------------------------------------------------------------------
7 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
7 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
8 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
8 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
9 # Copyright (C) 2008-2009 The IPython Development Team
9 # Copyright (C) 2008-2009 The IPython Development Team
10 #
10 #
11 # Distributed under the terms of the BSD License. The full license is in
11 # Distributed under the terms of the BSD License. The full license is in
12 # the file COPYING, distributed as part of this software.
12 # the file COPYING, distributed as part of this software.
13 #-----------------------------------------------------------------------------
13 #-----------------------------------------------------------------------------
14
14
15 #-----------------------------------------------------------------------------
15 #-----------------------------------------------------------------------------
16 # Imports
16 # Imports
17 #-----------------------------------------------------------------------------
17 #-----------------------------------------------------------------------------
18
18
19 from __future__ import with_statement
19 from __future__ import with_statement
20
20
21 import __builtin__
21 import __builtin__
22 import StringIO
22 import StringIO
23 import bdb
23 import bdb
24 import codeop
24 import codeop
25 import exceptions
25 import exceptions
26 import new
26 import new
27 import os
27 import os
28 import re
28 import re
29 import string
29 import string
30 import sys
30 import sys
31 import tempfile
31 import tempfile
32 from contextlib import nested
32 from contextlib import nested
33
33
34 from IPython.core import ultratb
34 from IPython.core import ultratb
35 from IPython.core import debugger, oinspect
35 from IPython.core import debugger, oinspect
36 from IPython.core import shadowns
36 from IPython.core import shadowns
37 from IPython.core import history as ipcorehist
37 from IPython.core import history as ipcorehist
38 from IPython.core import prefilter
38 from IPython.core import prefilter
39 from IPython.core.alias import AliasManager
39 from IPython.core.alias import AliasManager
40 from IPython.core.builtin_trap import BuiltinTrap
40 from IPython.core.builtin_trap import BuiltinTrap
41 from IPython.core.display_trap import DisplayTrap
41 from IPython.core.display_trap import DisplayTrap
42 from IPython.core.fakemodule import FakeModule, init_fakemod_dict
42 from IPython.core.fakemodule import FakeModule, init_fakemod_dict
43 from IPython.core.logger import Logger
43 from IPython.core.logger import Logger
44 from IPython.core.magic import Magic
44 from IPython.core.magic import Magic
45 from IPython.core.prompts import CachedOutput
45 from IPython.core.prompts import CachedOutput
46 from IPython.core.prefilter import PrefilterManager
46 from IPython.core.prefilter import PrefilterManager
47 from IPython.core.component import Component
47 from IPython.core.component import Component
48 from IPython.core.usage import interactive_usage, default_banner
48 from IPython.core.usage import interactive_usage, default_banner
49 from IPython.core.error import TryNext, UsageError
49 from IPython.core.error import TryNext, UsageError
50
50
51 from IPython.utils import pickleshare
51 from IPython.utils import pickleshare
52 from IPython.external.Itpl import ItplNS
52 from IPython.external.Itpl import ItplNS
53 from IPython.lib.backgroundjobs import BackgroundJobManager
53 from IPython.lib.backgroundjobs import BackgroundJobManager
54 from IPython.utils.ipstruct import Struct
54 from IPython.utils.ipstruct import Struct
55 from IPython.utils import PyColorize
55 from IPython.utils import PyColorize
56 from IPython.utils.genutils import *
56 from IPython.utils.genutils import *
57 from IPython.utils.genutils import get_ipython_dir
57 from IPython.utils.genutils import get_ipython_dir
58 from IPython.utils.platutils import toggle_set_term_title, set_term_title
58 from IPython.utils.platutils import toggle_set_term_title, set_term_title
59 from IPython.utils.strdispatch import StrDispatch
59 from IPython.utils.strdispatch import StrDispatch
60 from IPython.utils.syspathcontext import prepended_to_syspath
60 from IPython.utils.syspathcontext import prepended_to_syspath
61
61
62 # from IPython.utils import growl
62 # from IPython.utils import growl
63 # growl.start("IPython")
63 # growl.start("IPython")
64
64
65 from IPython.utils.traitlets import (
65 from IPython.utils.traitlets import (
66 Int, Str, CBool, CaselessStrEnum, Enum, List, Unicode
66 Int, Str, CBool, CaselessStrEnum, Enum, List, Unicode
67 )
67 )
68
68
69 #-----------------------------------------------------------------------------
69 #-----------------------------------------------------------------------------
70 # Globals
70 # Globals
71 #-----------------------------------------------------------------------------
71 #-----------------------------------------------------------------------------
72
72
73
73
74 # store the builtin raw_input globally, and use this always, in case user code
74 # store the builtin raw_input globally, and use this always, in case user code
75 # overwrites it (like wx.py.PyShell does)
75 # overwrites it (like wx.py.PyShell does)
76 raw_input_original = raw_input
76 raw_input_original = raw_input
77
77
78 # compiled regexps for autoindent management
78 # compiled regexps for autoindent management
79 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
79 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
80
80
81
81
82 #-----------------------------------------------------------------------------
82 #-----------------------------------------------------------------------------
83 # Utilities
83 # Utilities
84 #-----------------------------------------------------------------------------
84 #-----------------------------------------------------------------------------
85
85
86
86
87 ini_spaces_re = re.compile(r'^(\s+)')
87 ini_spaces_re = re.compile(r'^(\s+)')
88
88
89
89
90 def num_ini_spaces(strng):
90 def num_ini_spaces(strng):
91 """Return the number of initial spaces in a string"""
91 """Return the number of initial spaces in a string"""
92
92
93 ini_spaces = ini_spaces_re.match(strng)
93 ini_spaces = ini_spaces_re.match(strng)
94 if ini_spaces:
94 if ini_spaces:
95 return ini_spaces.end()
95 return ini_spaces.end()
96 else:
96 else:
97 return 0
97 return 0
98
98
99
99
100 def softspace(file, newvalue):
100 def softspace(file, newvalue):
101 """Copied from code.py, to remove the dependency"""
101 """Copied from code.py, to remove the dependency"""
102
102
103 oldvalue = 0
103 oldvalue = 0
104 try:
104 try:
105 oldvalue = file.softspace
105 oldvalue = file.softspace
106 except AttributeError:
106 except AttributeError:
107 pass
107 pass
108 try:
108 try:
109 file.softspace = newvalue
109 file.softspace = newvalue
110 except (AttributeError, TypeError):
110 except (AttributeError, TypeError):
111 # "attribute-less object" or "read-only attributes"
111 # "attribute-less object" or "read-only attributes"
112 pass
112 pass
113 return oldvalue
113 return oldvalue
114
114
115
115
116 class SpaceInInput(exceptions.Exception): pass
116 class SpaceInInput(exceptions.Exception): pass
117
117
118 class Bunch: pass
118 class Bunch: pass
119
119
120 class InputList(list):
120 class InputList(list):
121 """Class to store user input.
121 """Class to store user input.
122
122
123 It's basically a list, but slices return a string instead of a list, thus
123 It's basically a list, but slices return a string instead of a list, thus
124 allowing things like (assuming 'In' is an instance):
124 allowing things like (assuming 'In' is an instance):
125
125
126 exec In[4:7]
126 exec In[4:7]
127
127
128 or
128 or
129
129
130 exec In[5:9] + In[14] + In[21:25]"""
130 exec In[5:9] + In[14] + In[21:25]"""
131
131
132 def __getslice__(self,i,j):
132 def __getslice__(self,i,j):
133 return ''.join(list.__getslice__(self,i,j))
133 return ''.join(list.__getslice__(self,i,j))
134
134
135
135
136 class SyntaxTB(ultratb.ListTB):
136 class SyntaxTB(ultratb.ListTB):
137 """Extension which holds some state: the last exception value"""
137 """Extension which holds some state: the last exception value"""
138
138
139 def __init__(self,color_scheme = 'NoColor'):
139 def __init__(self,color_scheme = 'NoColor'):
140 ultratb.ListTB.__init__(self,color_scheme)
140 ultratb.ListTB.__init__(self,color_scheme)
141 self.last_syntax_error = None
141 self.last_syntax_error = None
142
142
143 def __call__(self, etype, value, elist):
143 def __call__(self, etype, value, elist):
144 self.last_syntax_error = value
144 self.last_syntax_error = value
145 ultratb.ListTB.__call__(self,etype,value,elist)
145 ultratb.ListTB.__call__(self,etype,value,elist)
146
146
147 def clear_err_state(self):
147 def clear_err_state(self):
148 """Return the current error state and clear it"""
148 """Return the current error state and clear it"""
149 e = self.last_syntax_error
149 e = self.last_syntax_error
150 self.last_syntax_error = None
150 self.last_syntax_error = None
151 return e
151 return e
152
152
153
153
154 def get_default_editor():
154 def get_default_editor():
155 try:
155 try:
156 ed = os.environ['EDITOR']
156 ed = os.environ['EDITOR']
157 except KeyError:
157 except KeyError:
158 if os.name == 'posix':
158 if os.name == 'posix':
159 ed = 'vi' # the only one guaranteed to be there!
159 ed = 'vi' # the only one guaranteed to be there!
160 else:
160 else:
161 ed = 'notepad' # same in Windows!
161 ed = 'notepad' # same in Windows!
162 return ed
162 return ed
163
163
164
164
165 class SeparateStr(Str):
165 class SeparateStr(Str):
166 """A Str subclass to validate separate_in, separate_out, etc.
166 """A Str subclass to validate separate_in, separate_out, etc.
167
167
168 This is a Str based traitlet that converts '0'->'' and '\\n'->'\n'.
168 This is a Str based traitlet that converts '0'->'' and '\\n'->'\n'.
169 """
169 """
170
170
171 def validate(self, obj, value):
171 def validate(self, obj, value):
172 if value == '0': value = ''
172 if value == '0': value = ''
173 value = value.replace('\\n','\n')
173 value = value.replace('\\n','\n')
174 return super(SeparateStr, self).validate(obj, value)
174 return super(SeparateStr, self).validate(obj, value)
175
175
176
176
177 #-----------------------------------------------------------------------------
177 #-----------------------------------------------------------------------------
178 # Main IPython class
178 # Main IPython class
179 #-----------------------------------------------------------------------------
179 #-----------------------------------------------------------------------------
180
180
181
181
182 class InteractiveShell(Component, Magic):
182 class InteractiveShell(Component, Magic):
183 """An enhanced, interactive shell for Python."""
183 """An enhanced, interactive shell for Python."""
184
184
185 autocall = Enum((0,1,2), config=True)
185 autocall = Enum((0,1,2), config=True)
186 autoedit_syntax = CBool(False, config=True)
186 autoedit_syntax = CBool(False, config=True)
187 autoindent = CBool(True, config=True)
187 autoindent = CBool(True, config=True)
188 automagic = CBool(True, config=True)
188 automagic = CBool(True, config=True)
189 banner = Str('')
189 banner = Str('')
190 banner1 = Str(default_banner, config=True)
190 banner1 = Str(default_banner, config=True)
191 banner2 = Str('', config=True)
191 banner2 = Str('', config=True)
192 cache_size = Int(1000, config=True)
192 cache_size = Int(1000, config=True)
193 color_info = CBool(True, config=True)
193 color_info = CBool(True, config=True)
194 colors = CaselessStrEnum(('NoColor','LightBG','Linux'),
194 colors = CaselessStrEnum(('NoColor','LightBG','Linux'),
195 default_value='LightBG', config=True)
195 default_value='LightBG', config=True)
196 confirm_exit = CBool(True, config=True)
196 confirm_exit = CBool(True, config=True)
197 debug = CBool(False, config=True)
197 debug = CBool(False, config=True)
198 deep_reload = CBool(False, config=True)
198 deep_reload = CBool(False, config=True)
199 # This display_banner only controls whether or not self.show_banner()
199 # This display_banner only controls whether or not self.show_banner()
200 # is called when mainloop/interact are called. The default is False
200 # is called when mainloop/interact are called. The default is False
201 # because for the terminal based application, the banner behavior
201 # because for the terminal based application, the banner behavior
202 # is controlled by Global.display_banner, which IPythonApp looks at
202 # is controlled by Global.display_banner, which IPythonApp looks at
203 # to determine if *it* should call show_banner() by hand or not.
203 # to determine if *it* should call show_banner() by hand or not.
204 display_banner = CBool(False) # This isn't configurable!
204 display_banner = CBool(False) # This isn't configurable!
205 embedded = CBool(False)
205 embedded = CBool(False)
206 embedded_active = CBool(False)
206 embedded_active = CBool(False)
207 editor = Str(get_default_editor(), config=True)
207 editor = Str(get_default_editor(), config=True)
208 filename = Str("<ipython console>")
208 filename = Str("<ipython console>")
209 ipythondir= Unicode('', config=True) # Set to get_ipython_dir() in __init__
209 ipythondir= Unicode('', config=True) # Set to get_ipython_dir() in __init__
210 logstart = CBool(False, config=True)
210 logstart = CBool(False, config=True)
211 logfile = Str('', config=True)
211 logfile = Str('', config=True)
212 logappend = Str('', config=True)
212 logappend = Str('', config=True)
213 object_info_string_level = Enum((0,1,2), default_value=0,
213 object_info_string_level = Enum((0,1,2), default_value=0,
214 config=True)
214 config=True)
215 pager = Str('less', config=True)
215 pager = Str('less', config=True)
216 pdb = CBool(False, config=True)
216 pdb = CBool(False, config=True)
217 pprint = CBool(True, config=True)
217 pprint = CBool(True, config=True)
218 profile = Str('', config=True)
218 profile = Str('', config=True)
219 prompt_in1 = Str('In [\\#]: ', config=True)
219 prompt_in1 = Str('In [\\#]: ', config=True)
220 prompt_in2 = Str(' .\\D.: ', config=True)
220 prompt_in2 = Str(' .\\D.: ', config=True)
221 prompt_out = Str('Out[\\#]: ', config=True)
221 prompt_out = Str('Out[\\#]: ', config=True)
222 prompts_pad_left = CBool(True, config=True)
222 prompts_pad_left = CBool(True, config=True)
223 quiet = CBool(False, config=True)
223 quiet = CBool(False, config=True)
224
224
225 readline_use = CBool(True, config=True)
225 readline_use = CBool(True, config=True)
226 readline_merge_completions = CBool(True, config=True)
226 readline_merge_completions = CBool(True, config=True)
227 readline_omit__names = Enum((0,1,2), default_value=0, config=True)
227 readline_omit__names = Enum((0,1,2), default_value=0, config=True)
228 readline_remove_delims = Str('-/~', config=True)
228 readline_remove_delims = Str('-/~', config=True)
229 readline_parse_and_bind = List([
229 readline_parse_and_bind = List([
230 'tab: complete',
230 'tab: complete',
231 '"\C-l": possible-completions',
231 '"\C-l": possible-completions',
232 'set show-all-if-ambiguous on',
232 'set show-all-if-ambiguous on',
233 '"\C-o": tab-insert',
233 '"\C-o": tab-insert',
234 '"\M-i": " "',
234 '"\M-i": " "',
235 '"\M-o": "\d\d\d\d"',
235 '"\M-o": "\d\d\d\d"',
236 '"\M-I": "\d\d\d\d"',
236 '"\M-I": "\d\d\d\d"',
237 '"\C-r": reverse-search-history',
237 '"\C-r": reverse-search-history',
238 '"\C-s": forward-search-history',
238 '"\C-s": forward-search-history',
239 '"\C-p": history-search-backward',
239 '"\C-p": history-search-backward',
240 '"\C-n": history-search-forward',
240 '"\C-n": history-search-forward',
241 '"\e[A": history-search-backward',
241 '"\e[A": history-search-backward',
242 '"\e[B": history-search-forward',
242 '"\e[B": history-search-forward',
243 '"\C-k": kill-line',
243 '"\C-k": kill-line',
244 '"\C-u": unix-line-discard',
244 '"\C-u": unix-line-discard',
245 ], allow_none=False, config=True)
245 ], allow_none=False, config=True)
246
246
247 screen_length = Int(0, config=True)
247 screen_length = Int(0, config=True)
248
248
249 # Use custom TraitletTypes that convert '0'->'' and '\\n'->'\n'
249 # Use custom TraitletTypes that convert '0'->'' and '\\n'->'\n'
250 separate_in = SeparateStr('\n', config=True)
250 separate_in = SeparateStr('\n', config=True)
251 separate_out = SeparateStr('', config=True)
251 separate_out = SeparateStr('', config=True)
252 separate_out2 = SeparateStr('', config=True)
252 separate_out2 = SeparateStr('', config=True)
253
253
254 system_header = Str('IPython system call: ', config=True)
254 system_header = Str('IPython system call: ', config=True)
255 system_verbose = CBool(False, config=True)
255 system_verbose = CBool(False, config=True)
256 term_title = CBool(False, config=True)
256 term_title = CBool(False, config=True)
257 wildcards_case_sensitive = CBool(True, config=True)
257 wildcards_case_sensitive = CBool(True, config=True)
258 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
258 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
259 default_value='Context', config=True)
259 default_value='Context', config=True)
260
260
261 autoexec = List(allow_none=False)
261 autoexec = List(allow_none=False)
262
262
263 # class attribute to indicate whether the class supports threads or not.
263 # class attribute to indicate whether the class supports threads or not.
264 # Subclasses with thread support should override this as needed.
264 # Subclasses with thread support should override this as needed.
265 isthreaded = False
265 isthreaded = False
266
266
267 def __init__(self, parent=None, config=None, ipythondir=None, usage=None,
267 def __init__(self, parent=None, config=None, ipythondir=None, usage=None,
268 user_ns=None, user_global_ns=None,
268 user_ns=None, user_global_ns=None,
269 banner1=None, banner2=None, display_banner=None,
269 banner1=None, banner2=None, display_banner=None,
270 custom_exceptions=((),None)):
270 custom_exceptions=((),None)):
271
271
272 # This is where traitlets with a config_key argument are updated
272 # This is where traitlets with a config_key argument are updated
273 # from the values on config.
273 # from the values on config.
274 super(InteractiveShell, self).__init__(parent, config=config)
274 super(InteractiveShell, self).__init__(parent, config=config)
275
275
276 # These are relatively independent and stateless
276 # These are relatively independent and stateless
277 self.init_ipythondir(ipythondir)
277 self.init_ipythondir(ipythondir)
278 self.init_instance_attrs()
278 self.init_instance_attrs()
279 self.init_term_title()
279 self.init_term_title()
280 self.init_usage(usage)
280 self.init_usage(usage)
281 self.init_banner(banner1, banner2, display_banner)
281 self.init_banner(banner1, banner2, display_banner)
282
282
283 # Create namespaces (user_ns, user_global_ns, etc.)
283 # Create namespaces (user_ns, user_global_ns, etc.)
284 self.init_create_namespaces(user_ns, user_global_ns)
284 self.init_create_namespaces(user_ns, user_global_ns)
285 # This has to be done after init_create_namespaces because it uses
285 # This has to be done after init_create_namespaces because it uses
286 # something in self.user_ns, but before init_sys_modules, which
286 # something in self.user_ns, but before init_sys_modules, which
287 # is the first thing to modify sys.
287 # is the first thing to modify sys.
288 self.save_sys_module_state()
288 self.save_sys_module_state()
289 self.init_sys_modules()
289 self.init_sys_modules()
290
290
291 self.init_history()
291 self.init_history()
292 self.init_encoding()
292 self.init_encoding()
293 self.init_prefilter()
293 self.init_prefilter()
294
294
295 Magic.__init__(self, self)
295 Magic.__init__(self, self)
296
296
297 self.init_syntax_highlighting()
297 self.init_syntax_highlighting()
298 self.init_hooks()
298 self.init_hooks()
299 self.init_pushd_popd_magic()
299 self.init_pushd_popd_magic()
300 self.init_traceback_handlers(custom_exceptions)
300 self.init_traceback_handlers(custom_exceptions)
301 self.init_user_ns()
301 self.init_user_ns()
302 self.init_logger()
302 self.init_logger()
303 self.init_alias()
303 self.init_alias()
304 self.init_builtins()
304 self.init_builtins()
305
305
306 # pre_config_initialization
306 # pre_config_initialization
307 self.init_shadow_hist()
307 self.init_shadow_hist()
308
308
309 # The next section should contain averything that was in ipmaker.
309 # The next section should contain averything that was in ipmaker.
310 self.init_logstart()
310 self.init_logstart()
311
311
312 # The following was in post_config_initialization
312 # The following was in post_config_initialization
313 self.init_inspector()
313 self.init_inspector()
314 self.init_readline()
314 self.init_readline()
315 self.init_prompts()
315 self.init_prompts()
316 self.init_displayhook()
316 self.init_displayhook()
317 self.init_reload_doctest()
317 self.init_reload_doctest()
318 self.init_magics()
318 self.init_magics()
319 self.init_pdb()
319 self.init_pdb()
320 self.hooks.late_startup_hook()
320 self.hooks.late_startup_hook()
321
321
322 def get_ipython(self):
322 def get_ipython(self):
323 return self
323 return self
324
324
325 #-------------------------------------------------------------------------
325 #-------------------------------------------------------------------------
326 # Traitlet changed handlers
326 # Traitlet changed handlers
327 #-------------------------------------------------------------------------
327 #-------------------------------------------------------------------------
328
328
329 def _banner1_changed(self):
329 def _banner1_changed(self):
330 self.compute_banner()
330 self.compute_banner()
331
331
332 def _banner2_changed(self):
332 def _banner2_changed(self):
333 self.compute_banner()
333 self.compute_banner()
334
334
335 def _ipythondir_changed(self, name, new):
335 def _ipythondir_changed(self, name, new):
336 if not os.path.isdir(new):
336 if not os.path.isdir(new):
337 os.makedirs(new, mode = 0777)
337 os.makedirs(new, mode = 0777)
338 if not os.path.isdir(self.ipython_extension_dir):
338 if not os.path.isdir(self.ipython_extension_dir):
339 os.makedirs(self.ipython_extension_dir, mode = 0777)
339 os.makedirs(self.ipython_extension_dir, mode = 0777)
340
340
341 @property
341 @property
342 def ipython_extension_dir(self):
342 def ipython_extension_dir(self):
343 return os.path.join(self.ipythondir, 'extensions')
343 return os.path.join(self.ipythondir, 'extensions')
344
344
345 @property
345 @property
346 def usable_screen_length(self):
346 def usable_screen_length(self):
347 if self.screen_length == 0:
347 if self.screen_length == 0:
348 return 0
348 return 0
349 else:
349 else:
350 num_lines_bot = self.separate_in.count('\n')+1
350 num_lines_bot = self.separate_in.count('\n')+1
351 return self.screen_length - num_lines_bot
351 return self.screen_length - num_lines_bot
352
352
353 def _term_title_changed(self, name, new_value):
353 def _term_title_changed(self, name, new_value):
354 self.init_term_title()
354 self.init_term_title()
355
355
356 def set_autoindent(self,value=None):
356 def set_autoindent(self,value=None):
357 """Set the autoindent flag, checking for readline support.
357 """Set the autoindent flag, checking for readline support.
358
358
359 If called with no arguments, it acts as a toggle."""
359 If called with no arguments, it acts as a toggle."""
360
360
361 if not self.has_readline:
361 if not self.has_readline:
362 if os.name == 'posix':
362 if os.name == 'posix':
363 warn("The auto-indent feature requires the readline library")
363 warn("The auto-indent feature requires the readline library")
364 self.autoindent = 0
364 self.autoindent = 0
365 return
365 return
366 if value is None:
366 if value is None:
367 self.autoindent = not self.autoindent
367 self.autoindent = not self.autoindent
368 else:
368 else:
369 self.autoindent = value
369 self.autoindent = value
370
370
371 #-------------------------------------------------------------------------
371 #-------------------------------------------------------------------------
372 # init_* methods called by __init__
372 # init_* methods called by __init__
373 #-------------------------------------------------------------------------
373 #-------------------------------------------------------------------------
374
374
375 def init_ipythondir(self, ipythondir):
375 def init_ipythondir(self, ipythondir):
376 if ipythondir is not None:
376 if ipythondir is not None:
377 self.ipythondir = ipythondir
377 self.ipythondir = ipythondir
378 self.config.Global.ipythondir = self.ipythondir
378 self.config.Global.ipythondir = self.ipythondir
379 return
379 return
380
380
381 if hasattr(self.config.Global, 'ipythondir'):
381 if hasattr(self.config.Global, 'ipythondir'):
382 self.ipythondir = self.config.Global.ipythondir
382 self.ipythondir = self.config.Global.ipythondir
383 else:
383 else:
384 self.ipythondir = get_ipython_dir()
384 self.ipythondir = get_ipython_dir()
385
385
386 # All children can just read this
386 # All children can just read this
387 self.config.Global.ipythondir = self.ipythondir
387 self.config.Global.ipythondir = self.ipythondir
388
388
389 def init_instance_attrs(self):
389 def init_instance_attrs(self):
390 self.jobs = BackgroundJobManager()
390 self.jobs = BackgroundJobManager()
391 self.more = False
391 self.more = False
392
392
393 # command compiler
393 # command compiler
394 self.compile = codeop.CommandCompiler()
394 self.compile = codeop.CommandCompiler()
395
395
396 # User input buffer
396 # User input buffer
397 self.buffer = []
397 self.buffer = []
398
398
399 # Make an empty namespace, which extension writers can rely on both
399 # Make an empty namespace, which extension writers can rely on both
400 # existing and NEVER being used by ipython itself. This gives them a
400 # existing and NEVER being used by ipython itself. This gives them a
401 # convenient location for storing additional information and state
401 # convenient location for storing additional information and state
402 # their extensions may require, without fear of collisions with other
402 # their extensions may require, without fear of collisions with other
403 # ipython names that may develop later.
403 # ipython names that may develop later.
404 self.meta = Struct()
404 self.meta = Struct()
405
405
406 # Object variable to store code object waiting execution. This is
406 # Object variable to store code object waiting execution. This is
407 # used mainly by the multithreaded shells, but it can come in handy in
407 # used mainly by the multithreaded shells, but it can come in handy in
408 # other situations. No need to use a Queue here, since it's a single
408 # other situations. No need to use a Queue here, since it's a single
409 # item which gets cleared once run.
409 # item which gets cleared once run.
410 self.code_to_run = None
410 self.code_to_run = None
411
411
412 # Flag to mark unconditional exit
412 # Flag to mark unconditional exit
413 self.exit_now = False
413 self.exit_now = False
414
414
415 # Temporary files used for various purposes. Deleted at exit.
415 # Temporary files used for various purposes. Deleted at exit.
416 self.tempfiles = []
416 self.tempfiles = []
417
417
418 # Keep track of readline usage (later set by init_readline)
418 # Keep track of readline usage (later set by init_readline)
419 self.has_readline = False
419 self.has_readline = False
420
420
421 # keep track of where we started running (mainly for crash post-mortem)
421 # keep track of where we started running (mainly for crash post-mortem)
422 # This is not being used anywhere currently.
422 # This is not being used anywhere currently.
423 self.starting_dir = os.getcwd()
423 self.starting_dir = os.getcwd()
424
424
425 # Indentation management
425 # Indentation management
426 self.indent_current_nsp = 0
426 self.indent_current_nsp = 0
427
427
428 def init_term_title(self):
428 def init_term_title(self):
429 # Enable or disable the terminal title.
429 # Enable or disable the terminal title.
430 if self.term_title:
430 if self.term_title:
431 toggle_set_term_title(True)
431 toggle_set_term_title(True)
432 set_term_title('IPython: ' + abbrev_cwd())
432 set_term_title('IPython: ' + abbrev_cwd())
433 else:
433 else:
434 toggle_set_term_title(False)
434 toggle_set_term_title(False)
435
435
436 def init_usage(self, usage=None):
436 def init_usage(self, usage=None):
437 if usage is None:
437 if usage is None:
438 self.usage = interactive_usage
438 self.usage = interactive_usage
439 else:
439 else:
440 self.usage = usage
440 self.usage = usage
441
441
442 def init_encoding(self):
442 def init_encoding(self):
443 # Get system encoding at startup time. Certain terminals (like Emacs
443 # Get system encoding at startup time. Certain terminals (like Emacs
444 # under Win32 have it set to None, and we need to have a known valid
444 # under Win32 have it set to None, and we need to have a known valid
445 # encoding to use in the raw_input() method
445 # encoding to use in the raw_input() method
446 try:
446 try:
447 self.stdin_encoding = sys.stdin.encoding or 'ascii'
447 self.stdin_encoding = sys.stdin.encoding or 'ascii'
448 except AttributeError:
448 except AttributeError:
449 self.stdin_encoding = 'ascii'
449 self.stdin_encoding = 'ascii'
450
450
451 def init_syntax_highlighting(self):
451 def init_syntax_highlighting(self):
452 # Python source parser/formatter for syntax highlighting
452 # Python source parser/formatter for syntax highlighting
453 pyformat = PyColorize.Parser().format
453 pyformat = PyColorize.Parser().format
454 self.pycolorize = lambda src: pyformat(src,'str',self.colors)
454 self.pycolorize = lambda src: pyformat(src,'str',self.colors)
455
455
456 def init_pushd_popd_magic(self):
456 def init_pushd_popd_magic(self):
457 # for pushd/popd management
457 # for pushd/popd management
458 try:
458 try:
459 self.home_dir = get_home_dir()
459 self.home_dir = get_home_dir()
460 except HomeDirError, msg:
460 except HomeDirError, msg:
461 fatal(msg)
461 fatal(msg)
462
462
463 self.dir_stack = []
463 self.dir_stack = []
464
464
465 def init_logger(self):
465 def init_logger(self):
466 self.logger = Logger(self, logfname='ipython_log.py', logmode='rotate')
466 self.logger = Logger(self, logfname='ipython_log.py', logmode='rotate')
467 # local shortcut, this is used a LOT
467 # local shortcut, this is used a LOT
468 self.log = self.logger.log
468 self.log = self.logger.log
469
469
470 def init_logstart(self):
470 def init_logstart(self):
471 if self.logappend:
471 if self.logappend:
472 self.magic_logstart(self.logappend + ' append')
472 self.magic_logstart(self.logappend + ' append')
473 elif self.logfile:
473 elif self.logfile:
474 self.magic_logstart(self.logfile)
474 self.magic_logstart(self.logfile)
475 elif self.logstart:
475 elif self.logstart:
476 self.magic_logstart()
476 self.magic_logstart()
477
477
478 def init_builtins(self):
478 def init_builtins(self):
479 self.builtin_trap = BuiltinTrap(self)
479 self.builtin_trap = BuiltinTrap(self)
480
480
481 def init_inspector(self):
481 def init_inspector(self):
482 # Object inspector
482 # Object inspector
483 self.inspector = oinspect.Inspector(oinspect.InspectColors,
483 self.inspector = oinspect.Inspector(oinspect.InspectColors,
484 PyColorize.ANSICodeColors,
484 PyColorize.ANSICodeColors,
485 'NoColor',
485 'NoColor',
486 self.object_info_string_level)
486 self.object_info_string_level)
487
487
488 def init_prompts(self):
488 def init_prompts(self):
489 # Initialize cache, set in/out prompts and printing system
489 # Initialize cache, set in/out prompts and printing system
490 self.outputcache = CachedOutput(self,
490 self.outputcache = CachedOutput(self,
491 self.cache_size,
491 self.cache_size,
492 self.pprint,
492 self.pprint,
493 input_sep = self.separate_in,
493 input_sep = self.separate_in,
494 output_sep = self.separate_out,
494 output_sep = self.separate_out,
495 output_sep2 = self.separate_out2,
495 output_sep2 = self.separate_out2,
496 ps1 = self.prompt_in1,
496 ps1 = self.prompt_in1,
497 ps2 = self.prompt_in2,
497 ps2 = self.prompt_in2,
498 ps_out = self.prompt_out,
498 ps_out = self.prompt_out,
499 pad_left = self.prompts_pad_left)
499 pad_left = self.prompts_pad_left)
500
500
501 # user may have over-ridden the default print hook:
501 # user may have over-ridden the default print hook:
502 try:
502 try:
503 self.outputcache.__class__.display = self.hooks.display
503 self.outputcache.__class__.display = self.hooks.display
504 except AttributeError:
504 except AttributeError:
505 pass
505 pass
506
506
507 def init_displayhook(self):
507 def init_displayhook(self):
508 self.display_trap = DisplayTrap(self, self.outputcache)
508 self.display_trap = DisplayTrap(self, self.outputcache)
509
509
510 def init_reload_doctest(self):
510 def init_reload_doctest(self):
511 # Do a proper resetting of doctest, including the necessary displayhook
511 # Do a proper resetting of doctest, including the necessary displayhook
512 # monkeypatching
512 # monkeypatching
513 try:
513 try:
514 doctest_reload()
514 doctest_reload()
515 except ImportError:
515 except ImportError:
516 warn("doctest module does not exist.")
516 warn("doctest module does not exist.")
517
517
518 #-------------------------------------------------------------------------
518 #-------------------------------------------------------------------------
519 # Things related to the banner
519 # Things related to the banner
520 #-------------------------------------------------------------------------
520 #-------------------------------------------------------------------------
521
521
522 def init_banner(self, banner1, banner2, display_banner):
522 def init_banner(self, banner1, banner2, display_banner):
523 if banner1 is not None:
523 if banner1 is not None:
524 self.banner1 = banner1
524 self.banner1 = banner1
525 if banner2 is not None:
525 if banner2 is not None:
526 self.banner2 = banner2
526 self.banner2 = banner2
527 if display_banner is not None:
527 if display_banner is not None:
528 self.display_banner = display_banner
528 self.display_banner = display_banner
529 self.compute_banner()
529 self.compute_banner()
530
530
531 def show_banner(self, banner=None):
531 def show_banner(self, banner=None):
532 if banner is None:
532 if banner is None:
533 banner = self.banner
533 banner = self.banner
534 self.write(banner)
534 self.write(banner)
535
535
536 def compute_banner(self):
536 def compute_banner(self):
537 self.banner = self.banner1 + '\n'
537 self.banner = self.banner1 + '\n'
538 if self.profile:
538 if self.profile:
539 self.banner += '\nIPython profile: %s\n' % self.profile
539 self.banner += '\nIPython profile: %s\n' % self.profile
540 if self.banner2:
540 if self.banner2:
541 self.banner += '\n' + self.banner2 + '\n'
541 self.banner += '\n' + self.banner2 + '\n'
542
542
543 #-------------------------------------------------------------------------
543 #-------------------------------------------------------------------------
544 # Things related to injections into the sys module
544 # Things related to injections into the sys module
545 #-------------------------------------------------------------------------
545 #-------------------------------------------------------------------------
546
546
547 def save_sys_module_state(self):
547 def save_sys_module_state(self):
548 """Save the state of hooks in the sys module.
548 """Save the state of hooks in the sys module.
549
549
550 This has to be called after self.user_ns is created.
550 This has to be called after self.user_ns is created.
551 """
551 """
552 self._orig_sys_module_state = {}
552 self._orig_sys_module_state = {}
553 self._orig_sys_module_state['stdin'] = sys.stdin
553 self._orig_sys_module_state['stdin'] = sys.stdin
554 self._orig_sys_module_state['stdout'] = sys.stdout
554 self._orig_sys_module_state['stdout'] = sys.stdout
555 self._orig_sys_module_state['stderr'] = sys.stderr
555 self._orig_sys_module_state['stderr'] = sys.stderr
556 self._orig_sys_module_state['excepthook'] = sys.excepthook
556 self._orig_sys_module_state['excepthook'] = sys.excepthook
557 try:
557 try:
558 self._orig_sys_modules_main_name = self.user_ns['__name__']
558 self._orig_sys_modules_main_name = self.user_ns['__name__']
559 except KeyError:
559 except KeyError:
560 pass
560 pass
561
561
562 def restore_sys_module_state(self):
562 def restore_sys_module_state(self):
563 """Restore the state of the sys module."""
563 """Restore the state of the sys module."""
564 try:
564 try:
565 for k, v in self._orig_sys_module_state.items():
565 for k, v in self._orig_sys_module_state.items():
566 setattr(sys, k, v)
566 setattr(sys, k, v)
567 except AttributeError:
567 except AttributeError:
568 pass
568 pass
569 try:
569 try:
570 delattr(sys, 'ipcompleter')
570 delattr(sys, 'ipcompleter')
571 except AttributeError:
571 except AttributeError:
572 pass
572 pass
573 # Reset what what done in self.init_sys_modules
573 # Reset what what done in self.init_sys_modules
574 try:
574 try:
575 sys.modules[self.user_ns['__name__']] = self._orig_sys_modules_main_name
575 sys.modules[self.user_ns['__name__']] = self._orig_sys_modules_main_name
576 except (AttributeError, KeyError):
576 except (AttributeError, KeyError):
577 pass
577 pass
578
578
579 #-------------------------------------------------------------------------
579 #-------------------------------------------------------------------------
580 # Things related to hooks
580 # Things related to hooks
581 #-------------------------------------------------------------------------
581 #-------------------------------------------------------------------------
582
582
583 def init_hooks(self):
583 def init_hooks(self):
584 # hooks holds pointers used for user-side customizations
584 # hooks holds pointers used for user-side customizations
585 self.hooks = Struct()
585 self.hooks = Struct()
586
586
587 self.strdispatchers = {}
587 self.strdispatchers = {}
588
588
589 # Set all default hooks, defined in the IPython.hooks module.
589 # Set all default hooks, defined in the IPython.hooks module.
590 import IPython.core.hooks
590 import IPython.core.hooks
591 hooks = IPython.core.hooks
591 hooks = IPython.core.hooks
592 for hook_name in hooks.__all__:
592 for hook_name in hooks.__all__:
593 # default hooks have priority 100, i.e. low; user hooks should have
593 # default hooks have priority 100, i.e. low; user hooks should have
594 # 0-100 priority
594 # 0-100 priority
595 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
595 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
596
596
597 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
597 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
598 """set_hook(name,hook) -> sets an internal IPython hook.
598 """set_hook(name,hook) -> sets an internal IPython hook.
599
599
600 IPython exposes some of its internal API as user-modifiable hooks. By
600 IPython exposes some of its internal API as user-modifiable hooks. By
601 adding your function to one of these hooks, you can modify IPython's
601 adding your function to one of these hooks, you can modify IPython's
602 behavior to call at runtime your own routines."""
602 behavior to call at runtime your own routines."""
603
603
604 # At some point in the future, this should validate the hook before it
604 # At some point in the future, this should validate the hook before it
605 # accepts it. Probably at least check that the hook takes the number
605 # accepts it. Probably at least check that the hook takes the number
606 # of args it's supposed to.
606 # of args it's supposed to.
607
607
608 f = new.instancemethod(hook,self,self.__class__)
608 f = new.instancemethod(hook,self,self.__class__)
609
609
610 # check if the hook is for strdispatcher first
610 # check if the hook is for strdispatcher first
611 if str_key is not None:
611 if str_key is not None:
612 sdp = self.strdispatchers.get(name, StrDispatch())
612 sdp = self.strdispatchers.get(name, StrDispatch())
613 sdp.add_s(str_key, f, priority )
613 sdp.add_s(str_key, f, priority )
614 self.strdispatchers[name] = sdp
614 self.strdispatchers[name] = sdp
615 return
615 return
616 if re_key is not None:
616 if re_key is not None:
617 sdp = self.strdispatchers.get(name, StrDispatch())
617 sdp = self.strdispatchers.get(name, StrDispatch())
618 sdp.add_re(re.compile(re_key), f, priority )
618 sdp.add_re(re.compile(re_key), f, priority )
619 self.strdispatchers[name] = sdp
619 self.strdispatchers[name] = sdp
620 return
620 return
621
621
622 dp = getattr(self.hooks, name, None)
622 dp = getattr(self.hooks, name, None)
623 if name not in IPython.core.hooks.__all__:
623 if name not in IPython.core.hooks.__all__:
624 print "Warning! Hook '%s' is not one of %s" % (name, IPython.core.hooks.__all__ )
624 print "Warning! Hook '%s' is not one of %s" % (name, IPython.core.hooks.__all__ )
625 if not dp:
625 if not dp:
626 dp = IPython.core.hooks.CommandChainDispatcher()
626 dp = IPython.core.hooks.CommandChainDispatcher()
627
627
628 try:
628 try:
629 dp.add(f,priority)
629 dp.add(f,priority)
630 except AttributeError:
630 except AttributeError:
631 # it was not commandchain, plain old func - replace
631 # it was not commandchain, plain old func - replace
632 dp = f
632 dp = f
633
633
634 setattr(self.hooks,name, dp)
634 setattr(self.hooks,name, dp)
635
635
636 #-------------------------------------------------------------------------
636 #-------------------------------------------------------------------------
637 # Things related to the "main" module
637 # Things related to the "main" module
638 #-------------------------------------------------------------------------
638 #-------------------------------------------------------------------------
639
639
640 def new_main_mod(self,ns=None):
640 def new_main_mod(self,ns=None):
641 """Return a new 'main' module object for user code execution.
641 """Return a new 'main' module object for user code execution.
642 """
642 """
643 main_mod = self._user_main_module
643 main_mod = self._user_main_module
644 init_fakemod_dict(main_mod,ns)
644 init_fakemod_dict(main_mod,ns)
645 return main_mod
645 return main_mod
646
646
647 def cache_main_mod(self,ns,fname):
647 def cache_main_mod(self,ns,fname):
648 """Cache a main module's namespace.
648 """Cache a main module's namespace.
649
649
650 When scripts are executed via %run, we must keep a reference to the
650 When scripts are executed via %run, we must keep a reference to the
651 namespace of their __main__ module (a FakeModule instance) around so
651 namespace of their __main__ module (a FakeModule instance) around so
652 that Python doesn't clear it, rendering objects defined therein
652 that Python doesn't clear it, rendering objects defined therein
653 useless.
653 useless.
654
654
655 This method keeps said reference in a private dict, keyed by the
655 This method keeps said reference in a private dict, keyed by the
656 absolute path of the module object (which corresponds to the script
656 absolute path of the module object (which corresponds to the script
657 path). This way, for multiple executions of the same script we only
657 path). This way, for multiple executions of the same script we only
658 keep one copy of the namespace (the last one), thus preventing memory
658 keep one copy of the namespace (the last one), thus preventing memory
659 leaks from old references while allowing the objects from the last
659 leaks from old references while allowing the objects from the last
660 execution to be accessible.
660 execution to be accessible.
661
661
662 Note: we can not allow the actual FakeModule instances to be deleted,
662 Note: we can not allow the actual FakeModule instances to be deleted,
663 because of how Python tears down modules (it hard-sets all their
663 because of how Python tears down modules (it hard-sets all their
664 references to None without regard for reference counts). This method
664 references to None without regard for reference counts). This method
665 must therefore make a *copy* of the given namespace, to allow the
665 must therefore make a *copy* of the given namespace, to allow the
666 original module's __dict__ to be cleared and reused.
666 original module's __dict__ to be cleared and reused.
667
667
668
668
669 Parameters
669 Parameters
670 ----------
670 ----------
671 ns : a namespace (a dict, typically)
671 ns : a namespace (a dict, typically)
672
672
673 fname : str
673 fname : str
674 Filename associated with the namespace.
674 Filename associated with the namespace.
675
675
676 Examples
676 Examples
677 --------
677 --------
678
678
679 In [10]: import IPython
679 In [10]: import IPython
680
680
681 In [11]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
681 In [11]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
682
682
683 In [12]: IPython.__file__ in _ip._main_ns_cache
683 In [12]: IPython.__file__ in _ip._main_ns_cache
684 Out[12]: True
684 Out[12]: True
685 """
685 """
686 self._main_ns_cache[os.path.abspath(fname)] = ns.copy()
686 self._main_ns_cache[os.path.abspath(fname)] = ns.copy()
687
687
688 def clear_main_mod_cache(self):
688 def clear_main_mod_cache(self):
689 """Clear the cache of main modules.
689 """Clear the cache of main modules.
690
690
691 Mainly for use by utilities like %reset.
691 Mainly for use by utilities like %reset.
692
692
693 Examples
693 Examples
694 --------
694 --------
695
695
696 In [15]: import IPython
696 In [15]: import IPython
697
697
698 In [16]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
698 In [16]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
699
699
700 In [17]: len(_ip._main_ns_cache) > 0
700 In [17]: len(_ip._main_ns_cache) > 0
701 Out[17]: True
701 Out[17]: True
702
702
703 In [18]: _ip.clear_main_mod_cache()
703 In [18]: _ip.clear_main_mod_cache()
704
704
705 In [19]: len(_ip._main_ns_cache) == 0
705 In [19]: len(_ip._main_ns_cache) == 0
706 Out[19]: True
706 Out[19]: True
707 """
707 """
708 self._main_ns_cache.clear()
708 self._main_ns_cache.clear()
709
709
710 #-------------------------------------------------------------------------
710 #-------------------------------------------------------------------------
711 # Things related to debugging
711 # Things related to debugging
712 #-------------------------------------------------------------------------
712 #-------------------------------------------------------------------------
713
713
714 def init_pdb(self):
714 def init_pdb(self):
715 # Set calling of pdb on exceptions
715 # Set calling of pdb on exceptions
716 # self.call_pdb is a property
716 # self.call_pdb is a property
717 self.call_pdb = self.pdb
717 self.call_pdb = self.pdb
718
718
719 def _get_call_pdb(self):
719 def _get_call_pdb(self):
720 return self._call_pdb
720 return self._call_pdb
721
721
722 def _set_call_pdb(self,val):
722 def _set_call_pdb(self,val):
723
723
724 if val not in (0,1,False,True):
724 if val not in (0,1,False,True):
725 raise ValueError,'new call_pdb value must be boolean'
725 raise ValueError,'new call_pdb value must be boolean'
726
726
727 # store value in instance
727 # store value in instance
728 self._call_pdb = val
728 self._call_pdb = val
729
729
730 # notify the actual exception handlers
730 # notify the actual exception handlers
731 self.InteractiveTB.call_pdb = val
731 self.InteractiveTB.call_pdb = val
732 if self.isthreaded:
732 if self.isthreaded:
733 try:
733 try:
734 self.sys_excepthook.call_pdb = val
734 self.sys_excepthook.call_pdb = val
735 except:
735 except:
736 warn('Failed to activate pdb for threaded exception handler')
736 warn('Failed to activate pdb for threaded exception handler')
737
737
738 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
738 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
739 'Control auto-activation of pdb at exceptions')
739 'Control auto-activation of pdb at exceptions')
740
740
741 def debugger(self,force=False):
741 def debugger(self,force=False):
742 """Call the pydb/pdb debugger.
742 """Call the pydb/pdb debugger.
743
743
744 Keywords:
744 Keywords:
745
745
746 - force(False): by default, this routine checks the instance call_pdb
746 - force(False): by default, this routine checks the instance call_pdb
747 flag and does not actually invoke the debugger if the flag is false.
747 flag and does not actually invoke the debugger if the flag is false.
748 The 'force' option forces the debugger to activate even if the flag
748 The 'force' option forces the debugger to activate even if the flag
749 is false.
749 is false.
750 """
750 """
751
751
752 if not (force or self.call_pdb):
752 if not (force or self.call_pdb):
753 return
753 return
754
754
755 if not hasattr(sys,'last_traceback'):
755 if not hasattr(sys,'last_traceback'):
756 error('No traceback has been produced, nothing to debug.')
756 error('No traceback has been produced, nothing to debug.')
757 return
757 return
758
758
759 # use pydb if available
759 # use pydb if available
760 if debugger.has_pydb:
760 if debugger.has_pydb:
761 from pydb import pm
761 from pydb import pm
762 else:
762 else:
763 # fallback to our internal debugger
763 # fallback to our internal debugger
764 pm = lambda : self.InteractiveTB.debugger(force=True)
764 pm = lambda : self.InteractiveTB.debugger(force=True)
765 self.history_saving_wrapper(pm)()
765 self.history_saving_wrapper(pm)()
766
766
767 #-------------------------------------------------------------------------
767 #-------------------------------------------------------------------------
768 # Things related to IPython's various namespaces
768 # Things related to IPython's various namespaces
769 #-------------------------------------------------------------------------
769 #-------------------------------------------------------------------------
770
770
771 def init_create_namespaces(self, user_ns=None, user_global_ns=None):
771 def init_create_namespaces(self, user_ns=None, user_global_ns=None):
772 # Create the namespace where the user will operate. user_ns is
772 # Create the namespace where the user will operate. user_ns is
773 # normally the only one used, and it is passed to the exec calls as
773 # normally the only one used, and it is passed to the exec calls as
774 # the locals argument. But we do carry a user_global_ns namespace
774 # the locals argument. But we do carry a user_global_ns namespace
775 # given as the exec 'globals' argument, This is useful in embedding
775 # given as the exec 'globals' argument, This is useful in embedding
776 # situations where the ipython shell opens in a context where the
776 # situations where the ipython shell opens in a context where the
777 # distinction between locals and globals is meaningful. For
777 # distinction between locals and globals is meaningful. For
778 # non-embedded contexts, it is just the same object as the user_ns dict.
778 # non-embedded contexts, it is just the same object as the user_ns dict.
779
779
780 # FIXME. For some strange reason, __builtins__ is showing up at user
780 # FIXME. For some strange reason, __builtins__ is showing up at user
781 # level as a dict instead of a module. This is a manual fix, but I
781 # level as a dict instead of a module. This is a manual fix, but I
782 # should really track down where the problem is coming from. Alex
782 # should really track down where the problem is coming from. Alex
783 # Schmolck reported this problem first.
783 # Schmolck reported this problem first.
784
784
785 # A useful post by Alex Martelli on this topic:
785 # A useful post by Alex Martelli on this topic:
786 # Re: inconsistent value from __builtins__
786 # Re: inconsistent value from __builtins__
787 # Von: Alex Martelli <aleaxit@yahoo.com>
787 # Von: Alex Martelli <aleaxit@yahoo.com>
788 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
788 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
789 # Gruppen: comp.lang.python
789 # Gruppen: comp.lang.python
790
790
791 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
791 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
792 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
792 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
793 # > <type 'dict'>
793 # > <type 'dict'>
794 # > >>> print type(__builtins__)
794 # > >>> print type(__builtins__)
795 # > <type 'module'>
795 # > <type 'module'>
796 # > Is this difference in return value intentional?
796 # > Is this difference in return value intentional?
797
797
798 # Well, it's documented that '__builtins__' can be either a dictionary
798 # Well, it's documented that '__builtins__' can be either a dictionary
799 # or a module, and it's been that way for a long time. Whether it's
799 # or a module, and it's been that way for a long time. Whether it's
800 # intentional (or sensible), I don't know. In any case, the idea is
800 # intentional (or sensible), I don't know. In any case, the idea is
801 # that if you need to access the built-in namespace directly, you
801 # that if you need to access the built-in namespace directly, you
802 # should start with "import __builtin__" (note, no 's') which will
802 # should start with "import __builtin__" (note, no 's') which will
803 # definitely give you a module. Yeah, it's somewhat confusing:-(.
803 # definitely give you a module. Yeah, it's somewhat confusing:-(.
804
804
805 # These routines return properly built dicts as needed by the rest of
805 # These routines return properly built dicts as needed by the rest of
806 # the code, and can also be used by extension writers to generate
806 # the code, and can also be used by extension writers to generate
807 # properly initialized namespaces.
807 # properly initialized namespaces.
808 user_ns, user_global_ns = self.make_user_namespaces(user_ns,
808 user_ns, user_global_ns = self.make_user_namespaces(user_ns,
809 user_global_ns)
809 user_global_ns)
810
810
811 # Assign namespaces
811 # Assign namespaces
812 # This is the namespace where all normal user variables live
812 # This is the namespace where all normal user variables live
813 self.user_ns = user_ns
813 self.user_ns = user_ns
814 self.user_global_ns = user_global_ns
814 self.user_global_ns = user_global_ns
815
815
816 # An auxiliary namespace that checks what parts of the user_ns were
816 # An auxiliary namespace that checks what parts of the user_ns were
817 # loaded at startup, so we can list later only variables defined in
817 # loaded at startup, so we can list later only variables defined in
818 # actual interactive use. Since it is always a subset of user_ns, it
818 # actual interactive use. Since it is always a subset of user_ns, it
819 # doesn't need to be seaparately tracked in the ns_table
819 # doesn't need to be seaparately tracked in the ns_table
820 self.user_config_ns = {}
820 self.user_config_ns = {}
821
821
822 # A namespace to keep track of internal data structures to prevent
822 # A namespace to keep track of internal data structures to prevent
823 # them from cluttering user-visible stuff. Will be updated later
823 # them from cluttering user-visible stuff. Will be updated later
824 self.internal_ns = {}
824 self.internal_ns = {}
825
825
826 # Now that FakeModule produces a real module, we've run into a nasty
826 # Now that FakeModule produces a real module, we've run into a nasty
827 # problem: after script execution (via %run), the module where the user
827 # problem: after script execution (via %run), the module where the user
828 # code ran is deleted. Now that this object is a true module (needed
828 # code ran is deleted. Now that this object is a true module (needed
829 # so docetst and other tools work correctly), the Python module
829 # so docetst and other tools work correctly), the Python module
830 # teardown mechanism runs over it, and sets to None every variable
830 # teardown mechanism runs over it, and sets to None every variable
831 # present in that module. Top-level references to objects from the
831 # present in that module. Top-level references to objects from the
832 # script survive, because the user_ns is updated with them. However,
832 # script survive, because the user_ns is updated with them. However,
833 # calling functions defined in the script that use other things from
833 # calling functions defined in the script that use other things from
834 # the script will fail, because the function's closure had references
834 # the script will fail, because the function's closure had references
835 # to the original objects, which are now all None. So we must protect
835 # to the original objects, which are now all None. So we must protect
836 # these modules from deletion by keeping a cache.
836 # these modules from deletion by keeping a cache.
837 #
837 #
838 # To avoid keeping stale modules around (we only need the one from the
838 # To avoid keeping stale modules around (we only need the one from the
839 # last run), we use a dict keyed with the full path to the script, so
839 # last run), we use a dict keyed with the full path to the script, so
840 # only the last version of the module is held in the cache. Note,
840 # only the last version of the module is held in the cache. Note,
841 # however, that we must cache the module *namespace contents* (their
841 # however, that we must cache the module *namespace contents* (their
842 # __dict__). Because if we try to cache the actual modules, old ones
842 # __dict__). Because if we try to cache the actual modules, old ones
843 # (uncached) could be destroyed while still holding references (such as
843 # (uncached) could be destroyed while still holding references (such as
844 # those held by GUI objects that tend to be long-lived)>
844 # those held by GUI objects that tend to be long-lived)>
845 #
845 #
846 # The %reset command will flush this cache. See the cache_main_mod()
846 # The %reset command will flush this cache. See the cache_main_mod()
847 # and clear_main_mod_cache() methods for details on use.
847 # and clear_main_mod_cache() methods for details on use.
848
848
849 # This is the cache used for 'main' namespaces
849 # This is the cache used for 'main' namespaces
850 self._main_ns_cache = {}
850 self._main_ns_cache = {}
851 # And this is the single instance of FakeModule whose __dict__ we keep
851 # And this is the single instance of FakeModule whose __dict__ we keep
852 # copying and clearing for reuse on each %run
852 # copying and clearing for reuse on each %run
853 self._user_main_module = FakeModule()
853 self._user_main_module = FakeModule()
854
854
855 # A table holding all the namespaces IPython deals with, so that
855 # A table holding all the namespaces IPython deals with, so that
856 # introspection facilities can search easily.
856 # introspection facilities can search easily.
857 self.ns_table = {'user':user_ns,
857 self.ns_table = {'user':user_ns,
858 'user_global':user_global_ns,
858 'user_global':user_global_ns,
859 'internal':self.internal_ns,
859 'internal':self.internal_ns,
860 'builtin':__builtin__.__dict__
860 'builtin':__builtin__.__dict__
861 }
861 }
862
862
863 # Similarly, track all namespaces where references can be held and that
863 # Similarly, track all namespaces where references can be held and that
864 # we can safely clear (so it can NOT include builtin). This one can be
864 # we can safely clear (so it can NOT include builtin). This one can be
865 # a simple list.
865 # a simple list.
866 self.ns_refs_table = [ user_ns, user_global_ns, self.user_config_ns,
866 self.ns_refs_table = [ user_ns, user_global_ns, self.user_config_ns,
867 self.internal_ns, self._main_ns_cache ]
867 self.internal_ns, self._main_ns_cache ]
868
868
869 def init_sys_modules(self):
869 def init_sys_modules(self):
870 # We need to insert into sys.modules something that looks like a
870 # We need to insert into sys.modules something that looks like a
871 # module but which accesses the IPython namespace, for shelve and
871 # module but which accesses the IPython namespace, for shelve and
872 # pickle to work interactively. Normally they rely on getting
872 # pickle to work interactively. Normally they rely on getting
873 # everything out of __main__, but for embedding purposes each IPython
873 # everything out of __main__, but for embedding purposes each IPython
874 # instance has its own private namespace, so we can't go shoving
874 # instance has its own private namespace, so we can't go shoving
875 # everything into __main__.
875 # everything into __main__.
876
876
877 # note, however, that we should only do this for non-embedded
877 # note, however, that we should only do this for non-embedded
878 # ipythons, which really mimic the __main__.__dict__ with their own
878 # ipythons, which really mimic the __main__.__dict__ with their own
879 # namespace. Embedded instances, on the other hand, should not do
879 # namespace. Embedded instances, on the other hand, should not do
880 # this because they need to manage the user local/global namespaces
880 # this because they need to manage the user local/global namespaces
881 # only, but they live within a 'normal' __main__ (meaning, they
881 # only, but they live within a 'normal' __main__ (meaning, they
882 # shouldn't overtake the execution environment of the script they're
882 # shouldn't overtake the execution environment of the script they're
883 # embedded in).
883 # embedded in).
884
884
885 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
885 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
886
886
887 try:
887 try:
888 main_name = self.user_ns['__name__']
888 main_name = self.user_ns['__name__']
889 except KeyError:
889 except KeyError:
890 raise KeyError('user_ns dictionary MUST have a "__name__" key')
890 raise KeyError('user_ns dictionary MUST have a "__name__" key')
891 else:
891 else:
892 sys.modules[main_name] = FakeModule(self.user_ns)
892 sys.modules[main_name] = FakeModule(self.user_ns)
893
893
894 def make_user_namespaces(self, user_ns=None, user_global_ns=None):
894 def make_user_namespaces(self, user_ns=None, user_global_ns=None):
895 """Return a valid local and global user interactive namespaces.
895 """Return a valid local and global user interactive namespaces.
896
896
897 This builds a dict with the minimal information needed to operate as a
897 This builds a dict with the minimal information needed to operate as a
898 valid IPython user namespace, which you can pass to the various
898 valid IPython user namespace, which you can pass to the various
899 embedding classes in ipython. The default implementation returns the
899 embedding classes in ipython. The default implementation returns the
900 same dict for both the locals and the globals to allow functions to
900 same dict for both the locals and the globals to allow functions to
901 refer to variables in the namespace. Customized implementations can
901 refer to variables in the namespace. Customized implementations can
902 return different dicts. The locals dictionary can actually be anything
902 return different dicts. The locals dictionary can actually be anything
903 following the basic mapping protocol of a dict, but the globals dict
903 following the basic mapping protocol of a dict, but the globals dict
904 must be a true dict, not even a subclass. It is recommended that any
904 must be a true dict, not even a subclass. It is recommended that any
905 custom object for the locals namespace synchronize with the globals
905 custom object for the locals namespace synchronize with the globals
906 dict somehow.
906 dict somehow.
907
907
908 Raises TypeError if the provided globals namespace is not a true dict.
908 Raises TypeError if the provided globals namespace is not a true dict.
909
909
910 :Parameters:
910 :Parameters:
911 user_ns : dict-like, optional
911 user_ns : dict-like, optional
912 The current user namespace. The items in this namespace should
912 The current user namespace. The items in this namespace should
913 be included in the output. If None, an appropriate blank
913 be included in the output. If None, an appropriate blank
914 namespace should be created.
914 namespace should be created.
915 user_global_ns : dict, optional
915 user_global_ns : dict, optional
916 The current user global namespace. The items in this namespace
916 The current user global namespace. The items in this namespace
917 should be included in the output. If None, an appropriate
917 should be included in the output. If None, an appropriate
918 blank namespace should be created.
918 blank namespace should be created.
919
919
920 :Returns:
920 :Returns:
921 A tuple pair of dictionary-like object to be used as the local namespace
921 A tuple pair of dictionary-like object to be used as the local namespace
922 of the interpreter and a dict to be used as the global namespace.
922 of the interpreter and a dict to be used as the global namespace.
923 """
923 """
924
924
925 if user_ns is None:
925 if user_ns is None:
926 # Set __name__ to __main__ to better match the behavior of the
926 # Set __name__ to __main__ to better match the behavior of the
927 # normal interpreter.
927 # normal interpreter.
928 user_ns = {'__name__' :'__main__',
928 user_ns = {'__name__' :'__main__',
929 '__builtins__' : __builtin__,
929 '__builtins__' : __builtin__,
930 }
930 }
931 else:
931 else:
932 user_ns.setdefault('__name__','__main__')
932 user_ns.setdefault('__name__','__main__')
933 user_ns.setdefault('__builtins__',__builtin__)
933 user_ns.setdefault('__builtins__',__builtin__)
934
934
935 if user_global_ns is None:
935 if user_global_ns is None:
936 user_global_ns = user_ns
936 user_global_ns = user_ns
937 if type(user_global_ns) is not dict:
937 if type(user_global_ns) is not dict:
938 raise TypeError("user_global_ns must be a true dict; got %r"
938 raise TypeError("user_global_ns must be a true dict; got %r"
939 % type(user_global_ns))
939 % type(user_global_ns))
940
940
941 return user_ns, user_global_ns
941 return user_ns, user_global_ns
942
942
943 def init_user_ns(self):
943 def init_user_ns(self):
944 """Initialize all user-visible namespaces to their minimum defaults.
944 """Initialize all user-visible namespaces to their minimum defaults.
945
945
946 Certain history lists are also initialized here, as they effectively
946 Certain history lists are also initialized here, as they effectively
947 act as user namespaces.
947 act as user namespaces.
948
948
949 Notes
949 Notes
950 -----
950 -----
951 All data structures here are only filled in, they are NOT reset by this
951 All data structures here are only filled in, they are NOT reset by this
952 method. If they were not empty before, data will simply be added to
952 method. If they were not empty before, data will simply be added to
953 therm.
953 therm.
954 """
954 """
955 # Store myself as the public api!!!
955 # Store myself as the public api!!!
956 self.user_ns['get_ipython'] = self.get_ipython
956 self.user_ns['get_ipython'] = self.get_ipython
957
957
958 # make global variables for user access to the histories
958 # make global variables for user access to the histories
959 self.user_ns['_ih'] = self.input_hist
959 self.user_ns['_ih'] = self.input_hist
960 self.user_ns['_oh'] = self.output_hist
960 self.user_ns['_oh'] = self.output_hist
961 self.user_ns['_dh'] = self.dir_hist
961 self.user_ns['_dh'] = self.dir_hist
962
962
963 # user aliases to input and output histories
963 # user aliases to input and output histories
964 self.user_ns['In'] = self.input_hist
964 self.user_ns['In'] = self.input_hist
965 self.user_ns['Out'] = self.output_hist
965 self.user_ns['Out'] = self.output_hist
966
966
967 self.user_ns['_sh'] = shadowns
967 self.user_ns['_sh'] = shadowns
968
968
969 # Put 'help' in the user namespace
969 # Put 'help' in the user namespace
970 try:
970 try:
971 from site import _Helper
971 from site import _Helper
972 self.user_ns['help'] = _Helper()
972 self.user_ns['help'] = _Helper()
973 except ImportError:
973 except ImportError:
974 warn('help() not available - check site.py')
974 warn('help() not available - check site.py')
975
975
976 def reset(self):
976 def reset(self):
977 """Clear all internal namespaces.
977 """Clear all internal namespaces.
978
978
979 Note that this is much more aggressive than %reset, since it clears
979 Note that this is much more aggressive than %reset, since it clears
980 fully all namespaces, as well as all input/output lists.
980 fully all namespaces, as well as all input/output lists.
981 """
981 """
982 for ns in self.ns_refs_table:
982 for ns in self.ns_refs_table:
983 ns.clear()
983 ns.clear()
984
984
985 self.alias_manager.clear_aliases()
985 self.alias_manager.clear_aliases()
986
986
987 # Clear input and output histories
987 # Clear input and output histories
988 self.input_hist[:] = []
988 self.input_hist[:] = []
989 self.input_hist_raw[:] = []
989 self.input_hist_raw[:] = []
990 self.output_hist.clear()
990 self.output_hist.clear()
991
991
992 # Restore the user namespaces to minimal usability
992 # Restore the user namespaces to minimal usability
993 self.init_user_ns()
993 self.init_user_ns()
994
994
995 # Restore the default and user aliases
995 # Restore the default and user aliases
996 self.alias_manager.init_aliases()
996 self.alias_manager.init_aliases()
997
997
998 def push(self, variables, interactive=True):
998 def push(self, variables, interactive=True):
999 """Inject a group of variables into the IPython user namespace.
999 """Inject a group of variables into the IPython user namespace.
1000
1000
1001 Parameters
1001 Parameters
1002 ----------
1002 ----------
1003 variables : dict, str or list/tuple of str
1003 variables : dict, str or list/tuple of str
1004 The variables to inject into the user's namespace. If a dict,
1004 The variables to inject into the user's namespace. If a dict,
1005 a simple update is done. If a str, the string is assumed to
1005 a simple update is done. If a str, the string is assumed to
1006 have variable names separated by spaces. A list/tuple of str
1006 have variable names separated by spaces. A list/tuple of str
1007 can also be used to give the variable names. If just the variable
1007 can also be used to give the variable names. If just the variable
1008 names are give (list/tuple/str) then the variable values looked
1008 names are give (list/tuple/str) then the variable values looked
1009 up in the callers frame.
1009 up in the callers frame.
1010 interactive : bool
1010 interactive : bool
1011 If True (default), the variables will be listed with the ``who``
1011 If True (default), the variables will be listed with the ``who``
1012 magic.
1012 magic.
1013 """
1013 """
1014 vdict = None
1014 vdict = None
1015
1015
1016 # We need a dict of name/value pairs to do namespace updates.
1016 # We need a dict of name/value pairs to do namespace updates.
1017 if isinstance(variables, dict):
1017 if isinstance(variables, dict):
1018 vdict = variables
1018 vdict = variables
1019 elif isinstance(variables, (basestring, list, tuple)):
1019 elif isinstance(variables, (basestring, list, tuple)):
1020 if isinstance(variables, basestring):
1020 if isinstance(variables, basestring):
1021 vlist = variables.split()
1021 vlist = variables.split()
1022 else:
1022 else:
1023 vlist = variables
1023 vlist = variables
1024 vdict = {}
1024 vdict = {}
1025 cf = sys._getframe(1)
1025 cf = sys._getframe(1)
1026 for name in vlist:
1026 for name in vlist:
1027 try:
1027 try:
1028 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1028 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1029 except:
1029 except:
1030 print ('Could not get variable %s from %s' %
1030 print ('Could not get variable %s from %s' %
1031 (name,cf.f_code.co_name))
1031 (name,cf.f_code.co_name))
1032 else:
1032 else:
1033 raise ValueError('variables must be a dict/str/list/tuple')
1033 raise ValueError('variables must be a dict/str/list/tuple')
1034
1034
1035 # Propagate variables to user namespace
1035 # Propagate variables to user namespace
1036 self.user_ns.update(vdict)
1036 self.user_ns.update(vdict)
1037
1037
1038 # And configure interactive visibility
1038 # And configure interactive visibility
1039 config_ns = self.user_config_ns
1039 config_ns = self.user_config_ns
1040 if interactive:
1040 if interactive:
1041 for name, val in vdict.iteritems():
1041 for name, val in vdict.iteritems():
1042 config_ns.pop(name, None)
1042 config_ns.pop(name, None)
1043 else:
1043 else:
1044 for name,val in vdict.iteritems():
1044 for name,val in vdict.iteritems():
1045 config_ns[name] = val
1045 config_ns[name] = val
1046
1046
1047 #-------------------------------------------------------------------------
1047 #-------------------------------------------------------------------------
1048 # Things related to history management
1048 # Things related to history management
1049 #-------------------------------------------------------------------------
1049 #-------------------------------------------------------------------------
1050
1050
1051 def init_history(self):
1051 def init_history(self):
1052 # List of input with multi-line handling.
1052 # List of input with multi-line handling.
1053 self.input_hist = InputList()
1053 self.input_hist = InputList()
1054 # This one will hold the 'raw' input history, without any
1054 # This one will hold the 'raw' input history, without any
1055 # pre-processing. This will allow users to retrieve the input just as
1055 # pre-processing. This will allow users to retrieve the input just as
1056 # it was exactly typed in by the user, with %hist -r.
1056 # it was exactly typed in by the user, with %hist -r.
1057 self.input_hist_raw = InputList()
1057 self.input_hist_raw = InputList()
1058
1058
1059 # list of visited directories
1059 # list of visited directories
1060 try:
1060 try:
1061 self.dir_hist = [os.getcwd()]
1061 self.dir_hist = [os.getcwd()]
1062 except OSError:
1062 except OSError:
1063 self.dir_hist = []
1063 self.dir_hist = []
1064
1064
1065 # dict of output history
1065 # dict of output history
1066 self.output_hist = {}
1066 self.output_hist = {}
1067
1067
1068 # Now the history file
1068 # Now the history file
1069 if self.profile:
1069 if self.profile:
1070 histfname = 'history-%s' % self.profile
1070 histfname = 'history-%s' % self.profile
1071 else:
1071 else:
1072 histfname = 'history'
1072 histfname = 'history'
1073 self.histfile = os.path.join(self.ipythondir, histfname)
1073 self.histfile = os.path.join(self.ipythondir, histfname)
1074
1074
1075 # Fill the history zero entry, user counter starts at 1
1075 # Fill the history zero entry, user counter starts at 1
1076 self.input_hist.append('\n')
1076 self.input_hist.append('\n')
1077 self.input_hist_raw.append('\n')
1077 self.input_hist_raw.append('\n')
1078
1078
1079 def init_shadow_hist(self):
1079 def init_shadow_hist(self):
1080 try:
1080 try:
1081 self.db = pickleshare.PickleShareDB(self.ipythondir + "/db")
1081 self.db = pickleshare.PickleShareDB(self.ipythondir + "/db")
1082 except exceptions.UnicodeDecodeError:
1082 except exceptions.UnicodeDecodeError:
1083 print "Your ipythondir can't be decoded to unicode!"
1083 print "Your ipythondir can't be decoded to unicode!"
1084 print "Please set HOME environment variable to something that"
1084 print "Please set HOME environment variable to something that"
1085 print r"only has ASCII characters, e.g. c:\home"
1085 print r"only has ASCII characters, e.g. c:\home"
1086 print "Now it is", self.ipythondir
1086 print "Now it is", self.ipythondir
1087 sys.exit()
1087 sys.exit()
1088 self.shadowhist = ipcorehist.ShadowHist(self.db)
1088 self.shadowhist = ipcorehist.ShadowHist(self.db)
1089
1089
1090 def savehist(self):
1090 def savehist(self):
1091 """Save input history to a file (via readline library)."""
1091 """Save input history to a file (via readline library)."""
1092
1092
1093 if not self.has_readline:
1093 if not self.has_readline:
1094 return
1094 return
1095
1095
1096 try:
1096 try:
1097 self.readline.write_history_file(self.histfile)
1097 self.readline.write_history_file(self.histfile)
1098 except:
1098 except:
1099 print 'Unable to save IPython command history to file: ' + \
1099 print 'Unable to save IPython command history to file: ' + \
1100 `self.histfile`
1100 `self.histfile`
1101
1101
1102 def reloadhist(self):
1102 def reloadhist(self):
1103 """Reload the input history from disk file."""
1103 """Reload the input history from disk file."""
1104
1104
1105 if self.has_readline:
1105 if self.has_readline:
1106 try:
1106 try:
1107 self.readline.clear_history()
1107 self.readline.clear_history()
1108 self.readline.read_history_file(self.shell.histfile)
1108 self.readline.read_history_file(self.shell.histfile)
1109 except AttributeError:
1109 except AttributeError:
1110 pass
1110 pass
1111
1111
1112 def history_saving_wrapper(self, func):
1112 def history_saving_wrapper(self, func):
1113 """ Wrap func for readline history saving
1113 """ Wrap func for readline history saving
1114
1114
1115 Convert func into callable that saves & restores
1115 Convert func into callable that saves & restores
1116 history around the call """
1116 history around the call """
1117
1117
1118 if not self.has_readline:
1118 if not self.has_readline:
1119 return func
1119 return func
1120
1120
1121 def wrapper():
1121 def wrapper():
1122 self.savehist()
1122 self.savehist()
1123 try:
1123 try:
1124 func()
1124 func()
1125 finally:
1125 finally:
1126 readline.read_history_file(self.histfile)
1126 readline.read_history_file(self.histfile)
1127 return wrapper
1127 return wrapper
1128
1128
1129 #-------------------------------------------------------------------------
1129 #-------------------------------------------------------------------------
1130 # Things related to exception handling and tracebacks (not debugging)
1130 # Things related to exception handling and tracebacks (not debugging)
1131 #-------------------------------------------------------------------------
1131 #-------------------------------------------------------------------------
1132
1132
1133 def init_traceback_handlers(self, custom_exceptions):
1133 def init_traceback_handlers(self, custom_exceptions):
1134 # Syntax error handler.
1134 # Syntax error handler.
1135 self.SyntaxTB = SyntaxTB(color_scheme='NoColor')
1135 self.SyntaxTB = SyntaxTB(color_scheme='NoColor')
1136
1136
1137 # The interactive one is initialized with an offset, meaning we always
1137 # The interactive one is initialized with an offset, meaning we always
1138 # want to remove the topmost item in the traceback, which is our own
1138 # want to remove the topmost item in the traceback, which is our own
1139 # internal code. Valid modes: ['Plain','Context','Verbose']
1139 # internal code. Valid modes: ['Plain','Context','Verbose']
1140 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1140 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1141 color_scheme='NoColor',
1141 color_scheme='NoColor',
1142 tb_offset = 1)
1142 tb_offset = 1)
1143
1143
1144 # IPython itself shouldn't crash. This will produce a detailed
1144 # IPython itself shouldn't crash. This will produce a detailed
1145 # post-mortem if it does. But we only install the crash handler for
1145 # post-mortem if it does. But we only install the crash handler for
1146 # non-threaded shells, the threaded ones use a normal verbose reporter
1146 # non-threaded shells, the threaded ones use a normal verbose reporter
1147 # and lose the crash handler. This is because exceptions in the main
1147 # and lose the crash handler. This is because exceptions in the main
1148 # thread (such as in GUI code) propagate directly to sys.excepthook,
1148 # thread (such as in GUI code) propagate directly to sys.excepthook,
1149 # and there's no point in printing crash dumps for every user exception.
1149 # and there's no point in printing crash dumps for every user exception.
1150 if self.isthreaded:
1150 if self.isthreaded:
1151 ipCrashHandler = ultratb.FormattedTB()
1151 ipCrashHandler = ultratb.FormattedTB()
1152 else:
1152 else:
1153 from IPython.core import crashhandler
1153 from IPython.core import crashhandler
1154 ipCrashHandler = crashhandler.IPythonCrashHandler(self)
1154 ipCrashHandler = crashhandler.IPythonCrashHandler(self)
1155 self.set_crash_handler(ipCrashHandler)
1155 self.set_crash_handler(ipCrashHandler)
1156
1156
1157 # and add any custom exception handlers the user may have specified
1157 # and add any custom exception handlers the user may have specified
1158 self.set_custom_exc(*custom_exceptions)
1158 self.set_custom_exc(*custom_exceptions)
1159
1159
1160 def set_crash_handler(self, crashHandler):
1160 def set_crash_handler(self, crashHandler):
1161 """Set the IPython crash handler.
1161 """Set the IPython crash handler.
1162
1162
1163 This must be a callable with a signature suitable for use as
1163 This must be a callable with a signature suitable for use as
1164 sys.excepthook."""
1164 sys.excepthook."""
1165
1165
1166 # Install the given crash handler as the Python exception hook
1166 # Install the given crash handler as the Python exception hook
1167 sys.excepthook = crashHandler
1167 sys.excepthook = crashHandler
1168
1168
1169 # The instance will store a pointer to this, so that runtime code
1169 # The instance will store a pointer to this, so that runtime code
1170 # (such as magics) can access it. This is because during the
1170 # (such as magics) can access it. This is because during the
1171 # read-eval loop, it gets temporarily overwritten (to deal with GUI
1171 # read-eval loop, it gets temporarily overwritten (to deal with GUI
1172 # frameworks).
1172 # frameworks).
1173 self.sys_excepthook = sys.excepthook
1173 self.sys_excepthook = sys.excepthook
1174
1174
1175 def set_custom_exc(self,exc_tuple,handler):
1175 def set_custom_exc(self,exc_tuple,handler):
1176 """set_custom_exc(exc_tuple,handler)
1176 """set_custom_exc(exc_tuple,handler)
1177
1177
1178 Set a custom exception handler, which will be called if any of the
1178 Set a custom exception handler, which will be called if any of the
1179 exceptions in exc_tuple occur in the mainloop (specifically, in the
1179 exceptions in exc_tuple occur in the mainloop (specifically, in the
1180 runcode() method.
1180 runcode() method.
1181
1181
1182 Inputs:
1182 Inputs:
1183
1183
1184 - exc_tuple: a *tuple* of valid exceptions to call the defined
1184 - exc_tuple: a *tuple* of valid exceptions to call the defined
1185 handler for. It is very important that you use a tuple, and NOT A
1185 handler for. It is very important that you use a tuple, and NOT A
1186 LIST here, because of the way Python's except statement works. If
1186 LIST here, because of the way Python's except statement works. If
1187 you only want to trap a single exception, use a singleton tuple:
1187 you only want to trap a single exception, use a singleton tuple:
1188
1188
1189 exc_tuple == (MyCustomException,)
1189 exc_tuple == (MyCustomException,)
1190
1190
1191 - handler: this must be defined as a function with the following
1191 - handler: this must be defined as a function with the following
1192 basic interface: def my_handler(self,etype,value,tb).
1192 basic interface: def my_handler(self,etype,value,tb).
1193
1193
1194 This will be made into an instance method (via new.instancemethod)
1194 This will be made into an instance method (via new.instancemethod)
1195 of IPython itself, and it will be called if any of the exceptions
1195 of IPython itself, and it will be called if any of the exceptions
1196 listed in the exc_tuple are caught. If the handler is None, an
1196 listed in the exc_tuple are caught. If the handler is None, an
1197 internal basic one is used, which just prints basic info.
1197 internal basic one is used, which just prints basic info.
1198
1198
1199 WARNING: by putting in your own exception handler into IPython's main
1199 WARNING: by putting in your own exception handler into IPython's main
1200 execution loop, you run a very good chance of nasty crashes. This
1200 execution loop, you run a very good chance of nasty crashes. This
1201 facility should only be used if you really know what you are doing."""
1201 facility should only be used if you really know what you are doing."""
1202
1202
1203 assert type(exc_tuple)==type(()) , \
1203 assert type(exc_tuple)==type(()) , \
1204 "The custom exceptions must be given AS A TUPLE."
1204 "The custom exceptions must be given AS A TUPLE."
1205
1205
1206 def dummy_handler(self,etype,value,tb):
1206 def dummy_handler(self,etype,value,tb):
1207 print '*** Simple custom exception handler ***'
1207 print '*** Simple custom exception handler ***'
1208 print 'Exception type :',etype
1208 print 'Exception type :',etype
1209 print 'Exception value:',value
1209 print 'Exception value:',value
1210 print 'Traceback :',tb
1210 print 'Traceback :',tb
1211 print 'Source code :','\n'.join(self.buffer)
1211 print 'Source code :','\n'.join(self.buffer)
1212
1212
1213 if handler is None: handler = dummy_handler
1213 if handler is None: handler = dummy_handler
1214
1214
1215 self.CustomTB = new.instancemethod(handler,self,self.__class__)
1215 self.CustomTB = new.instancemethod(handler,self,self.__class__)
1216 self.custom_exceptions = exc_tuple
1216 self.custom_exceptions = exc_tuple
1217
1217
1218 def excepthook(self, etype, value, tb):
1218 def excepthook(self, etype, value, tb):
1219 """One more defense for GUI apps that call sys.excepthook.
1219 """One more defense for GUI apps that call sys.excepthook.
1220
1220
1221 GUI frameworks like wxPython trap exceptions and call
1221 GUI frameworks like wxPython trap exceptions and call
1222 sys.excepthook themselves. I guess this is a feature that
1222 sys.excepthook themselves. I guess this is a feature that
1223 enables them to keep running after exceptions that would
1223 enables them to keep running after exceptions that would
1224 otherwise kill their mainloop. This is a bother for IPython
1224 otherwise kill their mainloop. This is a bother for IPython
1225 which excepts to catch all of the program exceptions with a try:
1225 which excepts to catch all of the program exceptions with a try:
1226 except: statement.
1226 except: statement.
1227
1227
1228 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1228 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1229 any app directly invokes sys.excepthook, it will look to the user like
1229 any app directly invokes sys.excepthook, it will look to the user like
1230 IPython crashed. In order to work around this, we can disable the
1230 IPython crashed. In order to work around this, we can disable the
1231 CrashHandler and replace it with this excepthook instead, which prints a
1231 CrashHandler and replace it with this excepthook instead, which prints a
1232 regular traceback using our InteractiveTB. In this fashion, apps which
1232 regular traceback using our InteractiveTB. In this fashion, apps which
1233 call sys.excepthook will generate a regular-looking exception from
1233 call sys.excepthook will generate a regular-looking exception from
1234 IPython, and the CrashHandler will only be triggered by real IPython
1234 IPython, and the CrashHandler will only be triggered by real IPython
1235 crashes.
1235 crashes.
1236
1236
1237 This hook should be used sparingly, only in places which are not likely
1237 This hook should be used sparingly, only in places which are not likely
1238 to be true IPython errors.
1238 to be true IPython errors.
1239 """
1239 """
1240 self.showtraceback((etype,value,tb),tb_offset=0)
1240 self.showtraceback((etype,value,tb),tb_offset=0)
1241
1241
1242 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None):
1242 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None):
1243 """Display the exception that just occurred.
1243 """Display the exception that just occurred.
1244
1244
1245 If nothing is known about the exception, this is the method which
1245 If nothing is known about the exception, this is the method which
1246 should be used throughout the code for presenting user tracebacks,
1246 should be used throughout the code for presenting user tracebacks,
1247 rather than directly invoking the InteractiveTB object.
1247 rather than directly invoking the InteractiveTB object.
1248
1248
1249 A specific showsyntaxerror() also exists, but this method can take
1249 A specific showsyntaxerror() also exists, but this method can take
1250 care of calling it if needed, so unless you are explicitly catching a
1250 care of calling it if needed, so unless you are explicitly catching a
1251 SyntaxError exception, don't try to analyze the stack manually and
1251 SyntaxError exception, don't try to analyze the stack manually and
1252 simply call this method."""
1252 simply call this method."""
1253
1253
1254
1254
1255 # Though this won't be called by syntax errors in the input line,
1255 # Though this won't be called by syntax errors in the input line,
1256 # there may be SyntaxError cases whith imported code.
1256 # there may be SyntaxError cases whith imported code.
1257
1257
1258 try:
1258 try:
1259 if exc_tuple is None:
1259 if exc_tuple is None:
1260 etype, value, tb = sys.exc_info()
1260 etype, value, tb = sys.exc_info()
1261 else:
1261 else:
1262 etype, value, tb = exc_tuple
1262 etype, value, tb = exc_tuple
1263
1263
1264 if etype is SyntaxError:
1264 if etype is SyntaxError:
1265 self.showsyntaxerror(filename)
1265 self.showsyntaxerror(filename)
1266 elif etype is UsageError:
1266 elif etype is UsageError:
1267 print "UsageError:", value
1267 print "UsageError:", value
1268 else:
1268 else:
1269 # WARNING: these variables are somewhat deprecated and not
1269 # WARNING: these variables are somewhat deprecated and not
1270 # necessarily safe to use in a threaded environment, but tools
1270 # necessarily safe to use in a threaded environment, but tools
1271 # like pdb depend on their existence, so let's set them. If we
1271 # like pdb depend on their existence, so let's set them. If we
1272 # find problems in the field, we'll need to revisit their use.
1272 # find problems in the field, we'll need to revisit their use.
1273 sys.last_type = etype
1273 sys.last_type = etype
1274 sys.last_value = value
1274 sys.last_value = value
1275 sys.last_traceback = tb
1275 sys.last_traceback = tb
1276
1276
1277 if etype in self.custom_exceptions:
1277 if etype in self.custom_exceptions:
1278 self.CustomTB(etype,value,tb)
1278 self.CustomTB(etype,value,tb)
1279 else:
1279 else:
1280 self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)
1280 self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)
1281 if self.InteractiveTB.call_pdb and self.has_readline:
1281 if self.InteractiveTB.call_pdb and self.has_readline:
1282 # pdb mucks up readline, fix it back
1282 # pdb mucks up readline, fix it back
1283 self.set_completer()
1283 self.set_completer()
1284 except KeyboardInterrupt:
1284 except KeyboardInterrupt:
1285 self.write("\nKeyboardInterrupt\n")
1285 self.write("\nKeyboardInterrupt\n")
1286
1286
1287 def showsyntaxerror(self, filename=None):
1287 def showsyntaxerror(self, filename=None):
1288 """Display the syntax error that just occurred.
1288 """Display the syntax error that just occurred.
1289
1289
1290 This doesn't display a stack trace because there isn't one.
1290 This doesn't display a stack trace because there isn't one.
1291
1291
1292 If a filename is given, it is stuffed in the exception instead
1292 If a filename is given, it is stuffed in the exception instead
1293 of what was there before (because Python's parser always uses
1293 of what was there before (because Python's parser always uses
1294 "<string>" when reading from a string).
1294 "<string>" when reading from a string).
1295 """
1295 """
1296 etype, value, last_traceback = sys.exc_info()
1296 etype, value, last_traceback = sys.exc_info()
1297
1297
1298 # See note about these variables in showtraceback() below
1298 # See note about these variables in showtraceback() below
1299 sys.last_type = etype
1299 sys.last_type = etype
1300 sys.last_value = value
1300 sys.last_value = value
1301 sys.last_traceback = last_traceback
1301 sys.last_traceback = last_traceback
1302
1302
1303 if filename and etype is SyntaxError:
1303 if filename and etype is SyntaxError:
1304 # Work hard to stuff the correct filename in the exception
1304 # Work hard to stuff the correct filename in the exception
1305 try:
1305 try:
1306 msg, (dummy_filename, lineno, offset, line) = value
1306 msg, (dummy_filename, lineno, offset, line) = value
1307 except:
1307 except:
1308 # Not the format we expect; leave it alone
1308 # Not the format we expect; leave it alone
1309 pass
1309 pass
1310 else:
1310 else:
1311 # Stuff in the right filename
1311 # Stuff in the right filename
1312 try:
1312 try:
1313 # Assume SyntaxError is a class exception
1313 # Assume SyntaxError is a class exception
1314 value = SyntaxError(msg, (filename, lineno, offset, line))
1314 value = SyntaxError(msg, (filename, lineno, offset, line))
1315 except:
1315 except:
1316 # If that failed, assume SyntaxError is a string
1316 # If that failed, assume SyntaxError is a string
1317 value = msg, (filename, lineno, offset, line)
1317 value = msg, (filename, lineno, offset, line)
1318 self.SyntaxTB(etype,value,[])
1318 self.SyntaxTB(etype,value,[])
1319
1319
1320 def edit_syntax_error(self):
1320 def edit_syntax_error(self):
1321 """The bottom half of the syntax error handler called in the main loop.
1321 """The bottom half of the syntax error handler called in the main loop.
1322
1322
1323 Loop until syntax error is fixed or user cancels.
1323 Loop until syntax error is fixed or user cancels.
1324 """
1324 """
1325
1325
1326 while self.SyntaxTB.last_syntax_error:
1326 while self.SyntaxTB.last_syntax_error:
1327 # copy and clear last_syntax_error
1327 # copy and clear last_syntax_error
1328 err = self.SyntaxTB.clear_err_state()
1328 err = self.SyntaxTB.clear_err_state()
1329 if not self._should_recompile(err):
1329 if not self._should_recompile(err):
1330 return
1330 return
1331 try:
1331 try:
1332 # may set last_syntax_error again if a SyntaxError is raised
1332 # may set last_syntax_error again if a SyntaxError is raised
1333 self.safe_execfile(err.filename,self.user_ns)
1333 self.safe_execfile(err.filename,self.user_ns)
1334 except:
1334 except:
1335 self.showtraceback()
1335 self.showtraceback()
1336 else:
1336 else:
1337 try:
1337 try:
1338 f = file(err.filename)
1338 f = file(err.filename)
1339 try:
1339 try:
1340 # This should be inside a display_trap block and I
1340 # This should be inside a display_trap block and I
1341 # think it is.
1341 # think it is.
1342 sys.displayhook(f.read())
1342 sys.displayhook(f.read())
1343 finally:
1343 finally:
1344 f.close()
1344 f.close()
1345 except:
1345 except:
1346 self.showtraceback()
1346 self.showtraceback()
1347
1347
1348 def _should_recompile(self,e):
1348 def _should_recompile(self,e):
1349 """Utility routine for edit_syntax_error"""
1349 """Utility routine for edit_syntax_error"""
1350
1350
1351 if e.filename in ('<ipython console>','<input>','<string>',
1351 if e.filename in ('<ipython console>','<input>','<string>',
1352 '<console>','<BackgroundJob compilation>',
1352 '<console>','<BackgroundJob compilation>',
1353 None):
1353 None):
1354
1354
1355 return False
1355 return False
1356 try:
1356 try:
1357 if (self.autoedit_syntax and
1357 if (self.autoedit_syntax and
1358 not self.ask_yes_no('Return to editor to correct syntax error? '
1358 not self.ask_yes_no('Return to editor to correct syntax error? '
1359 '[Y/n] ','y')):
1359 '[Y/n] ','y')):
1360 return False
1360 return False
1361 except EOFError:
1361 except EOFError:
1362 return False
1362 return False
1363
1363
1364 def int0(x):
1364 def int0(x):
1365 try:
1365 try:
1366 return int(x)
1366 return int(x)
1367 except TypeError:
1367 except TypeError:
1368 return 0
1368 return 0
1369 # always pass integer line and offset values to editor hook
1369 # always pass integer line and offset values to editor hook
1370 try:
1370 try:
1371 self.hooks.fix_error_editor(e.filename,
1371 self.hooks.fix_error_editor(e.filename,
1372 int0(e.lineno),int0(e.offset),e.msg)
1372 int0(e.lineno),int0(e.offset),e.msg)
1373 except TryNext:
1373 except TryNext:
1374 warn('Could not open editor')
1374 warn('Could not open editor')
1375 return False
1375 return False
1376 return True
1376 return True
1377
1377
1378 #-------------------------------------------------------------------------
1378 #-------------------------------------------------------------------------
1379 # Things related to tab completion
1379 # Things related to tab completion
1380 #-------------------------------------------------------------------------
1380 #-------------------------------------------------------------------------
1381
1381
1382 def complete(self, text):
1382 def complete(self, text):
1383 """Return a sorted list of all possible completions on text.
1383 """Return a sorted list of all possible completions on text.
1384
1384
1385 Inputs:
1385 Inputs:
1386
1386
1387 - text: a string of text to be completed on.
1387 - text: a string of text to be completed on.
1388
1388
1389 This is a wrapper around the completion mechanism, similar to what
1389 This is a wrapper around the completion mechanism, similar to what
1390 readline does at the command line when the TAB key is hit. By
1390 readline does at the command line when the TAB key is hit. By
1391 exposing it as a method, it can be used by other non-readline
1391 exposing it as a method, it can be used by other non-readline
1392 environments (such as GUIs) for text completion.
1392 environments (such as GUIs) for text completion.
1393
1393
1394 Simple usage example:
1394 Simple usage example:
1395
1395
1396 In [7]: x = 'hello'
1396 In [7]: x = 'hello'
1397
1397
1398 In [8]: x
1398 In [8]: x
1399 Out[8]: 'hello'
1399 Out[8]: 'hello'
1400
1400
1401 In [9]: print x
1401 In [9]: print x
1402 hello
1402 hello
1403
1403
1404 In [10]: _ip.complete('x.l')
1404 In [10]: _ip.complete('x.l')
1405 Out[10]: ['x.ljust', 'x.lower', 'x.lstrip']
1405 Out[10]: ['x.ljust', 'x.lower', 'x.lstrip']
1406 """
1406 """
1407
1407
1408 # Inject names into __builtin__ so we can complete on the added names.
1408 # Inject names into __builtin__ so we can complete on the added names.
1409 with self.builtin_trap:
1409 with self.builtin_trap:
1410 complete = self.Completer.complete
1410 complete = self.Completer.complete
1411 state = 0
1411 state = 0
1412 # use a dict so we get unique keys, since ipyhton's multiple
1412 # use a dict so we get unique keys, since ipyhton's multiple
1413 # completers can return duplicates. When we make 2.4 a requirement,
1413 # completers can return duplicates. When we make 2.4 a requirement,
1414 # start using sets instead, which are faster.
1414 # start using sets instead, which are faster.
1415 comps = {}
1415 comps = {}
1416 while True:
1416 while True:
1417 newcomp = complete(text,state,line_buffer=text)
1417 newcomp = complete(text,state,line_buffer=text)
1418 if newcomp is None:
1418 if newcomp is None:
1419 break
1419 break
1420 comps[newcomp] = 1
1420 comps[newcomp] = 1
1421 state += 1
1421 state += 1
1422 outcomps = comps.keys()
1422 outcomps = comps.keys()
1423 outcomps.sort()
1423 outcomps.sort()
1424 #print "T:",text,"OC:",outcomps # dbg
1424 #print "T:",text,"OC:",outcomps # dbg
1425 #print "vars:",self.user_ns.keys()
1425 #print "vars:",self.user_ns.keys()
1426 return outcomps
1426 return outcomps
1427
1427
1428 def set_custom_completer(self,completer,pos=0):
1428 def set_custom_completer(self,completer,pos=0):
1429 """set_custom_completer(completer,pos=0)
1429 """Adds a new custom completer function.
1430
1431 Adds a new custom completer function.
1432
1430
1433 The position argument (defaults to 0) is the index in the completers
1431 The position argument (defaults to 0) is the index in the completers
1434 list where you want the completer to be inserted."""
1432 list where you want the completer to be inserted."""
1435
1433
1436 newcomp = new.instancemethod(completer,self.Completer,
1434 newcomp = new.instancemethod(completer,self.Completer,
1437 self.Completer.__class__)
1435 self.Completer.__class__)
1438 self.Completer.matchers.insert(pos,newcomp)
1436 self.Completer.matchers.insert(pos,newcomp)
1439
1437
1440 def set_completer(self):
1438 def set_completer(self):
1441 """reset readline's completer to be our own."""
1439 """Reset readline's completer to be our own."""
1442 self.readline.set_completer(self.Completer.complete)
1440 self.readline.set_completer(self.Completer.complete)
1443
1441
1442 def set_completer_frame(self, frame=None):
1443 """Set the frame of the completer."""
1444 if frame:
1445 self.Completer.namespace = frame.f_locals
1446 self.Completer.global_namespace = frame.f_globals
1447 else:
1448 self.Completer.namespace = self.user_ns
1449 self.Completer.global_namespace = self.user_global_ns
1450
1444 #-------------------------------------------------------------------------
1451 #-------------------------------------------------------------------------
1445 # Things related to readline
1452 # Things related to readline
1446 #-------------------------------------------------------------------------
1453 #-------------------------------------------------------------------------
1447
1454
1448 def init_readline(self):
1455 def init_readline(self):
1449 """Command history completion/saving/reloading."""
1456 """Command history completion/saving/reloading."""
1450
1457
1451 self.rl_next_input = None
1458 self.rl_next_input = None
1452 self.rl_do_indent = False
1459 self.rl_do_indent = False
1453
1460
1454 if not self.readline_use:
1461 if not self.readline_use:
1455 return
1462 return
1456
1463
1457 import IPython.utils.rlineimpl as readline
1464 import IPython.utils.rlineimpl as readline
1458
1465
1459 if not readline.have_readline:
1466 if not readline.have_readline:
1460 self.has_readline = 0
1467 self.has_readline = 0
1461 self.readline = None
1468 self.readline = None
1462 # no point in bugging windows users with this every time:
1469 # no point in bugging windows users with this every time:
1463 warn('Readline services not available on this platform.')
1470 warn('Readline services not available on this platform.')
1464 else:
1471 else:
1465 sys.modules['readline'] = readline
1472 sys.modules['readline'] = readline
1466 import atexit
1473 import atexit
1467 from IPython.core.completer import IPCompleter
1474 from IPython.core.completer import IPCompleter
1468 self.Completer = IPCompleter(self,
1475 self.Completer = IPCompleter(self,
1469 self.user_ns,
1476 self.user_ns,
1470 self.user_global_ns,
1477 self.user_global_ns,
1471 self.readline_omit__names,
1478 self.readline_omit__names,
1472 self.alias_manager.alias_table)
1479 self.alias_manager.alias_table)
1473 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1480 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1474 self.strdispatchers['complete_command'] = sdisp
1481 self.strdispatchers['complete_command'] = sdisp
1475 self.Completer.custom_completers = sdisp
1482 self.Completer.custom_completers = sdisp
1476 # Platform-specific configuration
1483 # Platform-specific configuration
1477 if os.name == 'nt':
1484 if os.name == 'nt':
1478 self.readline_startup_hook = readline.set_pre_input_hook
1485 self.readline_startup_hook = readline.set_pre_input_hook
1479 else:
1486 else:
1480 self.readline_startup_hook = readline.set_startup_hook
1487 self.readline_startup_hook = readline.set_startup_hook
1481
1488
1482 # Load user's initrc file (readline config)
1489 # Load user's initrc file (readline config)
1483 # Or if libedit is used, load editrc.
1490 # Or if libedit is used, load editrc.
1484 inputrc_name = os.environ.get('INPUTRC')
1491 inputrc_name = os.environ.get('INPUTRC')
1485 if inputrc_name is None:
1492 if inputrc_name is None:
1486 home_dir = get_home_dir()
1493 home_dir = get_home_dir()
1487 if home_dir is not None:
1494 if home_dir is not None:
1488 inputrc_name = '.inputrc'
1495 inputrc_name = '.inputrc'
1489 if readline.uses_libedit:
1496 if readline.uses_libedit:
1490 inputrc_name = '.editrc'
1497 inputrc_name = '.editrc'
1491 inputrc_name = os.path.join(home_dir, inputrc_name)
1498 inputrc_name = os.path.join(home_dir, inputrc_name)
1492 if os.path.isfile(inputrc_name):
1499 if os.path.isfile(inputrc_name):
1493 try:
1500 try:
1494 readline.read_init_file(inputrc_name)
1501 readline.read_init_file(inputrc_name)
1495 except:
1502 except:
1496 warn('Problems reading readline initialization file <%s>'
1503 warn('Problems reading readline initialization file <%s>'
1497 % inputrc_name)
1504 % inputrc_name)
1498
1505
1499 self.has_readline = 1
1506 self.has_readline = 1
1500 self.readline = readline
1507 self.readline = readline
1501 # save this in sys so embedded copies can restore it properly
1508 # save this in sys so embedded copies can restore it properly
1502 sys.ipcompleter = self.Completer.complete
1509 sys.ipcompleter = self.Completer.complete
1503 self.set_completer()
1510 self.set_completer()
1504
1511
1505 # Configure readline according to user's prefs
1512 # Configure readline according to user's prefs
1506 # This is only done if GNU readline is being used. If libedit
1513 # This is only done if GNU readline is being used. If libedit
1507 # is being used (as on Leopard) the readline config is
1514 # is being used (as on Leopard) the readline config is
1508 # not run as the syntax for libedit is different.
1515 # not run as the syntax for libedit is different.
1509 if not readline.uses_libedit:
1516 if not readline.uses_libedit:
1510 for rlcommand in self.readline_parse_and_bind:
1517 for rlcommand in self.readline_parse_and_bind:
1511 #print "loading rl:",rlcommand # dbg
1518 #print "loading rl:",rlcommand # dbg
1512 readline.parse_and_bind(rlcommand)
1519 readline.parse_and_bind(rlcommand)
1513
1520
1514 # Remove some chars from the delimiters list. If we encounter
1521 # Remove some chars from the delimiters list. If we encounter
1515 # unicode chars, discard them.
1522 # unicode chars, discard them.
1516 delims = readline.get_completer_delims().encode("ascii", "ignore")
1523 delims = readline.get_completer_delims().encode("ascii", "ignore")
1517 delims = delims.translate(string._idmap,
1524 delims = delims.translate(string._idmap,
1518 self.readline_remove_delims)
1525 self.readline_remove_delims)
1519 readline.set_completer_delims(delims)
1526 readline.set_completer_delims(delims)
1520 # otherwise we end up with a monster history after a while:
1527 # otherwise we end up with a monster history after a while:
1521 readline.set_history_length(1000)
1528 readline.set_history_length(1000)
1522 try:
1529 try:
1523 #print '*** Reading readline history' # dbg
1530 #print '*** Reading readline history' # dbg
1524 readline.read_history_file(self.histfile)
1531 readline.read_history_file(self.histfile)
1525 except IOError:
1532 except IOError:
1526 pass # It doesn't exist yet.
1533 pass # It doesn't exist yet.
1527
1534
1528 atexit.register(self.atexit_operations)
1535 atexit.register(self.atexit_operations)
1529 del atexit
1536 del atexit
1530
1537
1531 # Configure auto-indent for all platforms
1538 # Configure auto-indent for all platforms
1532 self.set_autoindent(self.autoindent)
1539 self.set_autoindent(self.autoindent)
1533
1540
1534 def set_next_input(self, s):
1541 def set_next_input(self, s):
1535 """ Sets the 'default' input string for the next command line.
1542 """ Sets the 'default' input string for the next command line.
1536
1543
1537 Requires readline.
1544 Requires readline.
1538
1545
1539 Example:
1546 Example:
1540
1547
1541 [D:\ipython]|1> _ip.set_next_input("Hello Word")
1548 [D:\ipython]|1> _ip.set_next_input("Hello Word")
1542 [D:\ipython]|2> Hello Word_ # cursor is here
1549 [D:\ipython]|2> Hello Word_ # cursor is here
1543 """
1550 """
1544
1551
1545 self.rl_next_input = s
1552 self.rl_next_input = s
1546
1553
1547 def pre_readline(self):
1554 def pre_readline(self):
1548 """readline hook to be used at the start of each line.
1555 """readline hook to be used at the start of each line.
1549
1556
1550 Currently it handles auto-indent only."""
1557 Currently it handles auto-indent only."""
1551
1558
1552 #debugx('self.indent_current_nsp','pre_readline:')
1559 #debugx('self.indent_current_nsp','pre_readline:')
1553
1560
1554 if self.rl_do_indent:
1561 if self.rl_do_indent:
1555 self.readline.insert_text(self._indent_current_str())
1562 self.readline.insert_text(self._indent_current_str())
1556 if self.rl_next_input is not None:
1563 if self.rl_next_input is not None:
1557 self.readline.insert_text(self.rl_next_input)
1564 self.readline.insert_text(self.rl_next_input)
1558 self.rl_next_input = None
1565 self.rl_next_input = None
1559
1566
1560 def _indent_current_str(self):
1567 def _indent_current_str(self):
1561 """return the current level of indentation as a string"""
1568 """return the current level of indentation as a string"""
1562 return self.indent_current_nsp * ' '
1569 return self.indent_current_nsp * ' '
1563
1570
1564 #-------------------------------------------------------------------------
1571 #-------------------------------------------------------------------------
1565 # Things related to magics
1572 # Things related to magics
1566 #-------------------------------------------------------------------------
1573 #-------------------------------------------------------------------------
1567
1574
1568 def init_magics(self):
1575 def init_magics(self):
1569 # Set user colors (don't do it in the constructor above so that it
1576 # Set user colors (don't do it in the constructor above so that it
1570 # doesn't crash if colors option is invalid)
1577 # doesn't crash if colors option is invalid)
1571 self.magic_colors(self.colors)
1578 self.magic_colors(self.colors)
1572
1579
1573 def magic(self,arg_s):
1580 def magic(self,arg_s):
1574 """Call a magic function by name.
1581 """Call a magic function by name.
1575
1582
1576 Input: a string containing the name of the magic function to call and any
1583 Input: a string containing the name of the magic function to call and any
1577 additional arguments to be passed to the magic.
1584 additional arguments to be passed to the magic.
1578
1585
1579 magic('name -opt foo bar') is equivalent to typing at the ipython
1586 magic('name -opt foo bar') is equivalent to typing at the ipython
1580 prompt:
1587 prompt:
1581
1588
1582 In[1]: %name -opt foo bar
1589 In[1]: %name -opt foo bar
1583
1590
1584 To call a magic without arguments, simply use magic('name').
1591 To call a magic without arguments, simply use magic('name').
1585
1592
1586 This provides a proper Python function to call IPython's magics in any
1593 This provides a proper Python function to call IPython's magics in any
1587 valid Python code you can type at the interpreter, including loops and
1594 valid Python code you can type at the interpreter, including loops and
1588 compound statements.
1595 compound statements.
1589 """
1596 """
1590
1597
1591 args = arg_s.split(' ',1)
1598 args = arg_s.split(' ',1)
1592 magic_name = args[0]
1599 magic_name = args[0]
1593 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
1600 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
1594
1601
1595 try:
1602 try:
1596 magic_args = args[1]
1603 magic_args = args[1]
1597 except IndexError:
1604 except IndexError:
1598 magic_args = ''
1605 magic_args = ''
1599 fn = getattr(self,'magic_'+magic_name,None)
1606 fn = getattr(self,'magic_'+magic_name,None)
1600 if fn is None:
1607 if fn is None:
1601 error("Magic function `%s` not found." % magic_name)
1608 error("Magic function `%s` not found." % magic_name)
1602 else:
1609 else:
1603 magic_args = self.var_expand(magic_args,1)
1610 magic_args = self.var_expand(magic_args,1)
1604 with nested(self.builtin_trap,):
1611 with nested(self.builtin_trap,):
1605 result = fn(magic_args)
1612 result = fn(magic_args)
1606 return result
1613 return result
1607
1614
1608 def define_magic(self, magicname, func):
1615 def define_magic(self, magicname, func):
1609 """Expose own function as magic function for ipython
1616 """Expose own function as magic function for ipython
1610
1617
1611 def foo_impl(self,parameter_s=''):
1618 def foo_impl(self,parameter_s=''):
1612 'My very own magic!. (Use docstrings, IPython reads them).'
1619 'My very own magic!. (Use docstrings, IPython reads them).'
1613 print 'Magic function. Passed parameter is between < >:'
1620 print 'Magic function. Passed parameter is between < >:'
1614 print '<%s>' % parameter_s
1621 print '<%s>' % parameter_s
1615 print 'The self object is:',self
1622 print 'The self object is:',self
1616
1623
1617 self.define_magic('foo',foo_impl)
1624 self.define_magic('foo',foo_impl)
1618 """
1625 """
1619
1626
1620 import new
1627 import new
1621 im = new.instancemethod(func,self, self.__class__)
1628 im = new.instancemethod(func,self, self.__class__)
1622 old = getattr(self, "magic_" + magicname, None)
1629 old = getattr(self, "magic_" + magicname, None)
1623 setattr(self, "magic_" + magicname, im)
1630 setattr(self, "magic_" + magicname, im)
1624 return old
1631 return old
1625
1632
1626 #-------------------------------------------------------------------------
1633 #-------------------------------------------------------------------------
1627 # Things related to macros
1634 # Things related to macros
1628 #-------------------------------------------------------------------------
1635 #-------------------------------------------------------------------------
1629
1636
1630 def define_macro(self, name, themacro):
1637 def define_macro(self, name, themacro):
1631 """Define a new macro
1638 """Define a new macro
1632
1639
1633 Parameters
1640 Parameters
1634 ----------
1641 ----------
1635 name : str
1642 name : str
1636 The name of the macro.
1643 The name of the macro.
1637 themacro : str or Macro
1644 themacro : str or Macro
1638 The action to do upon invoking the macro. If a string, a new
1645 The action to do upon invoking the macro. If a string, a new
1639 Macro object is created by passing the string to it.
1646 Macro object is created by passing the string to it.
1640 """
1647 """
1641
1648
1642 from IPython.core import macro
1649 from IPython.core import macro
1643
1650
1644 if isinstance(themacro, basestring):
1651 if isinstance(themacro, basestring):
1645 themacro = macro.Macro(themacro)
1652 themacro = macro.Macro(themacro)
1646 if not isinstance(themacro, macro.Macro):
1653 if not isinstance(themacro, macro.Macro):
1647 raise ValueError('A macro must be a string or a Macro instance.')
1654 raise ValueError('A macro must be a string or a Macro instance.')
1648 self.user_ns[name] = themacro
1655 self.user_ns[name] = themacro
1649
1656
1650 #-------------------------------------------------------------------------
1657 #-------------------------------------------------------------------------
1651 # Things related to the running of system commands
1658 # Things related to the running of system commands
1652 #-------------------------------------------------------------------------
1659 #-------------------------------------------------------------------------
1653
1660
1654 def system(self, cmd):
1661 def system(self, cmd):
1655 """Make a system call, using IPython."""
1662 """Make a system call, using IPython."""
1656 return self.hooks.shell_hook(self.var_expand(cmd, depth=2))
1663 return self.hooks.shell_hook(self.var_expand(cmd, depth=2))
1657
1664
1658 #-------------------------------------------------------------------------
1665 #-------------------------------------------------------------------------
1659 # Things related to aliases
1666 # Things related to aliases
1660 #-------------------------------------------------------------------------
1667 #-------------------------------------------------------------------------
1661
1668
1662 def init_alias(self):
1669 def init_alias(self):
1663 self.alias_manager = AliasManager(self, config=self.config)
1670 self.alias_manager = AliasManager(self, config=self.config)
1664 self.ns_table['alias'] = self.alias_manager.alias_table,
1671 self.ns_table['alias'] = self.alias_manager.alias_table,
1665
1672
1666 #-------------------------------------------------------------------------
1673 #-------------------------------------------------------------------------
1667 # Things related to the running of code
1674 # Things related to the running of code
1668 #-------------------------------------------------------------------------
1675 #-------------------------------------------------------------------------
1669
1676
1670 def ex(self, cmd):
1677 def ex(self, cmd):
1671 """Execute a normal python statement in user namespace."""
1678 """Execute a normal python statement in user namespace."""
1672 with nested(self.builtin_trap,):
1679 with nested(self.builtin_trap,):
1673 exec cmd in self.user_global_ns, self.user_ns
1680 exec cmd in self.user_global_ns, self.user_ns
1674
1681
1675 def ev(self, expr):
1682 def ev(self, expr):
1676 """Evaluate python expression expr in user namespace.
1683 """Evaluate python expression expr in user namespace.
1677
1684
1678 Returns the result of evaluation
1685 Returns the result of evaluation
1679 """
1686 """
1680 with nested(self.builtin_trap,):
1687 with nested(self.builtin_trap,):
1681 return eval(expr, self.user_global_ns, self.user_ns)
1688 return eval(expr, self.user_global_ns, self.user_ns)
1682
1689
1683 def mainloop(self, display_banner=None):
1690 def mainloop(self, display_banner=None):
1684 """Start the mainloop.
1691 """Start the mainloop.
1685
1692
1686 If an optional banner argument is given, it will override the
1693 If an optional banner argument is given, it will override the
1687 internally created default banner.
1694 internally created default banner.
1688 """
1695 """
1689
1696
1690 with nested(self.builtin_trap, self.display_trap):
1697 with nested(self.builtin_trap, self.display_trap):
1691
1698
1692 # if you run stuff with -c <cmd>, raw hist is not updated
1699 # if you run stuff with -c <cmd>, raw hist is not updated
1693 # ensure that it's in sync
1700 # ensure that it's in sync
1694 if len(self.input_hist) != len (self.input_hist_raw):
1701 if len(self.input_hist) != len (self.input_hist_raw):
1695 self.input_hist_raw = InputList(self.input_hist)
1702 self.input_hist_raw = InputList(self.input_hist)
1696
1703
1697 while 1:
1704 while 1:
1698 try:
1705 try:
1699 self.interact(display_banner=display_banner)
1706 self.interact(display_banner=display_banner)
1700 #self.interact_with_readline()
1707 #self.interact_with_readline()
1701 # XXX for testing of a readline-decoupled repl loop, call
1708 # XXX for testing of a readline-decoupled repl loop, call
1702 # interact_with_readline above
1709 # interact_with_readline above
1703 break
1710 break
1704 except KeyboardInterrupt:
1711 except KeyboardInterrupt:
1705 # this should not be necessary, but KeyboardInterrupt
1712 # this should not be necessary, but KeyboardInterrupt
1706 # handling seems rather unpredictable...
1713 # handling seems rather unpredictable...
1707 self.write("\nKeyboardInterrupt in interact()\n")
1714 self.write("\nKeyboardInterrupt in interact()\n")
1708
1715
1709 def interact_prompt(self):
1716 def interact_prompt(self):
1710 """ Print the prompt (in read-eval-print loop)
1717 """ Print the prompt (in read-eval-print loop)
1711
1718
1712 Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not
1719 Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not
1713 used in standard IPython flow.
1720 used in standard IPython flow.
1714 """
1721 """
1715 if self.more:
1722 if self.more:
1716 try:
1723 try:
1717 prompt = self.hooks.generate_prompt(True)
1724 prompt = self.hooks.generate_prompt(True)
1718 except:
1725 except:
1719 self.showtraceback()
1726 self.showtraceback()
1720 if self.autoindent:
1727 if self.autoindent:
1721 self.rl_do_indent = True
1728 self.rl_do_indent = True
1722
1729
1723 else:
1730 else:
1724 try:
1731 try:
1725 prompt = self.hooks.generate_prompt(False)
1732 prompt = self.hooks.generate_prompt(False)
1726 except:
1733 except:
1727 self.showtraceback()
1734 self.showtraceback()
1728 self.write(prompt)
1735 self.write(prompt)
1729
1736
1730 def interact_handle_input(self,line):
1737 def interact_handle_input(self,line):
1731 """ Handle the input line (in read-eval-print loop)
1738 """ Handle the input line (in read-eval-print loop)
1732
1739
1733 Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not
1740 Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not
1734 used in standard IPython flow.
1741 used in standard IPython flow.
1735 """
1742 """
1736 if line.lstrip() == line:
1743 if line.lstrip() == line:
1737 self.shadowhist.add(line.strip())
1744 self.shadowhist.add(line.strip())
1738 lineout = self.prefilter_manager.prefilter_lines(line,self.more)
1745 lineout = self.prefilter_manager.prefilter_lines(line,self.more)
1739
1746
1740 if line.strip():
1747 if line.strip():
1741 if self.more:
1748 if self.more:
1742 self.input_hist_raw[-1] += '%s\n' % line
1749 self.input_hist_raw[-1] += '%s\n' % line
1743 else:
1750 else:
1744 self.input_hist_raw.append('%s\n' % line)
1751 self.input_hist_raw.append('%s\n' % line)
1745
1752
1746
1753
1747 self.more = self.push_line(lineout)
1754 self.more = self.push_line(lineout)
1748 if (self.SyntaxTB.last_syntax_error and
1755 if (self.SyntaxTB.last_syntax_error and
1749 self.autoedit_syntax):
1756 self.autoedit_syntax):
1750 self.edit_syntax_error()
1757 self.edit_syntax_error()
1751
1758
1752 def interact_with_readline(self):
1759 def interact_with_readline(self):
1753 """ Demo of using interact_handle_input, interact_prompt
1760 """ Demo of using interact_handle_input, interact_prompt
1754
1761
1755 This is the main read-eval-print loop. If you need to implement your own (e.g. for GUI),
1762 This is the main read-eval-print loop. If you need to implement your own (e.g. for GUI),
1756 it should work like this.
1763 it should work like this.
1757 """
1764 """
1758 self.readline_startup_hook(self.pre_readline)
1765 self.readline_startup_hook(self.pre_readline)
1759 while not self.exit_now:
1766 while not self.exit_now:
1760 self.interact_prompt()
1767 self.interact_prompt()
1761 if self.more:
1768 if self.more:
1762 self.rl_do_indent = True
1769 self.rl_do_indent = True
1763 else:
1770 else:
1764 self.rl_do_indent = False
1771 self.rl_do_indent = False
1765 line = raw_input_original().decode(self.stdin_encoding)
1772 line = raw_input_original().decode(self.stdin_encoding)
1766 self.interact_handle_input(line)
1773 self.interact_handle_input(line)
1767
1774
1768 def interact(self, display_banner=None):
1775 def interact(self, display_banner=None):
1769 """Closely emulate the interactive Python console."""
1776 """Closely emulate the interactive Python console."""
1770
1777
1771 # batch run -> do not interact
1778 # batch run -> do not interact
1772 if self.exit_now:
1779 if self.exit_now:
1773 return
1780 return
1774
1781
1775 if display_banner is None:
1782 if display_banner is None:
1776 display_banner = self.display_banner
1783 display_banner = self.display_banner
1777 if display_banner:
1784 if display_banner:
1778 self.show_banner()
1785 self.show_banner()
1779
1786
1780 more = 0
1787 more = 0
1781
1788
1782 # Mark activity in the builtins
1789 # Mark activity in the builtins
1783 __builtin__.__dict__['__IPYTHON__active'] += 1
1790 __builtin__.__dict__['__IPYTHON__active'] += 1
1784
1791
1785 if self.has_readline:
1792 if self.has_readline:
1786 self.readline_startup_hook(self.pre_readline)
1793 self.readline_startup_hook(self.pre_readline)
1787 # exit_now is set by a call to %Exit or %Quit, through the
1794 # exit_now is set by a call to %Exit or %Quit, through the
1788 # ask_exit callback.
1795 # ask_exit callback.
1789
1796
1790 while not self.exit_now:
1797 while not self.exit_now:
1791 self.hooks.pre_prompt_hook()
1798 self.hooks.pre_prompt_hook()
1792 if more:
1799 if more:
1793 try:
1800 try:
1794 prompt = self.hooks.generate_prompt(True)
1801 prompt = self.hooks.generate_prompt(True)
1795 except:
1802 except:
1796 self.showtraceback()
1803 self.showtraceback()
1797 if self.autoindent:
1804 if self.autoindent:
1798 self.rl_do_indent = True
1805 self.rl_do_indent = True
1799
1806
1800 else:
1807 else:
1801 try:
1808 try:
1802 prompt = self.hooks.generate_prompt(False)
1809 prompt = self.hooks.generate_prompt(False)
1803 except:
1810 except:
1804 self.showtraceback()
1811 self.showtraceback()
1805 try:
1812 try:
1806 line = self.raw_input(prompt, more)
1813 line = self.raw_input(prompt, more)
1807 if self.exit_now:
1814 if self.exit_now:
1808 # quick exit on sys.std[in|out] close
1815 # quick exit on sys.std[in|out] close
1809 break
1816 break
1810 if self.autoindent:
1817 if self.autoindent:
1811 self.rl_do_indent = False
1818 self.rl_do_indent = False
1812
1819
1813 except KeyboardInterrupt:
1820 except KeyboardInterrupt:
1814 #double-guard against keyboardinterrupts during kbdint handling
1821 #double-guard against keyboardinterrupts during kbdint handling
1815 try:
1822 try:
1816 self.write('\nKeyboardInterrupt\n')
1823 self.write('\nKeyboardInterrupt\n')
1817 self.resetbuffer()
1824 self.resetbuffer()
1818 # keep cache in sync with the prompt counter:
1825 # keep cache in sync with the prompt counter:
1819 self.outputcache.prompt_count -= 1
1826 self.outputcache.prompt_count -= 1
1820
1827
1821 if self.autoindent:
1828 if self.autoindent:
1822 self.indent_current_nsp = 0
1829 self.indent_current_nsp = 0
1823 more = 0
1830 more = 0
1824 except KeyboardInterrupt:
1831 except KeyboardInterrupt:
1825 pass
1832 pass
1826 except EOFError:
1833 except EOFError:
1827 if self.autoindent:
1834 if self.autoindent:
1828 self.rl_do_indent = False
1835 self.rl_do_indent = False
1829 self.readline_startup_hook(None)
1836 self.readline_startup_hook(None)
1830 self.write('\n')
1837 self.write('\n')
1831 self.exit()
1838 self.exit()
1832 except bdb.BdbQuit:
1839 except bdb.BdbQuit:
1833 warn('The Python debugger has exited with a BdbQuit exception.\n'
1840 warn('The Python debugger has exited with a BdbQuit exception.\n'
1834 'Because of how pdb handles the stack, it is impossible\n'
1841 'Because of how pdb handles the stack, it is impossible\n'
1835 'for IPython to properly format this particular exception.\n'
1842 'for IPython to properly format this particular exception.\n'
1836 'IPython will resume normal operation.')
1843 'IPython will resume normal operation.')
1837 except:
1844 except:
1838 # exceptions here are VERY RARE, but they can be triggered
1845 # exceptions here are VERY RARE, but they can be triggered
1839 # asynchronously by signal handlers, for example.
1846 # asynchronously by signal handlers, for example.
1840 self.showtraceback()
1847 self.showtraceback()
1841 else:
1848 else:
1842 more = self.push_line(line)
1849 more = self.push_line(line)
1843 if (self.SyntaxTB.last_syntax_error and
1850 if (self.SyntaxTB.last_syntax_error and
1844 self.autoedit_syntax):
1851 self.autoedit_syntax):
1845 self.edit_syntax_error()
1852 self.edit_syntax_error()
1846
1853
1847 # We are off again...
1854 # We are off again...
1848 __builtin__.__dict__['__IPYTHON__active'] -= 1
1855 __builtin__.__dict__['__IPYTHON__active'] -= 1
1849
1856
1850 def safe_execfile(self, fname, *where, **kw):
1857 def safe_execfile(self, fname, *where, **kw):
1851 """A safe version of the builtin execfile().
1858 """A safe version of the builtin execfile().
1852
1859
1853 This version will never throw an exception, but instead print
1860 This version will never throw an exception, but instead print
1854 helpful error messages to the screen. This only works on pure
1861 helpful error messages to the screen. This only works on pure
1855 Python files with the .py extension.
1862 Python files with the .py extension.
1856
1863
1857 Parameters
1864 Parameters
1858 ----------
1865 ----------
1859 fname : string
1866 fname : string
1860 The name of the file to be executed.
1867 The name of the file to be executed.
1861 where : tuple
1868 where : tuple
1862 One or two namespaces, passed to execfile() as (globals,locals).
1869 One or two namespaces, passed to execfile() as (globals,locals).
1863 If only one is given, it is passed as both.
1870 If only one is given, it is passed as both.
1864 exit_ignore : bool (False)
1871 exit_ignore : bool (False)
1865 If True, then don't print errors for non-zero exit statuses.
1872 If True, then don't print errors for non-zero exit statuses.
1866 """
1873 """
1867 kw.setdefault('exit_ignore', False)
1874 kw.setdefault('exit_ignore', False)
1868
1875
1869 fname = os.path.abspath(os.path.expanduser(fname))
1876 fname = os.path.abspath(os.path.expanduser(fname))
1870
1877
1871 # Make sure we have a .py file
1878 # Make sure we have a .py file
1872 if not fname.endswith('.py'):
1879 if not fname.endswith('.py'):
1873 warn('File must end with .py to be run using execfile: <%s>' % fname)
1880 warn('File must end with .py to be run using execfile: <%s>' % fname)
1874
1881
1875 # Make sure we can open the file
1882 # Make sure we can open the file
1876 try:
1883 try:
1877 with open(fname) as thefile:
1884 with open(fname) as thefile:
1878 pass
1885 pass
1879 except:
1886 except:
1880 warn('Could not open file <%s> for safe execution.' % fname)
1887 warn('Could not open file <%s> for safe execution.' % fname)
1881 return
1888 return
1882
1889
1883 # Find things also in current directory. This is needed to mimic the
1890 # Find things also in current directory. This is needed to mimic the
1884 # behavior of running a script from the system command line, where
1891 # behavior of running a script from the system command line, where
1885 # Python inserts the script's directory into sys.path
1892 # Python inserts the script's directory into sys.path
1886 dname = os.path.dirname(fname)
1893 dname = os.path.dirname(fname)
1887
1894
1888 with prepended_to_syspath(dname):
1895 with prepended_to_syspath(dname):
1889 try:
1896 try:
1890 if sys.platform == 'win32' and sys.version_info < (2,5,1):
1897 if sys.platform == 'win32' and sys.version_info < (2,5,1):
1891 # Work around a bug in Python for Windows. The bug was
1898 # Work around a bug in Python for Windows. The bug was
1892 # fixed in in Python 2.5 r54159 and 54158, but that's still
1899 # fixed in in Python 2.5 r54159 and 54158, but that's still
1893 # SVN Python as of March/07. For details, see:
1900 # SVN Python as of March/07. For details, see:
1894 # http://projects.scipy.org/ipython/ipython/ticket/123
1901 # http://projects.scipy.org/ipython/ipython/ticket/123
1895 try:
1902 try:
1896 globs,locs = where[0:2]
1903 globs,locs = where[0:2]
1897 except:
1904 except:
1898 try:
1905 try:
1899 globs = locs = where[0]
1906 globs = locs = where[0]
1900 except:
1907 except:
1901 globs = locs = globals()
1908 globs = locs = globals()
1902 exec file(fname) in globs,locs
1909 exec file(fname) in globs,locs
1903 else:
1910 else:
1904 execfile(fname,*where)
1911 execfile(fname,*where)
1905 except SyntaxError:
1912 except SyntaxError:
1906 self.showsyntaxerror()
1913 self.showsyntaxerror()
1907 warn('Failure executing file: <%s>' % fname)
1914 warn('Failure executing file: <%s>' % fname)
1908 except SystemExit, status:
1915 except SystemExit, status:
1909 # Code that correctly sets the exit status flag to success (0)
1916 # Code that correctly sets the exit status flag to success (0)
1910 # shouldn't be bothered with a traceback. Note that a plain
1917 # shouldn't be bothered with a traceback. Note that a plain
1911 # sys.exit() does NOT set the message to 0 (it's empty) so that
1918 # sys.exit() does NOT set the message to 0 (it's empty) so that
1912 # will still get a traceback. Note that the structure of the
1919 # will still get a traceback. Note that the structure of the
1913 # SystemExit exception changed between Python 2.4 and 2.5, so
1920 # SystemExit exception changed between Python 2.4 and 2.5, so
1914 # the checks must be done in a version-dependent way.
1921 # the checks must be done in a version-dependent way.
1915 show = False
1922 show = False
1916 if status.message!=0 and not kw['exit_ignore']:
1923 if status.message!=0 and not kw['exit_ignore']:
1917 show = True
1924 show = True
1918 if show:
1925 if show:
1919 self.showtraceback()
1926 self.showtraceback()
1920 warn('Failure executing file: <%s>' % fname)
1927 warn('Failure executing file: <%s>' % fname)
1921 except:
1928 except:
1922 self.showtraceback()
1929 self.showtraceback()
1923 warn('Failure executing file: <%s>' % fname)
1930 warn('Failure executing file: <%s>' % fname)
1924
1931
1925 def safe_execfile_ipy(self, fname):
1932 def safe_execfile_ipy(self, fname):
1926 """Like safe_execfile, but for .ipy files with IPython syntax.
1933 """Like safe_execfile, but for .ipy files with IPython syntax.
1927
1934
1928 Parameters
1935 Parameters
1929 ----------
1936 ----------
1930 fname : str
1937 fname : str
1931 The name of the file to execute. The filename must have a
1938 The name of the file to execute. The filename must have a
1932 .ipy extension.
1939 .ipy extension.
1933 """
1940 """
1934 fname = os.path.abspath(os.path.expanduser(fname))
1941 fname = os.path.abspath(os.path.expanduser(fname))
1935
1942
1936 # Make sure we have a .py file
1943 # Make sure we have a .py file
1937 if not fname.endswith('.ipy'):
1944 if not fname.endswith('.ipy'):
1938 warn('File must end with .py to be run using execfile: <%s>' % fname)
1945 warn('File must end with .py to be run using execfile: <%s>' % fname)
1939
1946
1940 # Make sure we can open the file
1947 # Make sure we can open the file
1941 try:
1948 try:
1942 with open(fname) as thefile:
1949 with open(fname) as thefile:
1943 pass
1950 pass
1944 except:
1951 except:
1945 warn('Could not open file <%s> for safe execution.' % fname)
1952 warn('Could not open file <%s> for safe execution.' % fname)
1946 return
1953 return
1947
1954
1948 # Find things also in current directory. This is needed to mimic the
1955 # Find things also in current directory. This is needed to mimic the
1949 # behavior of running a script from the system command line, where
1956 # behavior of running a script from the system command line, where
1950 # Python inserts the script's directory into sys.path
1957 # Python inserts the script's directory into sys.path
1951 dname = os.path.dirname(fname)
1958 dname = os.path.dirname(fname)
1952
1959
1953 with prepended_to_syspath(dname):
1960 with prepended_to_syspath(dname):
1954 try:
1961 try:
1955 with open(fname) as thefile:
1962 with open(fname) as thefile:
1956 script = thefile.read()
1963 script = thefile.read()
1957 # self.runlines currently captures all exceptions
1964 # self.runlines currently captures all exceptions
1958 # raise in user code. It would be nice if there were
1965 # raise in user code. It would be nice if there were
1959 # versions of runlines, execfile that did raise, so
1966 # versions of runlines, execfile that did raise, so
1960 # we could catch the errors.
1967 # we could catch the errors.
1961 self.runlines(script, clean=True)
1968 self.runlines(script, clean=True)
1962 except:
1969 except:
1963 self.showtraceback()
1970 self.showtraceback()
1964 warn('Unknown failure executing file: <%s>' % fname)
1971 warn('Unknown failure executing file: <%s>' % fname)
1965
1972
1966 def _is_secondary_block_start(self, s):
1973 def _is_secondary_block_start(self, s):
1967 if not s.endswith(':'):
1974 if not s.endswith(':'):
1968 return False
1975 return False
1969 if (s.startswith('elif') or
1976 if (s.startswith('elif') or
1970 s.startswith('else') or
1977 s.startswith('else') or
1971 s.startswith('except') or
1978 s.startswith('except') or
1972 s.startswith('finally')):
1979 s.startswith('finally')):
1973 return True
1980 return True
1974
1981
1975 def cleanup_ipy_script(self, script):
1982 def cleanup_ipy_script(self, script):
1976 """Make a script safe for self.runlines()
1983 """Make a script safe for self.runlines()
1977
1984
1978 Currently, IPython is lines based, with blocks being detected by
1985 Currently, IPython is lines based, with blocks being detected by
1979 empty lines. This is a problem for block based scripts that may
1986 empty lines. This is a problem for block based scripts that may
1980 not have empty lines after blocks. This script adds those empty
1987 not have empty lines after blocks. This script adds those empty
1981 lines to make scripts safe for running in the current line based
1988 lines to make scripts safe for running in the current line based
1982 IPython.
1989 IPython.
1983 """
1990 """
1984 res = []
1991 res = []
1985 lines = script.splitlines()
1992 lines = script.splitlines()
1986 level = 0
1993 level = 0
1987
1994
1988 for l in lines:
1995 for l in lines:
1989 lstripped = l.lstrip()
1996 lstripped = l.lstrip()
1990 stripped = l.strip()
1997 stripped = l.strip()
1991 if not stripped:
1998 if not stripped:
1992 continue
1999 continue
1993 newlevel = len(l) - len(lstripped)
2000 newlevel = len(l) - len(lstripped)
1994 if level > 0 and newlevel == 0 and \
2001 if level > 0 and newlevel == 0 and \
1995 not self._is_secondary_block_start(stripped):
2002 not self._is_secondary_block_start(stripped):
1996 # add empty line
2003 # add empty line
1997 res.append('')
2004 res.append('')
1998 res.append(l)
2005 res.append(l)
1999 level = newlevel
2006 level = newlevel
2000
2007
2001 return '\n'.join(res) + '\n'
2008 return '\n'.join(res) + '\n'
2002
2009
2003 def runlines(self, lines, clean=False):
2010 def runlines(self, lines, clean=False):
2004 """Run a string of one or more lines of source.
2011 """Run a string of one or more lines of source.
2005
2012
2006 This method is capable of running a string containing multiple source
2013 This method is capable of running a string containing multiple source
2007 lines, as if they had been entered at the IPython prompt. Since it
2014 lines, as if they had been entered at the IPython prompt. Since it
2008 exposes IPython's processing machinery, the given strings can contain
2015 exposes IPython's processing machinery, the given strings can contain
2009 magic calls (%magic), special shell access (!cmd), etc.
2016 magic calls (%magic), special shell access (!cmd), etc.
2010 """
2017 """
2011
2018
2012 if isinstance(lines, (list, tuple)):
2019 if isinstance(lines, (list, tuple)):
2013 lines = '\n'.join(lines)
2020 lines = '\n'.join(lines)
2014
2021
2015 if clean:
2022 if clean:
2016 lines = self.cleanup_ipy_script(lines)
2023 lines = self.cleanup_ipy_script(lines)
2017
2024
2018 # We must start with a clean buffer, in case this is run from an
2025 # We must start with a clean buffer, in case this is run from an
2019 # interactive IPython session (via a magic, for example).
2026 # interactive IPython session (via a magic, for example).
2020 self.resetbuffer()
2027 self.resetbuffer()
2021 lines = lines.splitlines()
2028 lines = lines.splitlines()
2022 more = 0
2029 more = 0
2023
2030
2024 with nested(self.builtin_trap, self.display_trap):
2031 with nested(self.builtin_trap, self.display_trap):
2025 for line in lines:
2032 for line in lines:
2026 # skip blank lines so we don't mess up the prompt counter, but do
2033 # skip blank lines so we don't mess up the prompt counter, but do
2027 # NOT skip even a blank line if we are in a code block (more is
2034 # NOT skip even a blank line if we are in a code block (more is
2028 # true)
2035 # true)
2029
2036
2030 if line or more:
2037 if line or more:
2031 # push to raw history, so hist line numbers stay in sync
2038 # push to raw history, so hist line numbers stay in sync
2032 self.input_hist_raw.append("# " + line + "\n")
2039 self.input_hist_raw.append("# " + line + "\n")
2033 prefiltered = self.prefilter_manager.prefilter_lines(line,more)
2040 prefiltered = self.prefilter_manager.prefilter_lines(line,more)
2034 more = self.push_line(prefiltered)
2041 more = self.push_line(prefiltered)
2035 # IPython's runsource returns None if there was an error
2042 # IPython's runsource returns None if there was an error
2036 # compiling the code. This allows us to stop processing right
2043 # compiling the code. This allows us to stop processing right
2037 # away, so the user gets the error message at the right place.
2044 # away, so the user gets the error message at the right place.
2038 if more is None:
2045 if more is None:
2039 break
2046 break
2040 else:
2047 else:
2041 self.input_hist_raw.append("\n")
2048 self.input_hist_raw.append("\n")
2042 # final newline in case the input didn't have it, so that the code
2049 # final newline in case the input didn't have it, so that the code
2043 # actually does get executed
2050 # actually does get executed
2044 if more:
2051 if more:
2045 self.push_line('\n')
2052 self.push_line('\n')
2046
2053
2047 def runsource(self, source, filename='<input>', symbol='single'):
2054 def runsource(self, source, filename='<input>', symbol='single'):
2048 """Compile and run some source in the interpreter.
2055 """Compile and run some source in the interpreter.
2049
2056
2050 Arguments are as for compile_command().
2057 Arguments are as for compile_command().
2051
2058
2052 One several things can happen:
2059 One several things can happen:
2053
2060
2054 1) The input is incorrect; compile_command() raised an
2061 1) The input is incorrect; compile_command() raised an
2055 exception (SyntaxError or OverflowError). A syntax traceback
2062 exception (SyntaxError or OverflowError). A syntax traceback
2056 will be printed by calling the showsyntaxerror() method.
2063 will be printed by calling the showsyntaxerror() method.
2057
2064
2058 2) The input is incomplete, and more input is required;
2065 2) The input is incomplete, and more input is required;
2059 compile_command() returned None. Nothing happens.
2066 compile_command() returned None. Nothing happens.
2060
2067
2061 3) The input is complete; compile_command() returned a code
2068 3) The input is complete; compile_command() returned a code
2062 object. The code is executed by calling self.runcode() (which
2069 object. The code is executed by calling self.runcode() (which
2063 also handles run-time exceptions, except for SystemExit).
2070 also handles run-time exceptions, except for SystemExit).
2064
2071
2065 The return value is:
2072 The return value is:
2066
2073
2067 - True in case 2
2074 - True in case 2
2068
2075
2069 - False in the other cases, unless an exception is raised, where
2076 - False in the other cases, unless an exception is raised, where
2070 None is returned instead. This can be used by external callers to
2077 None is returned instead. This can be used by external callers to
2071 know whether to continue feeding input or not.
2078 know whether to continue feeding input or not.
2072
2079
2073 The return value can be used to decide whether to use sys.ps1 or
2080 The return value can be used to decide whether to use sys.ps1 or
2074 sys.ps2 to prompt the next line."""
2081 sys.ps2 to prompt the next line."""
2075
2082
2076 # if the source code has leading blanks, add 'if 1:\n' to it
2083 # if the source code has leading blanks, add 'if 1:\n' to it
2077 # this allows execution of indented pasted code. It is tempting
2084 # this allows execution of indented pasted code. It is tempting
2078 # to add '\n' at the end of source to run commands like ' a=1'
2085 # to add '\n' at the end of source to run commands like ' a=1'
2079 # directly, but this fails for more complicated scenarios
2086 # directly, but this fails for more complicated scenarios
2080 source=source.encode(self.stdin_encoding)
2087 source=source.encode(self.stdin_encoding)
2081 if source[:1] in [' ', '\t']:
2088 if source[:1] in [' ', '\t']:
2082 source = 'if 1:\n%s' % source
2089 source = 'if 1:\n%s' % source
2083
2090
2084 try:
2091 try:
2085 code = self.compile(source,filename,symbol)
2092 code = self.compile(source,filename,symbol)
2086 except (OverflowError, SyntaxError, ValueError, TypeError, MemoryError):
2093 except (OverflowError, SyntaxError, ValueError, TypeError, MemoryError):
2087 # Case 1
2094 # Case 1
2088 self.showsyntaxerror(filename)
2095 self.showsyntaxerror(filename)
2089 return None
2096 return None
2090
2097
2091 if code is None:
2098 if code is None:
2092 # Case 2
2099 # Case 2
2093 return True
2100 return True
2094
2101
2095 # Case 3
2102 # Case 3
2096 # We store the code object so that threaded shells and
2103 # We store the code object so that threaded shells and
2097 # custom exception handlers can access all this info if needed.
2104 # custom exception handlers can access all this info if needed.
2098 # The source corresponding to this can be obtained from the
2105 # The source corresponding to this can be obtained from the
2099 # buffer attribute as '\n'.join(self.buffer).
2106 # buffer attribute as '\n'.join(self.buffer).
2100 self.code_to_run = code
2107 self.code_to_run = code
2101 # now actually execute the code object
2108 # now actually execute the code object
2102 if self.runcode(code) == 0:
2109 if self.runcode(code) == 0:
2103 return False
2110 return False
2104 else:
2111 else:
2105 return None
2112 return None
2106
2113
2107 def runcode(self,code_obj):
2114 def runcode(self,code_obj):
2108 """Execute a code object.
2115 """Execute a code object.
2109
2116
2110 When an exception occurs, self.showtraceback() is called to display a
2117 When an exception occurs, self.showtraceback() is called to display a
2111 traceback.
2118 traceback.
2112
2119
2113 Return value: a flag indicating whether the code to be run completed
2120 Return value: a flag indicating whether the code to be run completed
2114 successfully:
2121 successfully:
2115
2122
2116 - 0: successful execution.
2123 - 0: successful execution.
2117 - 1: an error occurred.
2124 - 1: an error occurred.
2118 """
2125 """
2119
2126
2120 # Set our own excepthook in case the user code tries to call it
2127 # Set our own excepthook in case the user code tries to call it
2121 # directly, so that the IPython crash handler doesn't get triggered
2128 # directly, so that the IPython crash handler doesn't get triggered
2122 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2129 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2123
2130
2124 # we save the original sys.excepthook in the instance, in case config
2131 # we save the original sys.excepthook in the instance, in case config
2125 # code (such as magics) needs access to it.
2132 # code (such as magics) needs access to it.
2126 self.sys_excepthook = old_excepthook
2133 self.sys_excepthook = old_excepthook
2127 outflag = 1 # happens in more places, so it's easier as default
2134 outflag = 1 # happens in more places, so it's easier as default
2128 try:
2135 try:
2129 try:
2136 try:
2130 self.hooks.pre_runcode_hook()
2137 self.hooks.pre_runcode_hook()
2131 exec code_obj in self.user_global_ns, self.user_ns
2138 exec code_obj in self.user_global_ns, self.user_ns
2132 finally:
2139 finally:
2133 # Reset our crash handler in place
2140 # Reset our crash handler in place
2134 sys.excepthook = old_excepthook
2141 sys.excepthook = old_excepthook
2135 except SystemExit:
2142 except SystemExit:
2136 self.resetbuffer()
2143 self.resetbuffer()
2137 self.showtraceback()
2144 self.showtraceback()
2138 warn("Type %exit or %quit to exit IPython "
2145 warn("Type %exit or %quit to exit IPython "
2139 "(%Exit or %Quit do so unconditionally).",level=1)
2146 "(%Exit or %Quit do so unconditionally).",level=1)
2140 except self.custom_exceptions:
2147 except self.custom_exceptions:
2141 etype,value,tb = sys.exc_info()
2148 etype,value,tb = sys.exc_info()
2142 self.CustomTB(etype,value,tb)
2149 self.CustomTB(etype,value,tb)
2143 except:
2150 except:
2144 self.showtraceback()
2151 self.showtraceback()
2145 else:
2152 else:
2146 outflag = 0
2153 outflag = 0
2147 if softspace(sys.stdout, 0):
2154 if softspace(sys.stdout, 0):
2148 print
2155 print
2149 # Flush out code object which has been run (and source)
2156 # Flush out code object which has been run (and source)
2150 self.code_to_run = None
2157 self.code_to_run = None
2151 return outflag
2158 return outflag
2152
2159
2153 def push_line(self, line):
2160 def push_line(self, line):
2154 """Push a line to the interpreter.
2161 """Push a line to the interpreter.
2155
2162
2156 The line should not have a trailing newline; it may have
2163 The line should not have a trailing newline; it may have
2157 internal newlines. The line is appended to a buffer and the
2164 internal newlines. The line is appended to a buffer and the
2158 interpreter's runsource() method is called with the
2165 interpreter's runsource() method is called with the
2159 concatenated contents of the buffer as source. If this
2166 concatenated contents of the buffer as source. If this
2160 indicates that the command was executed or invalid, the buffer
2167 indicates that the command was executed or invalid, the buffer
2161 is reset; otherwise, the command is incomplete, and the buffer
2168 is reset; otherwise, the command is incomplete, and the buffer
2162 is left as it was after the line was appended. The return
2169 is left as it was after the line was appended. The return
2163 value is 1 if more input is required, 0 if the line was dealt
2170 value is 1 if more input is required, 0 if the line was dealt
2164 with in some way (this is the same as runsource()).
2171 with in some way (this is the same as runsource()).
2165 """
2172 """
2166
2173
2167 # autoindent management should be done here, and not in the
2174 # autoindent management should be done here, and not in the
2168 # interactive loop, since that one is only seen by keyboard input. We
2175 # interactive loop, since that one is only seen by keyboard input. We
2169 # need this done correctly even for code run via runlines (which uses
2176 # need this done correctly even for code run via runlines (which uses
2170 # push).
2177 # push).
2171
2178
2172 #print 'push line: <%s>' % line # dbg
2179 #print 'push line: <%s>' % line # dbg
2173 for subline in line.splitlines():
2180 for subline in line.splitlines():
2174 self._autoindent_update(subline)
2181 self._autoindent_update(subline)
2175 self.buffer.append(line)
2182 self.buffer.append(line)
2176 more = self.runsource('\n'.join(self.buffer), self.filename)
2183 more = self.runsource('\n'.join(self.buffer), self.filename)
2177 if not more:
2184 if not more:
2178 self.resetbuffer()
2185 self.resetbuffer()
2179 return more
2186 return more
2180
2187
2181 def _autoindent_update(self,line):
2188 def _autoindent_update(self,line):
2182 """Keep track of the indent level."""
2189 """Keep track of the indent level."""
2183
2190
2184 #debugx('line')
2191 #debugx('line')
2185 #debugx('self.indent_current_nsp')
2192 #debugx('self.indent_current_nsp')
2186 if self.autoindent:
2193 if self.autoindent:
2187 if line:
2194 if line:
2188 inisp = num_ini_spaces(line)
2195 inisp = num_ini_spaces(line)
2189 if inisp < self.indent_current_nsp:
2196 if inisp < self.indent_current_nsp:
2190 self.indent_current_nsp = inisp
2197 self.indent_current_nsp = inisp
2191
2198
2192 if line[-1] == ':':
2199 if line[-1] == ':':
2193 self.indent_current_nsp += 4
2200 self.indent_current_nsp += 4
2194 elif dedent_re.match(line):
2201 elif dedent_re.match(line):
2195 self.indent_current_nsp -= 4
2202 self.indent_current_nsp -= 4
2196 else:
2203 else:
2197 self.indent_current_nsp = 0
2204 self.indent_current_nsp = 0
2198
2205
2199 def resetbuffer(self):
2206 def resetbuffer(self):
2200 """Reset the input buffer."""
2207 """Reset the input buffer."""
2201 self.buffer[:] = []
2208 self.buffer[:] = []
2202
2209
2203 def raw_input(self,prompt='',continue_prompt=False):
2210 def raw_input(self,prompt='',continue_prompt=False):
2204 """Write a prompt and read a line.
2211 """Write a prompt and read a line.
2205
2212
2206 The returned line does not include the trailing newline.
2213 The returned line does not include the trailing newline.
2207 When the user enters the EOF key sequence, EOFError is raised.
2214 When the user enters the EOF key sequence, EOFError is raised.
2208
2215
2209 Optional inputs:
2216 Optional inputs:
2210
2217
2211 - prompt(''): a string to be printed to prompt the user.
2218 - prompt(''): a string to be printed to prompt the user.
2212
2219
2213 - continue_prompt(False): whether this line is the first one or a
2220 - continue_prompt(False): whether this line is the first one or a
2214 continuation in a sequence of inputs.
2221 continuation in a sequence of inputs.
2215 """
2222 """
2216 # growl.notify("raw_input: ", "prompt = %r\ncontinue_prompt = %s" % (prompt, continue_prompt))
2223 # growl.notify("raw_input: ", "prompt = %r\ncontinue_prompt = %s" % (prompt, continue_prompt))
2217
2224
2218 # Code run by the user may have modified the readline completer state.
2225 # Code run by the user may have modified the readline completer state.
2219 # We must ensure that our completer is back in place.
2226 # We must ensure that our completer is back in place.
2220
2227
2221 if self.has_readline:
2228 if self.has_readline:
2222 self.set_completer()
2229 self.set_completer()
2223
2230
2224 try:
2231 try:
2225 line = raw_input_original(prompt).decode(self.stdin_encoding)
2232 line = raw_input_original(prompt).decode(self.stdin_encoding)
2226 except ValueError:
2233 except ValueError:
2227 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
2234 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
2228 " or sys.stdout.close()!\nExiting IPython!")
2235 " or sys.stdout.close()!\nExiting IPython!")
2229 self.ask_exit()
2236 self.ask_exit()
2230 return ""
2237 return ""
2231
2238
2232 # Try to be reasonably smart about not re-indenting pasted input more
2239 # Try to be reasonably smart about not re-indenting pasted input more
2233 # than necessary. We do this by trimming out the auto-indent initial
2240 # than necessary. We do this by trimming out the auto-indent initial
2234 # spaces, if the user's actual input started itself with whitespace.
2241 # spaces, if the user's actual input started itself with whitespace.
2235 #debugx('self.buffer[-1]')
2242 #debugx('self.buffer[-1]')
2236
2243
2237 if self.autoindent:
2244 if self.autoindent:
2238 if num_ini_spaces(line) > self.indent_current_nsp:
2245 if num_ini_spaces(line) > self.indent_current_nsp:
2239 line = line[self.indent_current_nsp:]
2246 line = line[self.indent_current_nsp:]
2240 self.indent_current_nsp = 0
2247 self.indent_current_nsp = 0
2241
2248
2242 # store the unfiltered input before the user has any chance to modify
2249 # store the unfiltered input before the user has any chance to modify
2243 # it.
2250 # it.
2244 if line.strip():
2251 if line.strip():
2245 if continue_prompt:
2252 if continue_prompt:
2246 self.input_hist_raw[-1] += '%s\n' % line
2253 self.input_hist_raw[-1] += '%s\n' % line
2247 if self.has_readline and self.readline_use:
2254 if self.has_readline and self.readline_use:
2248 try:
2255 try:
2249 histlen = self.readline.get_current_history_length()
2256 histlen = self.readline.get_current_history_length()
2250 if histlen > 1:
2257 if histlen > 1:
2251 newhist = self.input_hist_raw[-1].rstrip()
2258 newhist = self.input_hist_raw[-1].rstrip()
2252 self.readline.remove_history_item(histlen-1)
2259 self.readline.remove_history_item(histlen-1)
2253 self.readline.replace_history_item(histlen-2,
2260 self.readline.replace_history_item(histlen-2,
2254 newhist.encode(self.stdin_encoding))
2261 newhist.encode(self.stdin_encoding))
2255 except AttributeError:
2262 except AttributeError:
2256 pass # re{move,place}_history_item are new in 2.4.
2263 pass # re{move,place}_history_item are new in 2.4.
2257 else:
2264 else:
2258 self.input_hist_raw.append('%s\n' % line)
2265 self.input_hist_raw.append('%s\n' % line)
2259 # only entries starting at first column go to shadow history
2266 # only entries starting at first column go to shadow history
2260 if line.lstrip() == line:
2267 if line.lstrip() == line:
2261 self.shadowhist.add(line.strip())
2268 self.shadowhist.add(line.strip())
2262 elif not continue_prompt:
2269 elif not continue_prompt:
2263 self.input_hist_raw.append('\n')
2270 self.input_hist_raw.append('\n')
2264 try:
2271 try:
2265 lineout = self.prefilter_manager.prefilter_lines(line,continue_prompt)
2272 lineout = self.prefilter_manager.prefilter_lines(line,continue_prompt)
2266 except:
2273 except:
2267 # blanket except, in case a user-defined prefilter crashes, so it
2274 # blanket except, in case a user-defined prefilter crashes, so it
2268 # can't take all of ipython with it.
2275 # can't take all of ipython with it.
2269 self.showtraceback()
2276 self.showtraceback()
2270 return ''
2277 return ''
2271 else:
2278 else:
2272 return lineout
2279 return lineout
2273
2280
2274 #-------------------------------------------------------------------------
2281 #-------------------------------------------------------------------------
2275 # Working with components
2282 # Working with components
2276 #-------------------------------------------------------------------------
2283 #-------------------------------------------------------------------------
2277
2284
2278 def get_component(self, name=None, klass=None):
2285 def get_component(self, name=None, klass=None):
2279 """Fetch a component by name and klass in my tree."""
2286 """Fetch a component by name and klass in my tree."""
2280 c = Component.get_instances(root=self, name=name, klass=klass)
2287 c = Component.get_instances(root=self, name=name, klass=klass)
2281 if len(c) == 1:
2288 if len(c) == 1:
2282 return c[0]
2289 return c[0]
2283 else:
2290 else:
2284 return c
2291 return c
2285
2292
2286 #-------------------------------------------------------------------------
2293 #-------------------------------------------------------------------------
2287 # IPython extensions
2294 # IPython extensions
2288 #-------------------------------------------------------------------------
2295 #-------------------------------------------------------------------------
2289
2296
2290 def load_extension(self, module_str):
2297 def load_extension(self, module_str):
2291 """Load an IPython extension by its module name.
2298 """Load an IPython extension by its module name.
2292
2299
2293 An IPython extension is an importable Python module that has
2300 An IPython extension is an importable Python module that has
2294 a function with the signature::
2301 a function with the signature::
2295
2302
2296 def load_ipython_extension(ipython):
2303 def load_ipython_extension(ipython):
2297 # Do things with ipython
2304 # Do things with ipython
2298
2305
2299 This function is called after your extension is imported and the
2306 This function is called after your extension is imported and the
2300 currently active :class:`InteractiveShell` instance is passed as
2307 currently active :class:`InteractiveShell` instance is passed as
2301 the only argument. You can do anything you want with IPython at
2308 the only argument. You can do anything you want with IPython at
2302 that point, including defining new magic and aliases, adding new
2309 that point, including defining new magic and aliases, adding new
2303 components, etc.
2310 components, etc.
2304
2311
2305 The :func:`load_ipython_extension` will be called again is you
2312 The :func:`load_ipython_extension` will be called again is you
2306 load or reload the extension again. It is up to the extension
2313 load or reload the extension again. It is up to the extension
2307 author to add code to manage that.
2314 author to add code to manage that.
2308
2315
2309 You can put your extension modules anywhere you want, as long as
2316 You can put your extension modules anywhere you want, as long as
2310 they can be imported by Python's standard import mechanism. However,
2317 they can be imported by Python's standard import mechanism. However,
2311 to make it easy to write extensions, you can also put your extensions
2318 to make it easy to write extensions, you can also put your extensions
2312 in ``os.path.join(self.ipythondir, 'extensions')``. This directory
2319 in ``os.path.join(self.ipythondir, 'extensions')``. This directory
2313 is added to ``sys.path`` automatically.
2320 is added to ``sys.path`` automatically.
2314 """
2321 """
2315 from IPython.utils.syspathcontext import prepended_to_syspath
2322 from IPython.utils.syspathcontext import prepended_to_syspath
2316
2323
2317 if module_str not in sys.modules:
2324 if module_str not in sys.modules:
2318 with prepended_to_syspath(self.ipython_extension_dir):
2325 with prepended_to_syspath(self.ipython_extension_dir):
2319 __import__(module_str)
2326 __import__(module_str)
2320 mod = sys.modules[module_str]
2327 mod = sys.modules[module_str]
2321 self._call_load_ipython_extension(mod)
2328 self._call_load_ipython_extension(mod)
2322
2329
2323 def unload_extension(self, module_str):
2330 def unload_extension(self, module_str):
2324 """Unload an IPython extension by its module name.
2331 """Unload an IPython extension by its module name.
2325
2332
2326 This function looks up the extension's name in ``sys.modules`` and
2333 This function looks up the extension's name in ``sys.modules`` and
2327 simply calls ``mod.unload_ipython_extension(self)``.
2334 simply calls ``mod.unload_ipython_extension(self)``.
2328 """
2335 """
2329 if module_str in sys.modules:
2336 if module_str in sys.modules:
2330 mod = sys.modules[module_str]
2337 mod = sys.modules[module_str]
2331 self._call_unload_ipython_extension(mod)
2338 self._call_unload_ipython_extension(mod)
2332
2339
2333 def reload_extension(self, module_str):
2340 def reload_extension(self, module_str):
2334 """Reload an IPython extension by calling reload.
2341 """Reload an IPython extension by calling reload.
2335
2342
2336 If the module has not been loaded before,
2343 If the module has not been loaded before,
2337 :meth:`InteractiveShell.load_extension` is called. Otherwise
2344 :meth:`InteractiveShell.load_extension` is called. Otherwise
2338 :func:`reload` is called and then the :func:`load_ipython_extension`
2345 :func:`reload` is called and then the :func:`load_ipython_extension`
2339 function of the module, if it exists is called.
2346 function of the module, if it exists is called.
2340 """
2347 """
2341 from IPython.utils.syspathcontext import prepended_to_syspath
2348 from IPython.utils.syspathcontext import prepended_to_syspath
2342
2349
2343 with prepended_to_syspath(self.ipython_extension_dir):
2350 with prepended_to_syspath(self.ipython_extension_dir):
2344 if module_str in sys.modules:
2351 if module_str in sys.modules:
2345 mod = sys.modules[module_str]
2352 mod = sys.modules[module_str]
2346 reload(mod)
2353 reload(mod)
2347 self._call_load_ipython_extension(mod)
2354 self._call_load_ipython_extension(mod)
2348 else:
2355 else:
2349 self.load_extension(module_str)
2356 self.load_extension(module_str)
2350
2357
2351 def _call_load_ipython_extension(self, mod):
2358 def _call_load_ipython_extension(self, mod):
2352 if hasattr(mod, 'load_ipython_extension'):
2359 if hasattr(mod, 'load_ipython_extension'):
2353 mod.load_ipython_extension(self)
2360 mod.load_ipython_extension(self)
2354
2361
2355 def _call_unload_ipython_extension(self, mod):
2362 def _call_unload_ipython_extension(self, mod):
2356 if hasattr(mod, 'unload_ipython_extension'):
2363 if hasattr(mod, 'unload_ipython_extension'):
2357 mod.unload_ipython_extension(self)
2364 mod.unload_ipython_extension(self)
2358
2365
2359 #-------------------------------------------------------------------------
2366 #-------------------------------------------------------------------------
2360 # Things related to the prefilter
2367 # Things related to the prefilter
2361 #-------------------------------------------------------------------------
2368 #-------------------------------------------------------------------------
2362
2369
2363 def init_prefilter(self):
2370 def init_prefilter(self):
2364 self.prefilter_manager = PrefilterManager(self, config=self.config)
2371 self.prefilter_manager = PrefilterManager(self, config=self.config)
2365
2372
2366 #-------------------------------------------------------------------------
2373 #-------------------------------------------------------------------------
2367 # Utilities
2374 # Utilities
2368 #-------------------------------------------------------------------------
2375 #-------------------------------------------------------------------------
2369
2376
2370 def getoutput(self, cmd):
2377 def getoutput(self, cmd):
2371 return getoutput(self.var_expand(cmd,depth=2),
2378 return getoutput(self.var_expand(cmd,depth=2),
2372 header=self.system_header,
2379 header=self.system_header,
2373 verbose=self.system_verbose)
2380 verbose=self.system_verbose)
2374
2381
2375 def getoutputerror(self, cmd):
2382 def getoutputerror(self, cmd):
2376 return getoutputerror(self.var_expand(cmd,depth=2),
2383 return getoutputerror(self.var_expand(cmd,depth=2),
2377 header=self.system_header,
2384 header=self.system_header,
2378 verbose=self.system_verbose)
2385 verbose=self.system_verbose)
2379
2386
2380 def var_expand(self,cmd,depth=0):
2387 def var_expand(self,cmd,depth=0):
2381 """Expand python variables in a string.
2388 """Expand python variables in a string.
2382
2389
2383 The depth argument indicates how many frames above the caller should
2390 The depth argument indicates how many frames above the caller should
2384 be walked to look for the local namespace where to expand variables.
2391 be walked to look for the local namespace where to expand variables.
2385
2392
2386 The global namespace for expansion is always the user's interactive
2393 The global namespace for expansion is always the user's interactive
2387 namespace.
2394 namespace.
2388 """
2395 """
2389
2396
2390 return str(ItplNS(cmd,
2397 return str(ItplNS(cmd,
2391 self.user_ns, # globals
2398 self.user_ns, # globals
2392 # Skip our own frame in searching for locals:
2399 # Skip our own frame in searching for locals:
2393 sys._getframe(depth+1).f_locals # locals
2400 sys._getframe(depth+1).f_locals # locals
2394 ))
2401 ))
2395
2402
2396 def mktempfile(self,data=None):
2403 def mktempfile(self,data=None):
2397 """Make a new tempfile and return its filename.
2404 """Make a new tempfile and return its filename.
2398
2405
2399 This makes a call to tempfile.mktemp, but it registers the created
2406 This makes a call to tempfile.mktemp, but it registers the created
2400 filename internally so ipython cleans it up at exit time.
2407 filename internally so ipython cleans it up at exit time.
2401
2408
2402 Optional inputs:
2409 Optional inputs:
2403
2410
2404 - data(None): if data is given, it gets written out to the temp file
2411 - data(None): if data is given, it gets written out to the temp file
2405 immediately, and the file is closed again."""
2412 immediately, and the file is closed again."""
2406
2413
2407 filename = tempfile.mktemp('.py','ipython_edit_')
2414 filename = tempfile.mktemp('.py','ipython_edit_')
2408 self.tempfiles.append(filename)
2415 self.tempfiles.append(filename)
2409
2416
2410 if data:
2417 if data:
2411 tmp_file = open(filename,'w')
2418 tmp_file = open(filename,'w')
2412 tmp_file.write(data)
2419 tmp_file.write(data)
2413 tmp_file.close()
2420 tmp_file.close()
2414 return filename
2421 return filename
2415
2422
2416 def write(self,data):
2423 def write(self,data):
2417 """Write a string to the default output"""
2424 """Write a string to the default output"""
2418 Term.cout.write(data)
2425 Term.cout.write(data)
2419
2426
2420 def write_err(self,data):
2427 def write_err(self,data):
2421 """Write a string to the default error output"""
2428 """Write a string to the default error output"""
2422 Term.cerr.write(data)
2429 Term.cerr.write(data)
2423
2430
2424 def ask_yes_no(self,prompt,default=True):
2431 def ask_yes_no(self,prompt,default=True):
2425 if self.quiet:
2432 if self.quiet:
2426 return True
2433 return True
2427 return ask_yes_no(prompt,default)
2434 return ask_yes_no(prompt,default)
2428
2435
2429 #-------------------------------------------------------------------------
2436 #-------------------------------------------------------------------------
2430 # Things related to IPython exiting
2437 # Things related to IPython exiting
2431 #-------------------------------------------------------------------------
2438 #-------------------------------------------------------------------------
2432
2439
2433 def ask_exit(self):
2440 def ask_exit(self):
2434 """ Call for exiting. Can be overiden and used as a callback. """
2441 """ Call for exiting. Can be overiden and used as a callback. """
2435 self.exit_now = True
2442 self.exit_now = True
2436
2443
2437 def exit(self):
2444 def exit(self):
2438 """Handle interactive exit.
2445 """Handle interactive exit.
2439
2446
2440 This method calls the ask_exit callback."""
2447 This method calls the ask_exit callback."""
2441 if self.confirm_exit:
2448 if self.confirm_exit:
2442 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
2449 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
2443 self.ask_exit()
2450 self.ask_exit()
2444 else:
2451 else:
2445 self.ask_exit()
2452 self.ask_exit()
2446
2453
2447 def atexit_operations(self):
2454 def atexit_operations(self):
2448 """This will be executed at the time of exit.
2455 """This will be executed at the time of exit.
2449
2456
2450 Saving of persistent data should be performed here.
2457 Saving of persistent data should be performed here.
2451 """
2458 """
2452 self.savehist()
2459 self.savehist()
2453
2460
2454 # Cleanup all tempfiles left around
2461 # Cleanup all tempfiles left around
2455 for tfile in self.tempfiles:
2462 for tfile in self.tempfiles:
2456 try:
2463 try:
2457 os.unlink(tfile)
2464 os.unlink(tfile)
2458 except OSError:
2465 except OSError:
2459 pass
2466 pass
2460
2467
2461 # Clear all user namespaces to release all references cleanly.
2468 # Clear all user namespaces to release all references cleanly.
2462 self.reset()
2469 self.reset()
2463
2470
2464 # Run user hooks
2471 # Run user hooks
2465 self.hooks.shutdown_hook()
2472 self.hooks.shutdown_hook()
2466
2473
2467 def cleanup(self):
2474 def cleanup(self):
2468 self.restore_sys_module_state()
2475 self.restore_sys_module_state()
2469
2476
2470
2477
General Comments 0
You need to be logged in to leave comments. Login now