##// END OF EJS Templates
Fix tab-completion bug in threaded shells.x
fperez -
Show More

The requested changes are too big and content was truncated. Show full diff

@@ -1,900 +1,913 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """IPython Shell classes.
2 """IPython Shell classes.
3
3
4 All the matplotlib support code was co-developed with John Hunter,
4 All the matplotlib support code was co-developed with John Hunter,
5 matplotlib's author.
5 matplotlib's author.
6
6
7 $Id: Shell.py 958 2005-12-27 23:17:51Z fperez $"""
7 $Id: Shell.py 964 2005-12-28 21:03:01Z fperez $"""
8
8
9 #*****************************************************************************
9 #*****************************************************************************
10 # Copyright (C) 2001-2004 Fernando Perez <fperez@colorado.edu>
10 # Copyright (C) 2001-2004 Fernando Perez <fperez@colorado.edu>
11 #
11 #
12 # Distributed under the terms of the BSD License. The full license is in
12 # Distributed under the terms of the BSD License. The full license is in
13 # the file COPYING, distributed as part of this software.
13 # the file COPYING, distributed as part of this software.
14 #*****************************************************************************
14 #*****************************************************************************
15
15
16 from IPython import Release
16 from IPython import Release
17 __author__ = '%s <%s>' % Release.authors['Fernando']
17 __author__ = '%s <%s>' % Release.authors['Fernando']
18 __license__ = Release.license
18 __license__ = Release.license
19
19
20 # Code begins
20 # Code begins
21 import __main__
21 import __main__
22 import __builtin__
22 import __builtin__
23 import os
23 import os
24 import sys
24 import sys
25 import signal
25 import signal
26 import threading
26 import threading
27
27
28 import IPython
28 import IPython
29 from IPython import ultraTB
29 from IPython import ultraTB
30 from IPython.genutils import Term,warn,error,flag_calls
30 from IPython.genutils import Term,warn,error,flag_calls
31 from IPython.iplib import InteractiveShell
31 from IPython.iplib import InteractiveShell
32 from IPython.ipmaker import make_IPython
32 from IPython.ipmaker import make_IPython
33 from IPython.Magic import Magic
33 from IPython.Magic import Magic
34 from IPython.Struct import Struct
34 from IPython.Struct import Struct
35
35
36 # global flag to pass around information about Ctrl-C without exceptions
36 # global flag to pass around information about Ctrl-C without exceptions
37 KBINT = False
37 KBINT = False
38
38
39 # global flag to turn on/off Tk support.
39 # global flag to turn on/off Tk support.
40 USE_TK = False
40 USE_TK = False
41
41
42 #-----------------------------------------------------------------------------
42 #-----------------------------------------------------------------------------
43 # This class is trivial now, but I want to have it in to publish a clean
43 # This class is trivial now, but I want to have it in to publish a clean
44 # interface. Later when the internals are reorganized, code that uses this
44 # interface. Later when the internals are reorganized, code that uses this
45 # shouldn't have to change.
45 # shouldn't have to change.
46
46
47 class IPShell:
47 class IPShell:
48 """Create an IPython instance."""
48 """Create an IPython instance."""
49
49
50 def __init__(self,argv=None,user_ns=None,debug=1,
50 def __init__(self,argv=None,user_ns=None,user_global_ns=None,
51 shell_class=InteractiveShell):
51 debug=1,shell_class=InteractiveShell):
52 self.IP = make_IPython(argv,user_ns=user_ns,debug=debug,
52 self.IP = make_IPython(argv,user_ns=user_ns,user_global_ns=user_global_ns,
53 shell_class=shell_class)
53 debug=debug,shell_class=shell_class)
54
54
55 def mainloop(self,sys_exit=0,banner=None):
55 def mainloop(self,sys_exit=0,banner=None):
56 self.IP.mainloop(banner)
56 self.IP.mainloop(banner)
57 if sys_exit:
57 if sys_exit:
58 sys.exit()
58 sys.exit()
59
59
60 #-----------------------------------------------------------------------------
60 #-----------------------------------------------------------------------------
61 class IPShellEmbed:
61 class IPShellEmbed:
62 """Allow embedding an IPython shell into a running program.
62 """Allow embedding an IPython shell into a running program.
63
63
64 Instances of this class are callable, with the __call__ method being an
64 Instances of this class are callable, with the __call__ method being an
65 alias to the embed() method of an InteractiveShell instance.
65 alias to the embed() method of an InteractiveShell instance.
66
66
67 Usage (see also the example-embed.py file for a running example):
67 Usage (see also the example-embed.py file for a running example):
68
68
69 ipshell = IPShellEmbed([argv,banner,exit_msg,rc_override])
69 ipshell = IPShellEmbed([argv,banner,exit_msg,rc_override])
70
70
71 - argv: list containing valid command-line options for IPython, as they
71 - argv: list containing valid command-line options for IPython, as they
72 would appear in sys.argv[1:].
72 would appear in sys.argv[1:].
73
73
74 For example, the following command-line options:
74 For example, the following command-line options:
75
75
76 $ ipython -prompt_in1 'Input <\\#>' -colors LightBG
76 $ ipython -prompt_in1 'Input <\\#>' -colors LightBG
77
77
78 would be passed in the argv list as:
78 would be passed in the argv list as:
79
79
80 ['-prompt_in1','Input <\\#>','-colors','LightBG']
80 ['-prompt_in1','Input <\\#>','-colors','LightBG']
81
81
82 - banner: string which gets printed every time the interpreter starts.
82 - banner: string which gets printed every time the interpreter starts.
83
83
84 - exit_msg: string which gets printed every time the interpreter exits.
84 - exit_msg: string which gets printed every time the interpreter exits.
85
85
86 - rc_override: a dict or Struct of configuration options such as those
86 - rc_override: a dict or Struct of configuration options such as those
87 used by IPython. These options are read from your ~/.ipython/ipythonrc
87 used by IPython. These options are read from your ~/.ipython/ipythonrc
88 file when the Shell object is created. Passing an explicit rc_override
88 file when the Shell object is created. Passing an explicit rc_override
89 dict with any options you want allows you to override those values at
89 dict with any options you want allows you to override those values at
90 creation time without having to modify the file. This way you can create
90 creation time without having to modify the file. This way you can create
91 embeddable instances configured in any way you want without editing any
91 embeddable instances configured in any way you want without editing any
92 global files (thus keeping your interactive IPython configuration
92 global files (thus keeping your interactive IPython configuration
93 unchanged).
93 unchanged).
94
94
95 Then the ipshell instance can be called anywhere inside your code:
95 Then the ipshell instance can be called anywhere inside your code:
96
96
97 ipshell(header='') -> Opens up an IPython shell.
97 ipshell(header='') -> Opens up an IPython shell.
98
98
99 - header: string printed by the IPython shell upon startup. This can let
99 - header: string printed by the IPython shell upon startup. This can let
100 you know where in your code you are when dropping into the shell. Note
100 you know where in your code you are when dropping into the shell. Note
101 that 'banner' gets prepended to all calls, so header is used for
101 that 'banner' gets prepended to all calls, so header is used for
102 location-specific information.
102 location-specific information.
103
103
104 For more details, see the __call__ method below.
104 For more details, see the __call__ method below.
105
105
106 When the IPython shell is exited with Ctrl-D, normal program execution
106 When the IPython shell is exited with Ctrl-D, normal program execution
107 resumes.
107 resumes.
108
108
109 This functionality was inspired by a posting on comp.lang.python by cmkl
109 This functionality was inspired by a posting on comp.lang.python by cmkl
110 <cmkleffner@gmx.de> on Dec. 06/01 concerning similar uses of pyrepl, and
110 <cmkleffner@gmx.de> on Dec. 06/01 concerning similar uses of pyrepl, and
111 by the IDL stop/continue commands."""
111 by the IDL stop/continue commands."""
112
112
113 def __init__(self,argv=None,banner='',exit_msg=None,rc_override=None):
113 def __init__(self,argv=None,banner='',exit_msg=None,rc_override=None):
114 """Note that argv here is a string, NOT a list."""
114 """Note that argv here is a string, NOT a list."""
115 self.set_banner(banner)
115 self.set_banner(banner)
116 self.set_exit_msg(exit_msg)
116 self.set_exit_msg(exit_msg)
117 self.set_dummy_mode(0)
117 self.set_dummy_mode(0)
118
118
119 # sys.displayhook is a global, we need to save the user's original
119 # sys.displayhook is a global, we need to save the user's original
120 # Don't rely on __displayhook__, as the user may have changed that.
120 # Don't rely on __displayhook__, as the user may have changed that.
121 self.sys_displayhook_ori = sys.displayhook
121 self.sys_displayhook_ori = sys.displayhook
122
122
123 # save readline completer status
123 # save readline completer status
124 try:
124 try:
125 #print 'Save completer',sys.ipcompleter # dbg
125 #print 'Save completer',sys.ipcompleter # dbg
126 self.sys_ipcompleter_ori = sys.ipcompleter
126 self.sys_ipcompleter_ori = sys.ipcompleter
127 except:
127 except:
128 pass # not nested with IPython
128 pass # not nested with IPython
129
129
130 # FIXME. Passing user_ns breaks namespace handling.
130 # FIXME. Passing user_ns breaks namespace handling.
131 #self.IP = make_IPython(argv,user_ns=__main__.__dict__)
131 #self.IP = make_IPython(argv,user_ns=__main__.__dict__)
132 self.IP = make_IPython(argv,rc_override=rc_override,embedded=True)
132 self.IP = make_IPython(argv,rc_override=rc_override,embedded=True)
133
133
134 # copy our own displayhook also
134 # copy our own displayhook also
135 self.sys_displayhook_embed = sys.displayhook
135 self.sys_displayhook_embed = sys.displayhook
136 # and leave the system's display hook clean
136 # and leave the system's display hook clean
137 sys.displayhook = self.sys_displayhook_ori
137 sys.displayhook = self.sys_displayhook_ori
138 # don't use the ipython crash handler so that user exceptions aren't
138 # don't use the ipython crash handler so that user exceptions aren't
139 # trapped
139 # trapped
140 sys.excepthook = ultraTB.FormattedTB(color_scheme = self.IP.rc.colors,
140 sys.excepthook = ultraTB.FormattedTB(color_scheme = self.IP.rc.colors,
141 mode = self.IP.rc.xmode,
141 mode = self.IP.rc.xmode,
142 call_pdb = self.IP.rc.pdb)
142 call_pdb = self.IP.rc.pdb)
143 self.restore_system_completer()
143 self.restore_system_completer()
144
144
145 def restore_system_completer(self):
145 def restore_system_completer(self):
146 """Restores the readline completer which was in place.
146 """Restores the readline completer which was in place.
147
147
148 This allows embedded IPython within IPython not to disrupt the
148 This allows embedded IPython within IPython not to disrupt the
149 parent's completion.
149 parent's completion.
150 """
150 """
151
151
152 try:
152 try:
153 self.IP.readline.set_completer(self.sys_ipcompleter_ori)
153 self.IP.readline.set_completer(self.sys_ipcompleter_ori)
154 sys.ipcompleter = self.sys_ipcompleter_ori
154 sys.ipcompleter = self.sys_ipcompleter_ori
155 except:
155 except:
156 pass
156 pass
157
157
158 def __call__(self,header='',local_ns=None,global_ns=None,dummy=None):
158 def __call__(self,header='',local_ns=None,global_ns=None,dummy=None):
159 """Activate the interactive interpreter.
159 """Activate the interactive interpreter.
160
160
161 __call__(self,header='',local_ns=None,global_ns,dummy=None) -> Start
161 __call__(self,header='',local_ns=None,global_ns,dummy=None) -> Start
162 the interpreter shell with the given local and global namespaces, and
162 the interpreter shell with the given local and global namespaces, and
163 optionally print a header string at startup.
163 optionally print a header string at startup.
164
164
165 The shell can be globally activated/deactivated using the
165 The shell can be globally activated/deactivated using the
166 set/get_dummy_mode methods. This allows you to turn off a shell used
166 set/get_dummy_mode methods. This allows you to turn off a shell used
167 for debugging globally.
167 for debugging globally.
168
168
169 However, *each* time you call the shell you can override the current
169 However, *each* time you call the shell you can override the current
170 state of dummy_mode with the optional keyword parameter 'dummy'. For
170 state of dummy_mode with the optional keyword parameter 'dummy'. For
171 example, if you set dummy mode on with IPShell.set_dummy_mode(1), you
171 example, if you set dummy mode on with IPShell.set_dummy_mode(1), you
172 can still have a specific call work by making it as IPShell(dummy=0).
172 can still have a specific call work by making it as IPShell(dummy=0).
173
173
174 The optional keyword parameter dummy controls whether the call
174 The optional keyword parameter dummy controls whether the call
175 actually does anything. """
175 actually does anything. """
176
176
177 # Allow the dummy parameter to override the global __dummy_mode
177 # Allow the dummy parameter to override the global __dummy_mode
178 if dummy or (dummy != 0 and self.__dummy_mode):
178 if dummy or (dummy != 0 and self.__dummy_mode):
179 return
179 return
180
180
181 # Set global subsystems (display,completions) to our values
181 # Set global subsystems (display,completions) to our values
182 sys.displayhook = self.sys_displayhook_embed
182 sys.displayhook = self.sys_displayhook_embed
183 if self.IP.has_readline:
183 if self.IP.has_readline:
184 self.IP.readline.set_completer(self.IP.Completer.complete)
184 self.IP.readline.set_completer(self.IP.Completer.complete)
185
185
186 if self.banner and header:
186 if self.banner and header:
187 format = '%s\n%s\n'
187 format = '%s\n%s\n'
188 else:
188 else:
189 format = '%s%s\n'
189 format = '%s%s\n'
190 banner = format % (self.banner,header)
190 banner = format % (self.banner,header)
191
191
192 # Call the embedding code with a stack depth of 1 so it can skip over
192 # Call the embedding code with a stack depth of 1 so it can skip over
193 # our call and get the original caller's namespaces.
193 # our call and get the original caller's namespaces.
194 self.IP.embed_mainloop(banner,local_ns,global_ns,stack_depth=1)
194 self.IP.embed_mainloop(banner,local_ns,global_ns,stack_depth=1)
195
195
196 if self.exit_msg:
196 if self.exit_msg:
197 print self.exit_msg
197 print self.exit_msg
198
198
199 # Restore global systems (display, completion)
199 # Restore global systems (display, completion)
200 sys.displayhook = self.sys_displayhook_ori
200 sys.displayhook = self.sys_displayhook_ori
201 self.restore_system_completer()
201 self.restore_system_completer()
202
202
203 def set_dummy_mode(self,dummy):
203 def set_dummy_mode(self,dummy):
204 """Sets the embeddable shell's dummy mode parameter.
204 """Sets the embeddable shell's dummy mode parameter.
205
205
206 set_dummy_mode(dummy): dummy = 0 or 1.
206 set_dummy_mode(dummy): dummy = 0 or 1.
207
207
208 This parameter is persistent and makes calls to the embeddable shell
208 This parameter is persistent and makes calls to the embeddable shell
209 silently return without performing any action. This allows you to
209 silently return without performing any action. This allows you to
210 globally activate or deactivate a shell you're using with a single call.
210 globally activate or deactivate a shell you're using with a single call.
211
211
212 If you need to manually"""
212 If you need to manually"""
213
213
214 if dummy not in [0,1,False,True]:
214 if dummy not in [0,1,False,True]:
215 raise ValueError,'dummy parameter must be boolean'
215 raise ValueError,'dummy parameter must be boolean'
216 self.__dummy_mode = dummy
216 self.__dummy_mode = dummy
217
217
218 def get_dummy_mode(self):
218 def get_dummy_mode(self):
219 """Return the current value of the dummy mode parameter.
219 """Return the current value of the dummy mode parameter.
220 """
220 """
221 return self.__dummy_mode
221 return self.__dummy_mode
222
222
223 def set_banner(self,banner):
223 def set_banner(self,banner):
224 """Sets the global banner.
224 """Sets the global banner.
225
225
226 This banner gets prepended to every header printed when the shell
226 This banner gets prepended to every header printed when the shell
227 instance is called."""
227 instance is called."""
228
228
229 self.banner = banner
229 self.banner = banner
230
230
231 def set_exit_msg(self,exit_msg):
231 def set_exit_msg(self,exit_msg):
232 """Sets the global exit_msg.
232 """Sets the global exit_msg.
233
233
234 This exit message gets printed upon exiting every time the embedded
234 This exit message gets printed upon exiting every time the embedded
235 shell is called. It is None by default. """
235 shell is called. It is None by default. """
236
236
237 self.exit_msg = exit_msg
237 self.exit_msg = exit_msg
238
238
239 #-----------------------------------------------------------------------------
239 #-----------------------------------------------------------------------------
240 def sigint_handler (signum,stack_frame):
240 def sigint_handler (signum,stack_frame):
241 """Sigint handler for threaded apps.
241 """Sigint handler for threaded apps.
242
242
243 This is a horrible hack to pass information about SIGINT _without_ using
243 This is a horrible hack to pass information about SIGINT _without_ using
244 exceptions, since I haven't been able to properly manage cross-thread
244 exceptions, since I haven't been able to properly manage cross-thread
245 exceptions in GTK/WX. In fact, I don't think it can be done (or at least
245 exceptions in GTK/WX. In fact, I don't think it can be done (or at least
246 that's my understanding from a c.l.py thread where this was discussed)."""
246 that's my understanding from a c.l.py thread where this was discussed)."""
247
247
248 global KBINT
248 global KBINT
249
249
250 print '\nKeyboardInterrupt - Press <Enter> to continue.',
250 print '\nKeyboardInterrupt - Press <Enter> to continue.',
251 Term.cout.flush()
251 Term.cout.flush()
252 # Set global flag so that runsource can know that Ctrl-C was hit
252 # Set global flag so that runsource can know that Ctrl-C was hit
253 KBINT = True
253 KBINT = True
254
254
255 class MTInteractiveShell(InteractiveShell):
255 class MTInteractiveShell(InteractiveShell):
256 """Simple multi-threaded shell."""
256 """Simple multi-threaded shell."""
257
257
258 # Threading strategy taken from:
258 # Threading strategy taken from:
259 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/65109, by Brian
259 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/65109, by Brian
260 # McErlean and John Finlay. Modified with corrections by Antoon Pardon,
260 # McErlean and John Finlay. Modified with corrections by Antoon Pardon,
261 # from the pygtk mailing list, to avoid lockups with system calls.
261 # from the pygtk mailing list, to avoid lockups with system calls.
262
262
263 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
263 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
264 user_ns = None, banner2='',**kw):
264 user_ns=None,user_global_ns=None,banner2='',**kw):
265 """Similar to the normal InteractiveShell, but with threading control"""
265 """Similar to the normal InteractiveShell, but with threading control"""
266
266
267 IPython.iplib.InteractiveShell.__init__(self,name,usage,rc,user_ns,banner2)
267 InteractiveShell.__init__(self,name,usage,rc,user_ns,
268 user_global_ns,banner2)
268
269
269 # Locking control variable
270 # Locking control variable
270 self.thread_ready = threading.Condition()
271 self.thread_ready = threading.Condition()
271
272
272 # Stuff to do at closing time
273 # Stuff to do at closing time
273 self._kill = False
274 self._kill = False
274 on_kill = kw.get('on_kill')
275 on_kill = kw.get('on_kill')
275 if on_kill is None:
276 if on_kill is None:
276 on_kill = []
277 on_kill = []
277 # Check that all things to kill are callable:
278 # Check that all things to kill are callable:
278 for t in on_kill:
279 for t in on_kill:
279 if not callable(t):
280 if not callable(t):
280 raise TypeError,'on_kill must be a list of callables'
281 raise TypeError,'on_kill must be a list of callables'
281 self.on_kill = on_kill
282 self.on_kill = on_kill
282
283
283 def runsource(self, source, filename="<input>", symbol="single"):
284 def runsource(self, source, filename="<input>", symbol="single"):
284 """Compile and run some source in the interpreter.
285 """Compile and run some source in the interpreter.
285
286
286 Modified version of code.py's runsource(), to handle threading issues.
287 Modified version of code.py's runsource(), to handle threading issues.
287 See the original for full docstring details."""
288 See the original for full docstring details."""
288
289
289 global KBINT
290 global KBINT
290
291
291 # If Ctrl-C was typed, we reset the flag and return right away
292 # If Ctrl-C was typed, we reset the flag and return right away
292 if KBINT:
293 if KBINT:
293 KBINT = False
294 KBINT = False
294 return False
295 return False
295
296
296 try:
297 try:
297 code = self.compile(source, filename, symbol)
298 code = self.compile(source, filename, symbol)
298 except (OverflowError, SyntaxError, ValueError):
299 except (OverflowError, SyntaxError, ValueError):
299 # Case 1
300 # Case 1
300 self.showsyntaxerror(filename)
301 self.showsyntaxerror(filename)
301 return False
302 return False
302
303
303 if code is None:
304 if code is None:
304 # Case 2
305 # Case 2
305 return True
306 return True
306
307
307 # Case 3
308 # Case 3
308 # Store code in self, so the execution thread can handle it
309 # Store code in self, so the execution thread can handle it
309 self.thread_ready.acquire()
310 self.thread_ready.acquire()
310 self.code_to_run = code
311 self.code_to_run = code
311 self.thread_ready.wait() # Wait until processed in timeout interval
312 self.thread_ready.wait() # Wait until processed in timeout interval
312 self.thread_ready.release()
313 self.thread_ready.release()
313
314
314 return False
315 return False
315
316
316 def runcode(self):
317 def runcode(self):
317 """Execute a code object.
318 """Execute a code object.
318
319
319 Multithreaded wrapper around IPython's runcode()."""
320 Multithreaded wrapper around IPython's runcode()."""
320
321
321 # lock thread-protected stuff
322 # lock thread-protected stuff
322 self.thread_ready.acquire()
323 self.thread_ready.acquire()
323
324
324 # Install sigint handler
325 # Install sigint handler
325 try:
326 try:
326 signal.signal(signal.SIGINT, sigint_handler)
327 signal.signal(signal.SIGINT, sigint_handler)
327 except SystemError:
328 except SystemError:
328 # This happens under Windows, which seems to have all sorts
329 # This happens under Windows, which seems to have all sorts
329 # of problems with signal handling. Oh well...
330 # of problems with signal handling. Oh well...
330 pass
331 pass
331
332
332 if self._kill:
333 if self._kill:
333 print >>Term.cout, 'Closing threads...',
334 print >>Term.cout, 'Closing threads...',
334 Term.cout.flush()
335 Term.cout.flush()
335 for tokill in self.on_kill:
336 for tokill in self.on_kill:
336 tokill()
337 tokill()
337 print >>Term.cout, 'Done.'
338 print >>Term.cout, 'Done.'
338
339
339 # Run pending code by calling parent class
340 # Run pending code by calling parent class
340 if self.code_to_run is not None:
341 if self.code_to_run is not None:
341 self.thread_ready.notify()
342 self.thread_ready.notify()
342 InteractiveShell.runcode(self,self.code_to_run)
343 InteractiveShell.runcode(self,self.code_to_run)
343
344
344 # We're done with thread-protected variables
345 # We're done with thread-protected variables
345 self.thread_ready.release()
346 self.thread_ready.release()
346 # This MUST return true for gtk threading to work
347 # This MUST return true for gtk threading to work
347 return True
348 return True
348
349
349 def kill (self):
350 def kill (self):
350 """Kill the thread, returning when it has been shut down."""
351 """Kill the thread, returning when it has been shut down."""
351 self.thread_ready.acquire()
352 self.thread_ready.acquire()
352 self._kill = True
353 self._kill = True
353 self.thread_ready.release()
354 self.thread_ready.release()
354
355
355 class MatplotlibShellBase:
356 class MatplotlibShellBase:
356 """Mixin class to provide the necessary modifications to regular IPython
357 """Mixin class to provide the necessary modifications to regular IPython
357 shell classes for matplotlib support.
358 shell classes for matplotlib support.
358
359
359 Given Python's MRO, this should be used as the FIRST class in the
360 Given Python's MRO, this should be used as the FIRST class in the
360 inheritance hierarchy, so that it overrides the relevant methods."""
361 inheritance hierarchy, so that it overrides the relevant methods."""
361
362
362 def _matplotlib_config(self,name):
363 def _matplotlib_config(self,name):
363 """Return various items needed to setup the user's shell with matplotlib"""
364 """Return various items needed to setup the user's shell with matplotlib"""
364
365
365 # Initialize matplotlib to interactive mode always
366 # Initialize matplotlib to interactive mode always
366 import matplotlib
367 import matplotlib
367 from matplotlib import backends
368 from matplotlib import backends
368 matplotlib.interactive(True)
369 matplotlib.interactive(True)
369
370
370 def use(arg):
371 def use(arg):
371 """IPython wrapper for matplotlib's backend switcher.
372 """IPython wrapper for matplotlib's backend switcher.
372
373
373 In interactive use, we can not allow switching to a different
374 In interactive use, we can not allow switching to a different
374 interactive backend, since thread conflicts will most likely crash
375 interactive backend, since thread conflicts will most likely crash
375 the python interpreter. This routine does a safety check first,
376 the python interpreter. This routine does a safety check first,
376 and refuses to perform a dangerous switch. It still allows
377 and refuses to perform a dangerous switch. It still allows
377 switching to non-interactive backends."""
378 switching to non-interactive backends."""
378
379
379 if arg in backends.interactive_bk and arg != self.mpl_backend:
380 if arg in backends.interactive_bk and arg != self.mpl_backend:
380 m=('invalid matplotlib backend switch.\n'
381 m=('invalid matplotlib backend switch.\n'
381 'This script attempted to switch to the interactive '
382 'This script attempted to switch to the interactive '
382 'backend: `%s`\n'
383 'backend: `%s`\n'
383 'Your current choice of interactive backend is: `%s`\n\n'
384 'Your current choice of interactive backend is: `%s`\n\n'
384 'Switching interactive matplotlib backends at runtime\n'
385 'Switching interactive matplotlib backends at runtime\n'
385 'would crash the python interpreter, '
386 'would crash the python interpreter, '
386 'and IPython has blocked it.\n\n'
387 'and IPython has blocked it.\n\n'
387 'You need to either change your choice of matplotlib backend\n'
388 'You need to either change your choice of matplotlib backend\n'
388 'by editing your .matplotlibrc file, or run this script as a \n'
389 'by editing your .matplotlibrc file, or run this script as a \n'
389 'standalone file from the command line, not using IPython.\n' %
390 'standalone file from the command line, not using IPython.\n' %
390 (arg,self.mpl_backend) )
391 (arg,self.mpl_backend) )
391 raise RuntimeError, m
392 raise RuntimeError, m
392 else:
393 else:
393 self.mpl_use(arg)
394 self.mpl_use(arg)
394 self.mpl_use._called = True
395 self.mpl_use._called = True
395
396
396 self.matplotlib = matplotlib
397 self.matplotlib = matplotlib
397 self.mpl_backend = matplotlib.rcParams['backend']
398 self.mpl_backend = matplotlib.rcParams['backend']
398
399
399 # we also need to block switching of interactive backends by use()
400 # we also need to block switching of interactive backends by use()
400 self.mpl_use = matplotlib.use
401 self.mpl_use = matplotlib.use
401 self.mpl_use._called = False
402 self.mpl_use._called = False
402 # overwrite the original matplotlib.use with our wrapper
403 # overwrite the original matplotlib.use with our wrapper
403 matplotlib.use = use
404 matplotlib.use = use
404
405
405
406
406 # This must be imported last in the matplotlib series, after
407 # This must be imported last in the matplotlib series, after
407 # backend/interactivity choices have been made
408 # backend/interactivity choices have been made
408 try:
409 try:
409 import matplotlib.pylab as pylab
410 import matplotlib.pylab as pylab
410 self.pylab = pylab
411 self.pylab = pylab
411 self.pylab_name = 'pylab'
412 self.pylab_name = 'pylab'
412 except ImportError:
413 except ImportError:
413 import matplotlib.matlab as matlab
414 import matplotlib.matlab as matlab
414 self.pylab = matlab
415 self.pylab = matlab
415 self.pylab_name = 'matlab'
416 self.pylab_name = 'matlab'
416
417
417 self.pylab.show._needmain = False
418 self.pylab.show._needmain = False
418 # We need to detect at runtime whether show() is called by the user.
419 # We need to detect at runtime whether show() is called by the user.
419 # For this, we wrap it into a decorator which adds a 'called' flag.
420 # For this, we wrap it into a decorator which adds a 'called' flag.
420 self.pylab.draw_if_interactive = flag_calls(self.pylab.draw_if_interactive)
421 self.pylab.draw_if_interactive = flag_calls(self.pylab.draw_if_interactive)
421
422
422 # Build a user namespace initialized with matplotlib/matlab features.
423 # Build a user namespace initialized with matplotlib/matlab features.
423 user_ns = {'__name__':'__main__',
424 user_ns = {'__name__':'__main__',
424 '__builtins__' : __builtin__ }
425 '__builtins__' : __builtin__ }
425
426
426 # Be careful not to remove the final \n in the code string below, or
427 # Be careful not to remove the final \n in the code string below, or
427 # things will break badly with py22 (I think it's a python bug, 2.3 is
428 # things will break badly with py22 (I think it's a python bug, 2.3 is
428 # OK).
429 # OK).
429 pname = self.pylab_name # Python can't interpolate dotted var names
430 pname = self.pylab_name # Python can't interpolate dotted var names
430 exec ("import matplotlib\n"
431 exec ("import matplotlib\n"
431 "import matplotlib.%(pname)s as %(pname)s\n"
432 "import matplotlib.%(pname)s as %(pname)s\n"
432 "from matplotlib.%(pname)s import *\n" % locals()) in user_ns
433 "from matplotlib.%(pname)s import *\n" % locals()) in user_ns
433
434
434 # Build matplotlib info banner
435 # Build matplotlib info banner
435 b="""
436 b="""
436 Welcome to pylab, a matplotlib-based Python environment.
437 Welcome to pylab, a matplotlib-based Python environment.
437 For more information, type 'help(pylab)'.
438 For more information, type 'help(pylab)'.
438 """
439 """
439 return user_ns,b
440 return user_ns,b
440
441
441 def mplot_exec(self,fname,*where,**kw):
442 def mplot_exec(self,fname,*where,**kw):
442 """Execute a matplotlib script.
443 """Execute a matplotlib script.
443
444
444 This is a call to execfile(), but wrapped in safeties to properly
445 This is a call to execfile(), but wrapped in safeties to properly
445 handle interactive rendering and backend switching."""
446 handle interactive rendering and backend switching."""
446
447
447 #print '*** Matplotlib runner ***' # dbg
448 #print '*** Matplotlib runner ***' # dbg
448 # turn off rendering until end of script
449 # turn off rendering until end of script
449 isInteractive = self.matplotlib.rcParams['interactive']
450 isInteractive = self.matplotlib.rcParams['interactive']
450 self.matplotlib.interactive(False)
451 self.matplotlib.interactive(False)
451 self.safe_execfile(fname,*where,**kw)
452 self.safe_execfile(fname,*where,**kw)
452 self.matplotlib.interactive(isInteractive)
453 self.matplotlib.interactive(isInteractive)
453 # make rendering call now, if the user tried to do it
454 # make rendering call now, if the user tried to do it
454 if self.pylab.draw_if_interactive.called:
455 if self.pylab.draw_if_interactive.called:
455 self.pylab.draw()
456 self.pylab.draw()
456 self.pylab.draw_if_interactive.called = False
457 self.pylab.draw_if_interactive.called = False
457
458
458 # if a backend switch was performed, reverse it now
459 # if a backend switch was performed, reverse it now
459 if self.mpl_use._called:
460 if self.mpl_use._called:
460 self.matplotlib.rcParams['backend'] = self.mpl_backend
461 self.matplotlib.rcParams['backend'] = self.mpl_backend
461
462
462 def magic_run(self,parameter_s=''):
463 def magic_run(self,parameter_s=''):
463 Magic.magic_run(self,parameter_s,runner=self.mplot_exec)
464 Magic.magic_run(self,parameter_s,runner=self.mplot_exec)
464
465
465 # Fix the docstring so users see the original as well
466 # Fix the docstring so users see the original as well
466 magic_run.__doc__ = "%s\n%s" % (Magic.magic_run.__doc__,
467 magic_run.__doc__ = "%s\n%s" % (Magic.magic_run.__doc__,
467 "\n *** Modified %run for Matplotlib,"
468 "\n *** Modified %run for Matplotlib,"
468 " with proper interactive handling ***")
469 " with proper interactive handling ***")
469
470
470 # Now we provide 2 versions of a matplotlib-aware IPython base shells, single
471 # Now we provide 2 versions of a matplotlib-aware IPython base shells, single
471 # and multithreaded. Note that these are meant for internal use, the IPShell*
472 # and multithreaded. Note that these are meant for internal use, the IPShell*
472 # classes below are the ones meant for public consumption.
473 # classes below are the ones meant for public consumption.
473
474
474 class MatplotlibShell(MatplotlibShellBase,InteractiveShell):
475 class MatplotlibShell(MatplotlibShellBase,InteractiveShell):
475 """Single-threaded shell with matplotlib support."""
476 """Single-threaded shell with matplotlib support."""
476
477
477 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
478 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
478 user_ns = None, **kw):
479 user_ns=None,user_global_ns=None,**kw):
479 user_ns,b2 = self._matplotlib_config(name)
480 user_ns,b2 = self._matplotlib_config(name)
480 InteractiveShell.__init__(self,name,usage,rc,user_ns,banner2=b2,**kw)
481 InteractiveShell.__init__(self,name,usage,rc,user_ns,user_global_ns,
482 banner2=b2,**kw)
481
483
482 class MatplotlibMTShell(MatplotlibShellBase,MTInteractiveShell):
484 class MatplotlibMTShell(MatplotlibShellBase,MTInteractiveShell):
483 """Multi-threaded shell with matplotlib support."""
485 """Multi-threaded shell with matplotlib support."""
484
486
485 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
487 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
486 user_ns = None, **kw):
488 user_ns=None,user_global_ns=None, **kw):
487 user_ns,b2 = self._matplotlib_config(name)
489 user_ns,b2 = self._matplotlib_config(name)
488 MTInteractiveShell.__init__(self,name,usage,rc,user_ns,banner2=b2,**kw)
490 MTInteractiveShell.__init__(self,name,usage,rc,user_ns,user_global_ns,
491 banner2=b2,**kw)
489
492
490 #-----------------------------------------------------------------------------
493 #-----------------------------------------------------------------------------
491 # Utility functions for the different GUI enabled IPShell* classes.
494 # Utility functions for the different GUI enabled IPShell* classes.
492
495
493 def get_tk():
496 def get_tk():
494 """Tries to import Tkinter and returns a withdrawn Tkinter root
497 """Tries to import Tkinter and returns a withdrawn Tkinter root
495 window. If Tkinter is already imported or not available, this
498 window. If Tkinter is already imported or not available, this
496 returns None. This function calls `hijack_tk` underneath.
499 returns None. This function calls `hijack_tk` underneath.
497 """
500 """
498 if not USE_TK or sys.modules.has_key('Tkinter'):
501 if not USE_TK or sys.modules.has_key('Tkinter'):
499 return None
502 return None
500 else:
503 else:
501 try:
504 try:
502 import Tkinter
505 import Tkinter
503 except ImportError:
506 except ImportError:
504 return None
507 return None
505 else:
508 else:
506 hijack_tk()
509 hijack_tk()
507 r = Tkinter.Tk()
510 r = Tkinter.Tk()
508 r.withdraw()
511 r.withdraw()
509 return r
512 return r
510
513
511 def hijack_tk():
514 def hijack_tk():
512 """Modifies Tkinter's mainloop with a dummy so when a module calls
515 """Modifies Tkinter's mainloop with a dummy so when a module calls
513 mainloop, it does not block.
516 mainloop, it does not block.
514
517
515 """
518 """
516 def misc_mainloop(self, n=0):
519 def misc_mainloop(self, n=0):
517 pass
520 pass
518 def tkinter_mainloop(n=0):
521 def tkinter_mainloop(n=0):
519 pass
522 pass
520
523
521 import Tkinter
524 import Tkinter
522 Tkinter.Misc.mainloop = misc_mainloop
525 Tkinter.Misc.mainloop = misc_mainloop
523 Tkinter.mainloop = tkinter_mainloop
526 Tkinter.mainloop = tkinter_mainloop
524
527
525 def update_tk(tk):
528 def update_tk(tk):
526 """Updates the Tkinter event loop. This is typically called from
529 """Updates the Tkinter event loop. This is typically called from
527 the respective WX or GTK mainloops.
530 the respective WX or GTK mainloops.
528 """
531 """
529 if tk:
532 if tk:
530 tk.update()
533 tk.update()
531
534
532 def hijack_wx():
535 def hijack_wx():
533 """Modifies wxPython's MainLoop with a dummy so user code does not
536 """Modifies wxPython's MainLoop with a dummy so user code does not
534 block IPython. The hijacked mainloop function is returned.
537 block IPython. The hijacked mainloop function is returned.
535 """
538 """
536 def dummy_mainloop(*args, **kw):
539 def dummy_mainloop(*args, **kw):
537 pass
540 pass
538 import wxPython
541 import wxPython
539 ver = wxPython.__version__
542 ver = wxPython.__version__
540 orig_mainloop = None
543 orig_mainloop = None
541 if ver[:3] >= '2.5':
544 if ver[:3] >= '2.5':
542 import wx
545 import wx
543 if hasattr(wx, '_core_'): core = getattr(wx, '_core_')
546 if hasattr(wx, '_core_'): core = getattr(wx, '_core_')
544 elif hasattr(wx, '_core'): core = getattr(wx, '_core')
547 elif hasattr(wx, '_core'): core = getattr(wx, '_core')
545 else: raise AttributeError('Could not find wx core module')
548 else: raise AttributeError('Could not find wx core module')
546 orig_mainloop = core.PyApp_MainLoop
549 orig_mainloop = core.PyApp_MainLoop
547 core.PyApp_MainLoop = dummy_mainloop
550 core.PyApp_MainLoop = dummy_mainloop
548 elif ver[:3] == '2.4':
551 elif ver[:3] == '2.4':
549 orig_mainloop = wxPython.wxc.wxPyApp_MainLoop
552 orig_mainloop = wxPython.wxc.wxPyApp_MainLoop
550 wxPython.wxc.wxPyApp_MainLoop = dummy_mainloop
553 wxPython.wxc.wxPyApp_MainLoop = dummy_mainloop
551 else:
554 else:
552 warn("Unable to find either wxPython version 2.4 or >= 2.5.")
555 warn("Unable to find either wxPython version 2.4 or >= 2.5.")
553 return orig_mainloop
556 return orig_mainloop
554
557
555 def hijack_gtk():
558 def hijack_gtk():
556 """Modifies pyGTK's mainloop with a dummy so user code does not
559 """Modifies pyGTK's mainloop with a dummy so user code does not
557 block IPython. This function returns the original `gtk.mainloop`
560 block IPython. This function returns the original `gtk.mainloop`
558 function that has been hijacked.
561 function that has been hijacked.
559 """
562 """
560 def dummy_mainloop(*args, **kw):
563 def dummy_mainloop(*args, **kw):
561 pass
564 pass
562 import gtk
565 import gtk
563 if gtk.pygtk_version >= (2,4,0): orig_mainloop = gtk.main
566 if gtk.pygtk_version >= (2,4,0): orig_mainloop = gtk.main
564 else: orig_mainloop = gtk.mainloop
567 else: orig_mainloop = gtk.mainloop
565 gtk.mainloop = dummy_mainloop
568 gtk.mainloop = dummy_mainloop
566 gtk.main = dummy_mainloop
569 gtk.main = dummy_mainloop
567 return orig_mainloop
570 return orig_mainloop
568
571
569 #-----------------------------------------------------------------------------
572 #-----------------------------------------------------------------------------
570 # The IPShell* classes below are the ones meant to be run by external code as
573 # The IPShell* classes below are the ones meant to be run by external code as
571 # IPython instances. Note that unless a specific threading strategy is
574 # IPython instances. Note that unless a specific threading strategy is
572 # desired, the factory function start() below should be used instead (it
575 # desired, the factory function start() below should be used instead (it
573 # selects the proper threaded class).
576 # selects the proper threaded class).
574
577
575 class IPShellGTK(threading.Thread):
578 class IPShellGTK(threading.Thread):
576 """Run a gtk mainloop() in a separate thread.
579 """Run a gtk mainloop() in a separate thread.
577
580
578 Python commands can be passed to the thread where they will be executed.
581 Python commands can be passed to the thread where they will be executed.
579 This is implemented by periodically checking for passed code using a
582 This is implemented by periodically checking for passed code using a
580 GTK timeout callback."""
583 GTK timeout callback."""
581
584
582 TIMEOUT = 100 # Millisecond interval between timeouts.
585 TIMEOUT = 100 # Millisecond interval between timeouts.
583
586
584 def __init__(self,argv=None,user_ns=None,debug=1,
587 def __init__(self,argv=None,user_ns=None,user_global_ns=None,
585 shell_class=MTInteractiveShell):
588 debug=1,shell_class=MTInteractiveShell):
586
589
587 import gtk
590 import gtk
588
591
589 self.gtk = gtk
592 self.gtk = gtk
590 self.gtk_mainloop = hijack_gtk()
593 self.gtk_mainloop = hijack_gtk()
591
594
592 # Allows us to use both Tk and GTK.
595 # Allows us to use both Tk and GTK.
593 self.tk = get_tk()
596 self.tk = get_tk()
594
597
595 if gtk.pygtk_version >= (2,4,0): mainquit = self.gtk.main_quit
598 if gtk.pygtk_version >= (2,4,0): mainquit = self.gtk.main_quit
596 else: mainquit = self.gtk.mainquit
599 else: mainquit = self.gtk.mainquit
597
600
598 self.IP = make_IPython(argv,user_ns=user_ns,debug=debug,
601 self.IP = make_IPython(argv,user_ns=user_ns,
602 user_global_ns=user_global_ns,
603 debug=debug,
599 shell_class=shell_class,
604 shell_class=shell_class,
600 on_kill=[mainquit])
605 on_kill=[mainquit])
601
606
602 # HACK: slot for banner in self; it will be passed to the mainloop
607 # HACK: slot for banner in self; it will be passed to the mainloop
603 # method only and .run() needs it. The actual value will be set by
608 # method only and .run() needs it. The actual value will be set by
604 # .mainloop().
609 # .mainloop().
605 self._banner = None
610 self._banner = None
606
611
607 threading.Thread.__init__(self)
612 threading.Thread.__init__(self)
608
613
609 def run(self):
614 def run(self):
610 self.IP.mainloop(self._banner)
615 self.IP.mainloop(self._banner)
611 self.IP.kill()
616 self.IP.kill()
612
617
613 def mainloop(self,sys_exit=0,banner=None):
618 def mainloop(self,sys_exit=0,banner=None):
614
619
615 self._banner = banner
620 self._banner = banner
616
621
617 if self.gtk.pygtk_version >= (2,4,0):
622 if self.gtk.pygtk_version >= (2,4,0):
618 import gobject
623 import gobject
619 gobject.idle_add(self.on_timer)
624 gobject.idle_add(self.on_timer)
620 else:
625 else:
621 self.gtk.idle_add(self.on_timer)
626 self.gtk.idle_add(self.on_timer)
622
627
623 if sys.platform != 'win32':
628 if sys.platform != 'win32':
624 try:
629 try:
625 if self.gtk.gtk_version[0] >= 2:
630 if self.gtk.gtk_version[0] >= 2:
626 self.gtk.threads_init()
631 self.gtk.threads_init()
627 except AttributeError:
632 except AttributeError:
628 pass
633 pass
629 except RuntimeError:
634 except RuntimeError:
630 error('Your pyGTK likely has not been compiled with '
635 error('Your pyGTK likely has not been compiled with '
631 'threading support.\n'
636 'threading support.\n'
632 'The exception printout is below.\n'
637 'The exception printout is below.\n'
633 'You can either rebuild pyGTK with threads, or '
638 'You can either rebuild pyGTK with threads, or '
634 'try using \n'
639 'try using \n'
635 'matplotlib with a different backend (like Tk or WX).\n'
640 'matplotlib with a different backend (like Tk or WX).\n'
636 'Note that matplotlib will most likely not work in its '
641 'Note that matplotlib will most likely not work in its '
637 'current state!')
642 'current state!')
638 self.IP.InteractiveTB()
643 self.IP.InteractiveTB()
639 self.start()
644 self.start()
640 self.gtk.threads_enter()
645 self.gtk.threads_enter()
641 self.gtk_mainloop()
646 self.gtk_mainloop()
642 self.gtk.threads_leave()
647 self.gtk.threads_leave()
643 self.join()
648 self.join()
644
649
645 def on_timer(self):
650 def on_timer(self):
646 update_tk(self.tk)
651 update_tk(self.tk)
647 return self.IP.runcode()
652 return self.IP.runcode()
648
653
649
654
650 class IPShellWX(threading.Thread):
655 class IPShellWX(threading.Thread):
651 """Run a wx mainloop() in a separate thread.
656 """Run a wx mainloop() in a separate thread.
652
657
653 Python commands can be passed to the thread where they will be executed.
658 Python commands can be passed to the thread where they will be executed.
654 This is implemented by periodically checking for passed code using a
659 This is implemented by periodically checking for passed code using a
655 GTK timeout callback."""
660 GTK timeout callback."""
656
661
657 TIMEOUT = 100 # Millisecond interval between timeouts.
662 TIMEOUT = 100 # Millisecond interval between timeouts.
658
663
659 def __init__(self,argv=None,user_ns=None,debug=1,
664 def __init__(self,argv=None,user_ns=None,user_global_ns=None,
660 shell_class=MTInteractiveShell):
665 debug=1,shell_class=MTInteractiveShell):
661
666
662 import wxPython.wx as wx
667 import wxPython.wx as wx
663
668
664 threading.Thread.__init__(self)
669 threading.Thread.__init__(self)
665 self.wx = wx
670 self.wx = wx
666 self.wx_mainloop = hijack_wx()
671 self.wx_mainloop = hijack_wx()
667
672
668 # Allows us to use both Tk and GTK.
673 # Allows us to use both Tk and GTK.
669 self.tk = get_tk()
674 self.tk = get_tk()
670
675
671 self.IP = make_IPython(argv,user_ns=user_ns,debug=debug,
676 self.IP = make_IPython(argv,user_ns=user_ns,
677 user_global_ns=user_global_ns,
678 debug=debug,
672 shell_class=shell_class,
679 shell_class=shell_class,
673 on_kill=[self.wxexit])
680 on_kill=[self.wxexit])
674 # HACK: slot for banner in self; it will be passed to the mainloop
681 # HACK: slot for banner in self; it will be passed to the mainloop
675 # method only and .run() needs it. The actual value will be set by
682 # method only and .run() needs it. The actual value will be set by
676 # .mainloop().
683 # .mainloop().
677 self._banner = None
684 self._banner = None
678
685
679 self.app = None
686 self.app = None
680
687
681 def wxexit(self, *args):
688 def wxexit(self, *args):
682 if self.app is not None:
689 if self.app is not None:
683 self.app.agent.timer.Stop()
690 self.app.agent.timer.Stop()
684 self.app.ExitMainLoop()
691 self.app.ExitMainLoop()
685
692
686 def run(self):
693 def run(self):
687 self.IP.mainloop(self._banner)
694 self.IP.mainloop(self._banner)
688 self.IP.kill()
695 self.IP.kill()
689
696
690 def mainloop(self,sys_exit=0,banner=None):
697 def mainloop(self,sys_exit=0,banner=None):
691
698
692 self._banner = banner
699 self._banner = banner
693
700
694 self.start()
701 self.start()
695
702
696 class TimerAgent(self.wx.wxMiniFrame):
703 class TimerAgent(self.wx.wxMiniFrame):
697 wx = self.wx
704 wx = self.wx
698 IP = self.IP
705 IP = self.IP
699 tk = self.tk
706 tk = self.tk
700 def __init__(self, parent, interval):
707 def __init__(self, parent, interval):
701 style = self.wx.wxDEFAULT_FRAME_STYLE | self.wx.wxTINY_CAPTION_HORIZ
708 style = self.wx.wxDEFAULT_FRAME_STYLE | self.wx.wxTINY_CAPTION_HORIZ
702 self.wx.wxMiniFrame.__init__(self, parent, -1, ' ', pos=(200, 200),
709 self.wx.wxMiniFrame.__init__(self, parent, -1, ' ', pos=(200, 200),
703 size=(100, 100),style=style)
710 size=(100, 100),style=style)
704 self.Show(False)
711 self.Show(False)
705 self.interval = interval
712 self.interval = interval
706 self.timerId = self.wx.wxNewId()
713 self.timerId = self.wx.wxNewId()
707
714
708 def StartWork(self):
715 def StartWork(self):
709 self.timer = self.wx.wxTimer(self, self.timerId)
716 self.timer = self.wx.wxTimer(self, self.timerId)
710 self.wx.EVT_TIMER(self, self.timerId, self.OnTimer)
717 self.wx.EVT_TIMER(self, self.timerId, self.OnTimer)
711 self.timer.Start(self.interval)
718 self.timer.Start(self.interval)
712
719
713 def OnTimer(self, event):
720 def OnTimer(self, event):
714 update_tk(self.tk)
721 update_tk(self.tk)
715 self.IP.runcode()
722 self.IP.runcode()
716
723
717 class App(self.wx.wxApp):
724 class App(self.wx.wxApp):
718 wx = self.wx
725 wx = self.wx
719 TIMEOUT = self.TIMEOUT
726 TIMEOUT = self.TIMEOUT
720 def OnInit(self):
727 def OnInit(self):
721 'Create the main window and insert the custom frame'
728 'Create the main window and insert the custom frame'
722 self.agent = TimerAgent(None, self.TIMEOUT)
729 self.agent = TimerAgent(None, self.TIMEOUT)
723 self.agent.Show(self.wx.false)
730 self.agent.Show(self.wx.false)
724 self.agent.StartWork()
731 self.agent.StartWork()
725 return self.wx.true
732 return self.wx.true
726
733
727 self.app = App(redirect=False)
734 self.app = App(redirect=False)
728 self.wx_mainloop(self.app)
735 self.wx_mainloop(self.app)
729 self.join()
736 self.join()
730
737
731
738
732 class IPShellQt(threading.Thread):
739 class IPShellQt(threading.Thread):
733 """Run a Qt event loop in a separate thread.
740 """Run a Qt event loop in a separate thread.
734
741
735 Python commands can be passed to the thread where they will be executed.
742 Python commands can be passed to the thread where they will be executed.
736 This is implemented by periodically checking for passed code using a
743 This is implemented by periodically checking for passed code using a
737 Qt timer / slot."""
744 Qt timer / slot."""
738
745
739 TIMEOUT = 100 # Millisecond interval between timeouts.
746 TIMEOUT = 100 # Millisecond interval between timeouts.
740
747
741 def __init__(self,argv=None,user_ns=None,debug=0,
748 def __init__(self,argv=None,user_ns=None,user_global_ns=None,
742 shell_class=MTInteractiveShell):
749 debug=0,shell_class=MTInteractiveShell):
743
750
744 import qt
751 import qt
745
752
746 class newQApplication:
753 class newQApplication:
747 def __init__( self ):
754 def __init__( self ):
748 self.QApplication = qt.QApplication
755 self.QApplication = qt.QApplication
749
756
750 def __call__( *args, **kwargs ):
757 def __call__( *args, **kwargs ):
751 return qt.qApp
758 return qt.qApp
752
759
753 def exec_loop( *args, **kwargs ):
760 def exec_loop( *args, **kwargs ):
754 pass
761 pass
755
762
756 def __getattr__( self, name ):
763 def __getattr__( self, name ):
757 return getattr( self.QApplication, name )
764 return getattr( self.QApplication, name )
758
765
759 qt.QApplication = newQApplication()
766 qt.QApplication = newQApplication()
760
767
761 # Allows us to use both Tk and QT.
768 # Allows us to use both Tk and QT.
762 self.tk = get_tk()
769 self.tk = get_tk()
763
770
764 self.IP = make_IPython(argv,user_ns=user_ns,debug=debug,
771 self.IP = make_IPython(argv,user_ns=user_ns,
772 user_global_ns=user_global_ns,
773 debug=debug,
765 shell_class=shell_class,
774 shell_class=shell_class,
766 on_kill=[qt.qApp.exit])
775 on_kill=[qt.qApp.exit])
767
776
768 # HACK: slot for banner in self; it will be passed to the mainloop
777 # HACK: slot for banner in self; it will be passed to the mainloop
769 # method only and .run() needs it. The actual value will be set by
778 # method only and .run() needs it. The actual value will be set by
770 # .mainloop().
779 # .mainloop().
771 self._banner = None
780 self._banner = None
772
781
773 threading.Thread.__init__(self)
782 threading.Thread.__init__(self)
774
783
775 def run(self):
784 def run(self):
776 self.IP.mainloop(self._banner)
785 self.IP.mainloop(self._banner)
777 self.IP.kill()
786 self.IP.kill()
778
787
779 def mainloop(self,sys_exit=0,banner=None):
788 def mainloop(self,sys_exit=0,banner=None):
780
789
781 import qt
790 import qt
782
791
783 self._banner = banner
792 self._banner = banner
784
793
785 if qt.QApplication.startingUp():
794 if qt.QApplication.startingUp():
786 a = qt.QApplication.QApplication(sys.argv)
795 a = qt.QApplication.QApplication(sys.argv)
787 self.timer = qt.QTimer()
796 self.timer = qt.QTimer()
788 qt.QObject.connect( self.timer, qt.SIGNAL( 'timeout()' ), self.on_timer )
797 qt.QObject.connect( self.timer, qt.SIGNAL( 'timeout()' ), self.on_timer )
789
798
790 self.start()
799 self.start()
791 self.timer.start( self.TIMEOUT, True )
800 self.timer.start( self.TIMEOUT, True )
792 while True:
801 while True:
793 if self.IP._kill: break
802 if self.IP._kill: break
794 qt.qApp.exec_loop()
803 qt.qApp.exec_loop()
795 self.join()
804 self.join()
796
805
797 def on_timer(self):
806 def on_timer(self):
798 update_tk(self.tk)
807 update_tk(self.tk)
799 result = self.IP.runcode()
808 result = self.IP.runcode()
800 self.timer.start( self.TIMEOUT, True )
809 self.timer.start( self.TIMEOUT, True )
801 return result
810 return result
802
811
803 # A set of matplotlib public IPython shell classes, for single-threaded
812 # A set of matplotlib public IPython shell classes, for single-threaded
804 # (Tk* and FLTK* backends) and multithreaded (GTK* and WX* backends) use.
813 # (Tk* and FLTK* backends) and multithreaded (GTK* and WX* backends) use.
805 class IPShellMatplotlib(IPShell):
814 class IPShellMatplotlib(IPShell):
806 """Subclass IPShell with MatplotlibShell as the internal shell.
815 """Subclass IPShell with MatplotlibShell as the internal shell.
807
816
808 Single-threaded class, meant for the Tk* and FLTK* backends.
817 Single-threaded class, meant for the Tk* and FLTK* backends.
809
818
810 Having this on a separate class simplifies the external driver code."""
819 Having this on a separate class simplifies the external driver code."""
811
820
812 def __init__(self,argv=None,user_ns=None,debug=1):
821 def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
813 IPShell.__init__(self,argv,user_ns,debug,shell_class=MatplotlibShell)
822 IPShell.__init__(self,argv,user_ns,user_global_ns,debug,
823 shell_class=MatplotlibShell)
814
824
815 class IPShellMatplotlibGTK(IPShellGTK):
825 class IPShellMatplotlibGTK(IPShellGTK):
816 """Subclass IPShellGTK with MatplotlibMTShell as the internal shell.
826 """Subclass IPShellGTK with MatplotlibMTShell as the internal shell.
817
827
818 Multi-threaded class, meant for the GTK* backends."""
828 Multi-threaded class, meant for the GTK* backends."""
819
829
820 def __init__(self,argv=None,user_ns=None,debug=1):
830 def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
821 IPShellGTK.__init__(self,argv,user_ns,debug,shell_class=MatplotlibMTShell)
831 IPShellGTK.__init__(self,argv,user_ns,user_global_ns,debug,
832 shell_class=MatplotlibMTShell)
822
833
823 class IPShellMatplotlibWX(IPShellWX):
834 class IPShellMatplotlibWX(IPShellWX):
824 """Subclass IPShellWX with MatplotlibMTShell as the internal shell.
835 """Subclass IPShellWX with MatplotlibMTShell as the internal shell.
825
836
826 Multi-threaded class, meant for the WX* backends."""
837 Multi-threaded class, meant for the WX* backends."""
827
838
828 def __init__(self,argv=None,user_ns=None,debug=1):
839 def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
829 IPShellWX.__init__(self,argv,user_ns,debug,shell_class=MatplotlibMTShell)
840 IPShellWX.__init__(self,argv,user_ns,user_global_ns,debug,
841 shell_class=MatplotlibMTShell)
830
842
831 class IPShellMatplotlibQt(IPShellQt):
843 class IPShellMatplotlibQt(IPShellQt):
832 """Subclass IPShellQt with MatplotlibMTShell as the internal shell.
844 """Subclass IPShellQt with MatplotlibMTShell as the internal shell.
833
845
834 Multi-threaded class, meant for the Qt* backends."""
846 Multi-threaded class, meant for the Qt* backends."""
835
847
836 def __init__(self,argv=None,user_ns=None,debug=1):
848 def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
837 IPShellQt.__init__(self,argv,user_ns,debug,shell_class=MatplotlibMTShell)
849 IPShellQt.__init__(self,argv,user_ns,user_global_ns,debug,
850 shell_class=MatplotlibMTShell)
838
851
839 #-----------------------------------------------------------------------------
852 #-----------------------------------------------------------------------------
840 # Factory functions to actually start the proper thread-aware shell
853 # Factory functions to actually start the proper thread-aware shell
841
854
842 def _matplotlib_shell_class():
855 def _matplotlib_shell_class():
843 """Factory function to handle shell class selection for matplotlib.
856 """Factory function to handle shell class selection for matplotlib.
844
857
845 The proper shell class to use depends on the matplotlib backend, since
858 The proper shell class to use depends on the matplotlib backend, since
846 each backend requires a different threading strategy."""
859 each backend requires a different threading strategy."""
847
860
848 try:
861 try:
849 import matplotlib
862 import matplotlib
850 except ImportError:
863 except ImportError:
851 error('matplotlib could NOT be imported! Starting normal IPython.')
864 error('matplotlib could NOT be imported! Starting normal IPython.')
852 sh_class = IPShell
865 sh_class = IPShell
853 else:
866 else:
854 backend = matplotlib.rcParams['backend']
867 backend = matplotlib.rcParams['backend']
855 if backend.startswith('GTK'):
868 if backend.startswith('GTK'):
856 sh_class = IPShellMatplotlibGTK
869 sh_class = IPShellMatplotlibGTK
857 elif backend.startswith('WX'):
870 elif backend.startswith('WX'):
858 sh_class = IPShellMatplotlibWX
871 sh_class = IPShellMatplotlibWX
859 elif backend.startswith('Qt'):
872 elif backend.startswith('Qt'):
860 sh_class = IPShellMatplotlibQt
873 sh_class = IPShellMatplotlibQt
861 else:
874 else:
862 sh_class = IPShellMatplotlib
875 sh_class = IPShellMatplotlib
863 #print 'Using %s with the %s backend.' % (sh_class,backend) # dbg
876 #print 'Using %s with the %s backend.' % (sh_class,backend) # dbg
864 return sh_class
877 return sh_class
865
878
866 # This is the one which should be called by external code.
879 # This is the one which should be called by external code.
867 def start():
880 def start():
868 """Return a running shell instance, dealing with threading options.
881 """Return a running shell instance, dealing with threading options.
869
882
870 This is a factory function which will instantiate the proper IPython shell
883 This is a factory function which will instantiate the proper IPython shell
871 based on the user's threading choice. Such a selector is needed because
884 based on the user's threading choice. Such a selector is needed because
872 different GUI toolkits require different thread handling details."""
885 different GUI toolkits require different thread handling details."""
873
886
874 global USE_TK
887 global USE_TK
875 # Crude sys.argv hack to extract the threading options.
888 # Crude sys.argv hack to extract the threading options.
876 argv = sys.argv
889 argv = sys.argv
877 if len(argv) > 1:
890 if len(argv) > 1:
878 if len(argv) > 2:
891 if len(argv) > 2:
879 arg2 = argv[2]
892 arg2 = argv[2]
880 if arg2.endswith('-tk'):
893 if arg2.endswith('-tk'):
881 USE_TK = True
894 USE_TK = True
882 arg1 = argv[1]
895 arg1 = argv[1]
883 if arg1.endswith('-gthread'):
896 if arg1.endswith('-gthread'):
884 shell = IPShellGTK
897 shell = IPShellGTK
885 elif arg1.endswith( '-qthread' ):
898 elif arg1.endswith( '-qthread' ):
886 shell = IPShellQt
899 shell = IPShellQt
887 elif arg1.endswith('-wthread'):
900 elif arg1.endswith('-wthread'):
888 shell = IPShellWX
901 shell = IPShellWX
889 elif arg1.endswith('-pylab'):
902 elif arg1.endswith('-pylab'):
890 shell = _matplotlib_shell_class()
903 shell = _matplotlib_shell_class()
891 else:
904 else:
892 shell = IPShell
905 shell = IPShell
893 else:
906 else:
894 shell = IPShell
907 shell = IPShell
895 return shell()
908 return shell()
896
909
897 # Some aliases for backwards compatibility
910 # Some aliases for backwards compatibility
898 IPythonShell = IPShell
911 IPythonShell = IPShell
899 IPythonShellEmbed = IPShellEmbed
912 IPythonShellEmbed = IPShellEmbed
900 #************************ End of file <Shell.py> ***************************
913 #************************ End of file <Shell.py> ***************************
@@ -1,523 +1,526 b''
1 """Word completion for IPython.
1 """Word completion for IPython.
2
2
3 This module is a fork of the rlcompleter module in the Python standard
3 This module is a fork of the rlcompleter module in the Python standard
4 library. The original enhancements made to rlcompleter have been sent
4 library. The original enhancements made to rlcompleter have been sent
5 upstream and were accepted as of Python 2.3, but we need a lot more
5 upstream and were accepted as of Python 2.3, but we need a lot more
6 functionality specific to IPython, so this module will continue to live as an
6 functionality specific to IPython, so this module will continue to live as an
7 IPython-specific utility.
7 IPython-specific utility.
8
8
9 ---------------------------------------------------------------------------
9 ---------------------------------------------------------------------------
10 Original rlcompleter documentation:
10 Original rlcompleter documentation:
11
11
12 This requires the latest extension to the readline module (the
12 This requires the latest extension to the readline module (the
13 completes keywords, built-ins and globals in __main__; when completing
13 completes keywords, built-ins and globals in __main__; when completing
14 NAME.NAME..., it evaluates (!) the expression up to the last dot and
14 NAME.NAME..., it evaluates (!) the expression up to the last dot and
15 completes its attributes.
15 completes its attributes.
16
16
17 It's very cool to do "import string" type "string.", hit the
17 It's very cool to do "import string" type "string.", hit the
18 completion key (twice), and see the list of names defined by the
18 completion key (twice), and see the list of names defined by the
19 string module!
19 string module!
20
20
21 Tip: to use the tab key as the completion key, call
21 Tip: to use the tab key as the completion key, call
22
22
23 readline.parse_and_bind("tab: complete")
23 readline.parse_and_bind("tab: complete")
24
24
25 Notes:
25 Notes:
26
26
27 - Exceptions raised by the completer function are *ignored* (and
27 - Exceptions raised by the completer function are *ignored* (and
28 generally cause the completion to fail). This is a feature -- since
28 generally cause the completion to fail). This is a feature -- since
29 readline sets the tty device in raw (or cbreak) mode, printing a
29 readline sets the tty device in raw (or cbreak) mode, printing a
30 traceback wouldn't work well without some complicated hoopla to save,
30 traceback wouldn't work well without some complicated hoopla to save,
31 reset and restore the tty state.
31 reset and restore the tty state.
32
32
33 - The evaluation of the NAME.NAME... form may cause arbitrary
33 - The evaluation of the NAME.NAME... form may cause arbitrary
34 application defined code to be executed if an object with a
34 application defined code to be executed if an object with a
35 __getattr__ hook is found. Since it is the responsibility of the
35 __getattr__ hook is found. Since it is the responsibility of the
36 application (or the user) to enable this feature, I consider this an
36 application (or the user) to enable this feature, I consider this an
37 acceptable risk. More complicated expressions (e.g. function calls or
37 acceptable risk. More complicated expressions (e.g. function calls or
38 indexing operations) are *not* evaluated.
38 indexing operations) are *not* evaluated.
39
39
40 - GNU readline is also used by the built-in functions input() and
40 - GNU readline is also used by the built-in functions input() and
41 raw_input(), and thus these also benefit/suffer from the completer
41 raw_input(), and thus these also benefit/suffer from the completer
42 features. Clearly an interactive application can benefit by
42 features. Clearly an interactive application can benefit by
43 specifying its own completer function and using raw_input() for all
43 specifying its own completer function and using raw_input() for all
44 its input.
44 its input.
45
45
46 - When the original stdin is not a tty device, GNU readline is never
46 - When the original stdin is not a tty device, GNU readline is never
47 used, and this module (and the readline module) are silently inactive.
47 used, and this module (and the readline module) are silently inactive.
48
48
49 """
49 """
50
50
51 #*****************************************************************************
51 #*****************************************************************************
52 #
52 #
53 # Since this file is essentially a minimally modified copy of the rlcompleter
53 # Since this file is essentially a minimally modified copy of the rlcompleter
54 # module which is part of the standard Python distribution, I assume that the
54 # module which is part of the standard Python distribution, I assume that the
55 # proper procedure is to maintain its copyright as belonging to the Python
55 # proper procedure is to maintain its copyright as belonging to the Python
56 # Software Foundation (in addition to my own, for all new code).
56 # Software Foundation (in addition to my own, for all new code).
57 #
57 #
58 # Copyright (C) 2001 Python Software Foundation, www.python.org
58 # Copyright (C) 2001 Python Software Foundation, www.python.org
59 # Copyright (C) 2001-2005 Fernando Perez. <fperez@colorado.edu>
59 # Copyright (C) 2001-2005 Fernando Perez. <fperez@colorado.edu>
60 #
60 #
61 # Distributed under the terms of the BSD License. The full license is in
61 # Distributed under the terms of the BSD License. The full license is in
62 # the file COPYING, distributed as part of this software.
62 # the file COPYING, distributed as part of this software.
63 #
63 #
64 #*****************************************************************************
64 #*****************************************************************************
65
65
66 import __builtin__
66 import __builtin__
67 import __main__
67 import __main__
68 import glob
68 import glob
69 import keyword
69 import keyword
70 import os
70 import os
71 import re
71 import re
72 import readline
72 import readline
73 import sys
73 import sys
74 import types
74 import types
75
75
76 from IPython.genutils import shlex_split
76 from IPython.genutils import shlex_split
77
77
78 __all__ = ['Completer','IPCompleter']
78 __all__ = ['Completer','IPCompleter']
79
79
80 def get_class_members(cls):
80 def get_class_members(cls):
81 ret = dir(cls)
81 ret = dir(cls)
82 if hasattr(cls,'__bases__'):
82 if hasattr(cls,'__bases__'):
83 for base in cls.__bases__:
83 for base in cls.__bases__:
84 ret.extend(get_class_members(base))
84 ret.extend(get_class_members(base))
85 return ret
85 return ret
86
86
87 class Completer:
87 class Completer:
88 def __init__(self,namespace=None,global_namespace=None):
88 def __init__(self,namespace=None,global_namespace=None):
89 """Create a new completer for the command line.
89 """Create a new completer for the command line.
90
90
91 Completer([namespace,global_namespace]) -> completer instance.
91 Completer([namespace,global_namespace]) -> completer instance.
92
92
93 If unspecified, the default namespace where completions are performed
93 If unspecified, the default namespace where completions are performed
94 is __main__ (technically, __main__.__dict__). Namespaces should be
94 is __main__ (technically, __main__.__dict__). Namespaces should be
95 given as dictionaries.
95 given as dictionaries.
96
96
97 An optional second namespace can be given. This allows the completer
97 An optional second namespace can be given. This allows the completer
98 to handle cases where both the local and global scopes need to be
98 to handle cases where both the local and global scopes need to be
99 distinguished.
99 distinguished.
100
100
101 Completer instances should be used as the completion mechanism of
101 Completer instances should be used as the completion mechanism of
102 readline via the set_completer() call:
102 readline via the set_completer() call:
103
103
104 readline.set_completer(Completer(my_namespace).complete)
104 readline.set_completer(Completer(my_namespace).complete)
105 """
105 """
106
107 if namespace and type(namespace) != types.DictType:
108 raise TypeError,'namespace must be a dictionary'
109
106
110 if global_namespace and type(global_namespace) != types.DictType:
107 # some minimal strict typechecks. For some core data structures, I
111 raise TypeError,'global_namespace must be a dictionary'
108 # want actual basic python types, not just anything that looks like
109 # one. This is especially true for namespaces.
110 for ns in (namespace,global_namespace):
111 if ns is not None and type(ns) != types.DictType:
112 raise TypeError,'namespace must be a dictionary'
112
113
113 # Don't bind to namespace quite yet, but flag whether the user wants a
114 # Don't bind to namespace quite yet, but flag whether the user wants a
114 # specific namespace or to use __main__.__dict__. This will allow us
115 # specific namespace or to use __main__.__dict__. This will allow us
115 # to bind to __main__.__dict__ at completion time, not now.
116 # to bind to __main__.__dict__ at completion time, not now.
116 if namespace is None:
117 if namespace is None:
117 self.use_main_ns = 1
118 self.use_main_ns = 1
118 else:
119 else:
119 self.use_main_ns = 0
120 self.use_main_ns = 0
120 self.namespace = namespace
121 self.namespace = namespace
121
122
122 # The global namespace, if given, can be bound directly
123 # The global namespace, if given, can be bound directly
123 if global_namespace is None:
124 if global_namespace is None:
124 self.global_namespace = {}
125 self.global_namespace = {}
125 else:
126 else:
126 self.global_namespace = global_namespace
127 self.global_namespace = global_namespace
127
128
128 def complete(self, text, state):
129 def complete(self, text, state):
129 """Return the next possible completion for 'text'.
130 """Return the next possible completion for 'text'.
130
131
131 This is called successively with state == 0, 1, 2, ... until it
132 This is called successively with state == 0, 1, 2, ... until it
132 returns None. The completion should begin with 'text'.
133 returns None. The completion should begin with 'text'.
133
134
134 """
135 """
135 if self.use_main_ns:
136 if self.use_main_ns:
136 self.namespace = __main__.__dict__
137 self.namespace = __main__.__dict__
137
138
138 if state == 0:
139 if state == 0:
139 if "." in text:
140 if "." in text:
140 self.matches = self.attr_matches(text)
141 self.matches = self.attr_matches(text)
141 else:
142 else:
142 self.matches = self.global_matches(text)
143 self.matches = self.global_matches(text)
143 try:
144 try:
144 return self.matches[state]
145 return self.matches[state]
145 except IndexError:
146 except IndexError:
146 return None
147 return None
147
148
148 def global_matches(self, text):
149 def global_matches(self, text):
149 """Compute matches when text is a simple name.
150 """Compute matches when text is a simple name.
150
151
151 Return a list of all keywords, built-in functions and names currently
152 Return a list of all keywords, built-in functions and names currently
152 defined in self.namespace or self.global_namespace that match.
153 defined in self.namespace or self.global_namespace that match.
153
154
154 """
155 """
155 matches = []
156 matches = []
156 match_append = matches.append
157 match_append = matches.append
157 n = len(text)
158 n = len(text)
158 for lst in [keyword.kwlist,
159 for lst in [keyword.kwlist,
159 __builtin__.__dict__.keys(),
160 __builtin__.__dict__.keys(),
160 self.namespace.keys(),
161 self.namespace.keys(),
161 self.global_namespace.keys()]:
162 self.global_namespace.keys()]:
162 for word in lst:
163 for word in lst:
163 if word[:n] == text and word != "__builtins__":
164 if word[:n] == text and word != "__builtins__":
164 match_append(word)
165 match_append(word)
165 return matches
166 return matches
166
167
167 def attr_matches(self, text):
168 def attr_matches(self, text):
168 """Compute matches when text contains a dot.
169 """Compute matches when text contains a dot.
169
170
170 Assuming the text is of the form NAME.NAME....[NAME], and is
171 Assuming the text is of the form NAME.NAME....[NAME], and is
171 evaluatable in self.namespace or self.global_namespace, it will be
172 evaluatable in self.namespace or self.global_namespace, it will be
172 evaluated and its attributes (as revealed by dir()) are used as
173 evaluated and its attributes (as revealed by dir()) are used as
173 possible completions. (For class instances, class members are are
174 possible completions. (For class instances, class members are are
174 also considered.)
175 also considered.)
175
176
176 WARNING: this can still invoke arbitrary C code, if an object
177 WARNING: this can still invoke arbitrary C code, if an object
177 with a __getattr__ hook is evaluated.
178 with a __getattr__ hook is evaluated.
178
179
179 """
180 """
180 import re
181 import re
181
182
182 # Another option, seems to work great. Catches things like ''.<tab>
183 # Another option, seems to work great. Catches things like ''.<tab>
183 m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
184 m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
184
185
185 if not m:
186 if not m:
186 return []
187 return []
187 expr, attr = m.group(1, 3)
188 expr, attr = m.group(1, 3)
188 try:
189 try:
189 object = eval(expr, self.namespace)
190 object = eval(expr, self.namespace)
190 except:
191 except:
191 object = eval(expr, self.global_namespace)
192 object = eval(expr, self.global_namespace)
192 words = [w for w in dir(object) if isinstance(w, basestring)]
193 words = [w for w in dir(object) if isinstance(w, basestring)]
193 if hasattr(object,'__class__'):
194 if hasattr(object,'__class__'):
194 words.append('__class__')
195 words.append('__class__')
195 words.extend(get_class_members(object.__class__))
196 words.extend(get_class_members(object.__class__))
196 n = len(attr)
197 n = len(attr)
197 matches = []
198 matches = []
198 for word in words:
199 for word in words:
199 if word[:n] == attr and word != "__builtins__":
200 if word[:n] == attr and word != "__builtins__":
200 matches.append("%s.%s" % (expr, word))
201 matches.append("%s.%s" % (expr, word))
201 return matches
202 return matches
202
203
203 class IPCompleter(Completer):
204 class IPCompleter(Completer):
204 """Extension of the completer class with IPython-specific features"""
205 """Extension of the completer class with IPython-specific features"""
205
206
206 def __init__(self,shell,namespace=None,global_namespace=None,
207 def __init__(self,shell,namespace=None,global_namespace=None,
207 omit__names=0,alias_table=None):
208 omit__names=0,alias_table=None):
208 """IPCompleter() -> completer
209 """IPCompleter() -> completer
209
210
210 Return a completer object suitable for use by the readline library
211 Return a completer object suitable for use by the readline library
211 via readline.set_completer().
212 via readline.set_completer().
212
213
213 Inputs:
214 Inputs:
214
215
215 - shell: a pointer to the ipython shell itself. This is needed
216 - shell: a pointer to the ipython shell itself. This is needed
216 because this completer knows about magic functions, and those can
217 because this completer knows about magic functions, and those can
217 only be accessed via the ipython instance.
218 only be accessed via the ipython instance.
218
219
219 - namespace: an optional dict where completions are performed.
220 - namespace: an optional dict where completions are performed.
220
221
221 - global_namespace: secondary optional dict for completions, to
222 - global_namespace: secondary optional dict for completions, to
222 handle cases (such as IPython embedded inside functions) where
223 handle cases (such as IPython embedded inside functions) where
223 both Python scopes are visible.
224 both Python scopes are visible.
224
225
225 - The optional omit__names parameter sets the completer to omit the
226 - The optional omit__names parameter sets the completer to omit the
226 'magic' names (__magicname__) for python objects unless the text
227 'magic' names (__magicname__) for python objects unless the text
227 to be completed explicitly starts with one or more underscores.
228 to be completed explicitly starts with one or more underscores.
228
229
229 - If alias_table is supplied, it should be a dictionary of aliases
230 - If alias_table is supplied, it should be a dictionary of aliases
230 to complete. """
231 to complete. """
231
232
232 Completer.__init__(self,namespace,global_namespace)
233 Completer.__init__(self,namespace,global_namespace)
233 self.magic_prefix = shell.name+'.magic_'
234 self.magic_prefix = shell.name+'.magic_'
234 self.magic_escape = shell.ESC_MAGIC
235 self.magic_escape = shell.ESC_MAGIC
235 self.readline = readline
236 self.readline = readline
236 delims = self.readline.get_completer_delims()
237 delims = self.readline.get_completer_delims()
237 delims = delims.replace(self.magic_escape,'')
238 delims = delims.replace(self.magic_escape,'')
238 self.readline.set_completer_delims(delims)
239 self.readline.set_completer_delims(delims)
239 self.get_line_buffer = self.readline.get_line_buffer
240 self.get_line_buffer = self.readline.get_line_buffer
240 self.omit__names = omit__names
241 self.omit__names = omit__names
241 self.merge_completions = shell.rc.readline_merge_completions
242 self.merge_completions = shell.rc.readline_merge_completions
242
243
243 if alias_table is None:
244 if alias_table is None:
244 alias_table = {}
245 alias_table = {}
245 self.alias_table = alias_table
246 self.alias_table = alias_table
246 # Regexp to split filenames with spaces in them
247 # Regexp to split filenames with spaces in them
247 self.space_name_re = re.compile(r'([^\\] )')
248 self.space_name_re = re.compile(r'([^\\] )')
248 # Hold a local ref. to glob.glob for speed
249 # Hold a local ref. to glob.glob for speed
249 self.glob = glob.glob
250 self.glob = glob.glob
250 # Special handling of backslashes needed in win32 platforms
251 # Special handling of backslashes needed in win32 platforms
251 if sys.platform == "win32":
252 if sys.platform == "win32":
252 self.clean_glob = self._clean_glob_win32
253 self.clean_glob = self._clean_glob_win32
253 else:
254 else:
254 self.clean_glob = self._clean_glob
255 self.clean_glob = self._clean_glob
255 self.matchers = [self.python_matches,
256 self.matchers = [self.python_matches,
256 self.file_matches,
257 self.file_matches,
257 self.alias_matches,
258 self.alias_matches,
258 self.python_func_kw_matches]
259 self.python_func_kw_matches]
259
260
260 # Code contributed by Alex Schmolck, for ipython/emacs integration
261 # Code contributed by Alex Schmolck, for ipython/emacs integration
261 def all_completions(self, text):
262 def all_completions(self, text):
262 """Return all possible completions for the benefit of emacs."""
263 """Return all possible completions for the benefit of emacs."""
263
264
264 completions = []
265 completions = []
265 comp_append = completions.append
266 comp_append = completions.append
266 try:
267 try:
267 for i in xrange(sys.maxint):
268 for i in xrange(sys.maxint):
268 res = self.complete(text, i)
269 res = self.complete(text, i)
269
270
270 if not res: break
271 if not res: break
271
272
272 comp_append(res)
273 comp_append(res)
273 #XXX workaround for ``notDefined.<tab>``
274 #XXX workaround for ``notDefined.<tab>``
274 except NameError:
275 except NameError:
275 pass
276 pass
276 return completions
277 return completions
277 # /end Alex Schmolck code.
278 # /end Alex Schmolck code.
278
279
279 def _clean_glob(self,text):
280 def _clean_glob(self,text):
280 return self.glob("%s*" % text)
281 return self.glob("%s*" % text)
281
282
282 def _clean_glob_win32(self,text):
283 def _clean_glob_win32(self,text):
283 return [f.replace("\\","/")
284 return [f.replace("\\","/")
284 for f in self.glob("%s*" % text)]
285 for f in self.glob("%s*" % text)]
285
286
286 def file_matches(self, text):
287 def file_matches(self, text):
287 """Match filneames, expanding ~USER type strings.
288 """Match filneames, expanding ~USER type strings.
288
289
289 Most of the seemingly convoluted logic in this completer is an
290 Most of the seemingly convoluted logic in this completer is an
290 attempt to handle filenames with spaces in them. And yet it's not
291 attempt to handle filenames with spaces in them. And yet it's not
291 quite perfect, because Python's readline doesn't expose all of the
292 quite perfect, because Python's readline doesn't expose all of the
292 GNU readline details needed for this to be done correctly.
293 GNU readline details needed for this to be done correctly.
293
294
294 For a filename with a space in it, the printed completions will be
295 For a filename with a space in it, the printed completions will be
295 only the parts after what's already been typed (instead of the
296 only the parts after what's already been typed (instead of the
296 full completions, as is normally done). I don't think with the
297 full completions, as is normally done). I don't think with the
297 current (as of Python 2.3) Python readline it's possible to do
298 current (as of Python 2.3) Python readline it's possible to do
298 better."""
299 better."""
299
300
300 #print 'Completer->file_matches: <%s>' % text # dbg
301 #print 'Completer->file_matches: <%s>' % text # dbg
301
302
302 # chars that require escaping with backslash - i.e. chars
303 # chars that require escaping with backslash - i.e. chars
303 # that readline treats incorrectly as delimiters, but we
304 # that readline treats incorrectly as delimiters, but we
304 # don't want to treat as delimiters in filename matching
305 # don't want to treat as delimiters in filename matching
305 # when escaped with backslash
306 # when escaped with backslash
306
307
307 protectables = ' ()[]{}'
308 protectables = ' ()[]{}'
308
309
309 def protect_filename(s):
310 def protect_filename(s):
310 return "".join([(ch in protectables and '\\' + ch or ch)
311 return "".join([(ch in protectables and '\\' + ch or ch)
311 for ch in s])
312 for ch in s])
312
313
313 lbuf = self.get_line_buffer()[:self.readline.get_endidx()]
314 lbuf = self.get_line_buffer()[:self.readline.get_endidx()]
314 open_quotes = 0 # track strings with open quotes
315 open_quotes = 0 # track strings with open quotes
315 try:
316 try:
316 lsplit = shlex_split(lbuf)[-1]
317 lsplit = shlex_split(lbuf)[-1]
317 except ValueError:
318 except ValueError:
318 # typically an unmatched ", or backslash without escaped char.
319 # typically an unmatched ", or backslash without escaped char.
319 if lbuf.count('"')==1:
320 if lbuf.count('"')==1:
320 open_quotes = 1
321 open_quotes = 1
321 lsplit = lbuf.split('"')[-1]
322 lsplit = lbuf.split('"')[-1]
322 elif lbuf.count("'")==1:
323 elif lbuf.count("'")==1:
323 open_quotes = 1
324 open_quotes = 1
324 lsplit = lbuf.split("'")[-1]
325 lsplit = lbuf.split("'")[-1]
325 else:
326 else:
326 return None
327 return None
327 except IndexError:
328 except IndexError:
328 # tab pressed on empty line
329 # tab pressed on empty line
329 lsplit = ""
330 lsplit = ""
330
331
331 if lsplit != protect_filename(lsplit):
332 if lsplit != protect_filename(lsplit):
332 # if protectables are found, do matching on the whole escaped
333 # if protectables are found, do matching on the whole escaped
333 # name
334 # name
334 has_protectables = 1
335 has_protectables = 1
335 text0,text = text,lsplit
336 text0,text = text,lsplit
336 else:
337 else:
337 has_protectables = 0
338 has_protectables = 0
338 text = os.path.expanduser(text)
339 text = os.path.expanduser(text)
339
340
340 if text == "":
341 if text == "":
341 return [protect_filename(f) for f in self.glob("*")]
342 return [protect_filename(f) for f in self.glob("*")]
342
343
343 m0 = self.clean_glob(text.replace('\\',''))
344 m0 = self.clean_glob(text.replace('\\',''))
344 if has_protectables:
345 if has_protectables:
345 # If we had protectables, we need to revert our changes to the
346 # If we had protectables, we need to revert our changes to the
346 # beginning of filename so that we don't double-write the part
347 # beginning of filename so that we don't double-write the part
347 # of the filename we have so far
348 # of the filename we have so far
348 len_lsplit = len(lsplit)
349 len_lsplit = len(lsplit)
349 matches = [text0 + protect_filename(f[len_lsplit:]) for f in m0]
350 matches = [text0 + protect_filename(f[len_lsplit:]) for f in m0]
350 else:
351 else:
351 if open_quotes:
352 if open_quotes:
352 # if we have a string with an open quote, we don't need to
353 # if we have a string with an open quote, we don't need to
353 # protect the names at all (and we _shouldn't_, as it
354 # protect the names at all (and we _shouldn't_, as it
354 # would cause bugs when the filesystem call is made).
355 # would cause bugs when the filesystem call is made).
355 matches = m0
356 matches = m0
356 else:
357 else:
357 matches = [protect_filename(f) for f in m0]
358 matches = [protect_filename(f) for f in m0]
358 if len(matches) == 1 and os.path.isdir(matches[0]):
359 if len(matches) == 1 and os.path.isdir(matches[0]):
359 # Takes care of links to directories also. Use '/'
360 # Takes care of links to directories also. Use '/'
360 # explicitly, even under Windows, so that name completions
361 # explicitly, even under Windows, so that name completions
361 # don't end up escaped.
362 # don't end up escaped.
362 matches[0] += '/'
363 matches[0] += '/'
363 return matches
364 return matches
364
365
365 def alias_matches(self, text):
366 def alias_matches(self, text):
366 """Match internal system aliases"""
367 """Match internal system aliases"""
367 #print 'Completer->alias_matches:',text # dbg
368 #print 'Completer->alias_matches:',text # dbg
368 text = os.path.expanduser(text)
369 text = os.path.expanduser(text)
369 aliases = self.alias_table.keys()
370 aliases = self.alias_table.keys()
370 if text == "":
371 if text == "":
371 return aliases
372 return aliases
372 else:
373 else:
373 return [alias for alias in aliases if alias.startswith(text)]
374 return [alias for alias in aliases if alias.startswith(text)]
374
375
375 def python_matches(self,text):
376 def python_matches(self,text):
376 """Match attributes or global python names"""
377 """Match attributes or global python names"""
377 #print 'Completer->python_matches' # dbg
378 #print 'Completer->python_matches' # dbg
378 if "." in text:
379 if "." in text:
379 try:
380 try:
380 matches = self.attr_matches(text)
381 matches = self.attr_matches(text)
381 if text.endswith('.') and self.omit__names:
382 if text.endswith('.') and self.omit__names:
382 if self.omit__names == 1:
383 if self.omit__names == 1:
383 # true if txt is _not_ a __ name, false otherwise:
384 # true if txt is _not_ a __ name, false otherwise:
384 no__name = (lambda txt:
385 no__name = (lambda txt:
385 re.match(r'.*\.__.*?__',txt) is None)
386 re.match(r'.*\.__.*?__',txt) is None)
386 else:
387 else:
387 # true if txt is _not_ a _ name, false otherwise:
388 # true if txt is _not_ a _ name, false otherwise:
388 no__name = (lambda txt:
389 no__name = (lambda txt:
389 re.match(r'.*\._.*?',txt) is None)
390 re.match(r'.*\._.*?',txt) is None)
390 matches = filter(no__name, matches)
391 matches = filter(no__name, matches)
391 except NameError:
392 except NameError:
392 # catches <undefined attributes>.<tab>
393 # catches <undefined attributes>.<tab>
393 matches = []
394 matches = []
394 else:
395 else:
395 matches = self.global_matches(text)
396 matches = self.global_matches(text)
396 # this is so completion finds magics when automagic is on:
397 # this is so completion finds magics when automagic is on:
397 if matches == [] and not text.startswith(os.sep):
398 if matches == [] and not text.startswith(os.sep):
398 matches = self.attr_matches(self.magic_prefix+text)
399 matches = self.attr_matches(self.magic_prefix+text)
399 return matches
400 return matches
400
401
401 def _default_arguments(self, obj):
402 def _default_arguments(self, obj):
402 """Return the list of default arguments of obj if it is callable,
403 """Return the list of default arguments of obj if it is callable,
403 or empty list otherwise."""
404 or empty list otherwise."""
404
405
405 if not (inspect.isfunction(obj) or inspect.ismethod(obj)):
406 if not (inspect.isfunction(obj) or inspect.ismethod(obj)):
406 # for classes, check for __init__,__new__
407 # for classes, check for __init__,__new__
407 if inspect.isclass(obj):
408 if inspect.isclass(obj):
408 obj = (getattr(obj,'__init__',None) or
409 obj = (getattr(obj,'__init__',None) or
409 getattr(obj,'__new__',None))
410 getattr(obj,'__new__',None))
410 # for all others, check if they are __call__able
411 # for all others, check if they are __call__able
411 elif hasattr(obj, '__call__'):
412 elif hasattr(obj, '__call__'):
412 obj = obj.__call__
413 obj = obj.__call__
413 # XXX: is there a way to handle the builtins ?
414 # XXX: is there a way to handle the builtins ?
414 try:
415 try:
415 args,_,_1,defaults = inspect.getargspec(obj)
416 args,_,_1,defaults = inspect.getargspec(obj)
416 if defaults:
417 if defaults:
417 return args[-len(defaults):]
418 return args[-len(defaults):]
418 except TypeError: pass
419 except TypeError: pass
419 return []
420 return []
420
421
421 def python_func_kw_matches(self,text):
422 def python_func_kw_matches(self,text):
422 """Match named parameters (kwargs) of the last open function"""
423 """Match named parameters (kwargs) of the last open function"""
423
424
424 if "." in text: # a parameter cannot be dotted
425 if "." in text: # a parameter cannot be dotted
425 return []
426 return []
426 try: regexp = self.__funcParamsRegex
427 try: regexp = self.__funcParamsRegex
427 except AttributeError:
428 except AttributeError:
428 regexp = self.__funcParamsRegex = re.compile(r'''
429 regexp = self.__funcParamsRegex = re.compile(r'''
429 '.*?' | # single quoted strings or
430 '.*?' | # single quoted strings or
430 ".*?" | # double quoted strings or
431 ".*?" | # double quoted strings or
431 \w+ | # identifier
432 \w+ | # identifier
432 \S # other characters
433 \S # other characters
433 ''', re.VERBOSE | re.DOTALL)
434 ''', re.VERBOSE | re.DOTALL)
434 # 1. find the nearest identifier that comes before an unclosed
435 # 1. find the nearest identifier that comes before an unclosed
435 # parenthesis e.g. for "foo (1+bar(x), pa", the candidate is "foo"
436 # parenthesis e.g. for "foo (1+bar(x), pa", the candidate is "foo"
436 tokens = regexp.findall(self.get_line_buffer())
437 tokens = regexp.findall(self.get_line_buffer())
437 tokens.reverse()
438 tokens.reverse()
438 iterTokens = iter(tokens); openPar = 0
439 iterTokens = iter(tokens); openPar = 0
439 for token in iterTokens:
440 for token in iterTokens:
440 if token == ')':
441 if token == ')':
441 openPar -= 1
442 openPar -= 1
442 elif token == '(':
443 elif token == '(':
443 openPar += 1
444 openPar += 1
444 if openPar > 0:
445 if openPar > 0:
445 # found the last unclosed parenthesis
446 # found the last unclosed parenthesis
446 break
447 break
447 else:
448 else:
448 return []
449 return []
449 # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
450 # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
450 ids = []
451 ids = []
451 isId = re.compile(r'\w+$').match
452 isId = re.compile(r'\w+$').match
452 while True:
453 while True:
453 try:
454 try:
454 ids.append(iterTokens.next())
455 ids.append(iterTokens.next())
455 if not isId(ids[-1]):
456 if not isId(ids[-1]):
456 ids.pop(); break
457 ids.pop(); break
457 if not iterTokens.next() == '.':
458 if not iterTokens.next() == '.':
458 break
459 break
459 except StopIteration:
460 except StopIteration:
460 break
461 break
461 # lookup the candidate callable matches either using global_matches
462 # lookup the candidate callable matches either using global_matches
462 # or attr_matches for dotted names
463 # or attr_matches for dotted names
463 if len(ids) == 1:
464 if len(ids) == 1:
464 callableMatches = self.global_matches(ids[0])
465 callableMatches = self.global_matches(ids[0])
465 else:
466 else:
466 callableMatches = self.attr_matches('.'.join(ids[::-1]))
467 callableMatches = self.attr_matches('.'.join(ids[::-1]))
467 argMatches = []
468 argMatches = []
468 for callableMatch in callableMatches:
469 for callableMatch in callableMatches:
469 try: namedArgs = self._default_arguments(eval(callableMatch,
470 try: namedArgs = self._default_arguments(eval(callableMatch,
470 self.namespace))
471 self.namespace))
471 except: continue
472 except: continue
472 for namedArg in namedArgs:
473 for namedArg in namedArgs:
473 if namedArg.startswith(text):
474 if namedArg.startswith(text):
474 argMatches.append("%s=" %namedArg)
475 argMatches.append("%s=" %namedArg)
475 return argMatches
476 return argMatches
476
477
477 def complete(self, text, state):
478 def complete(self, text, state):
478 """Return the next possible completion for 'text'.
479 """Return the next possible completion for 'text'.
479
480
480 This is called successively with state == 0, 1, 2, ... until it
481 This is called successively with state == 0, 1, 2, ... until it
481 returns None. The completion should begin with 'text'. """
482 returns None. The completion should begin with 'text'. """
482
483
483 #print '\n*** COMPLETE: <%s> (%s)' % (text,state) # dbg
484 #print '\n*** COMPLETE: <%s> (%s)' % (text,state) # dbg
484
485
485 # if there is only a tab on a line with only whitespace, instead
486 # if there is only a tab on a line with only whitespace, instead
486 # of the mostly useless 'do you want to see all million
487 # of the mostly useless 'do you want to see all million
487 # completions' message, just do the right thing and give the user
488 # completions' message, just do the right thing and give the user
488 # his tab! Incidentally, this enables pasting of tabbed text from
489 # his tab! Incidentally, this enables pasting of tabbed text from
489 # an editor (as long as autoindent is off).
490 # an editor (as long as autoindent is off).
490 if not self.get_line_buffer().strip():
491 if not self.get_line_buffer().strip():
491 self.readline.insert_text('\t')
492 self.readline.insert_text('\t')
492 return None
493 return None
493
494
494 magic_escape = self.magic_escape
495 magic_escape = self.magic_escape
495 magic_prefix = self.magic_prefix
496 magic_prefix = self.magic_prefix
496
497
497 try:
498 try:
498 if text.startswith(magic_escape):
499 if text.startswith(magic_escape):
499 text = text.replace(magic_escape,magic_prefix)
500 text = text.replace(magic_escape,magic_prefix)
500 elif text.startswith('~'):
501 elif text.startswith('~'):
501 text = os.path.expanduser(text)
502 text = os.path.expanduser(text)
502 if state == 0:
503 if state == 0:
503 # Extend the list of completions with the results of each
504 # Extend the list of completions with the results of each
504 # matcher, so we return results to the user from all
505 # matcher, so we return results to the user from all
505 # namespaces.
506 # namespaces.
506 if self.merge_completions:
507 if self.merge_completions:
507 self.matches = []
508 self.matches = []
508 for matcher in self.matchers:
509 for matcher in self.matchers:
509 self.matches.extend(matcher(text))
510 self.matches.extend(matcher(text))
510 else:
511 else:
511 for matcher in self.matchers:
512 for matcher in self.matchers:
512 self.matches = matcher(text)
513 self.matches = matcher(text)
513 if self.matches:
514 if self.matches:
514 break
515 break
515
516
516 try:
517 try:
517 return self.matches[state].replace(magic_prefix,magic_escape)
518 return self.matches[state].replace(magic_prefix,magic_escape)
518 except IndexError:
519 except IndexError:
519 return None
520 return None
520 except:
521 except:
521 #import traceback; traceback.print_exc() # dbg
522 #from IPython.ultraTB import AutoFormattedTB; # dbg
523 #tb=AutoFormattedTB('Verbose');tb() #dbg
524
522 # If completion fails, don't annoy the user.
525 # If completion fails, don't annoy the user.
523 return None
526 return None
@@ -1,1961 +1,1968 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """
2 """
3 IPython -- An enhanced Interactive Python
3 IPython -- An enhanced Interactive Python
4
4
5 Requires Python 2.1 or newer.
5 Requires Python 2.1 or newer.
6
6
7 This file contains all the classes and helper functions specific to IPython.
7 This file contains all the classes and helper functions specific to IPython.
8
8
9 $Id: iplib.py 963 2005-12-28 19:21:29Z fperez $
9 $Id: iplib.py 964 2005-12-28 21:03:01Z fperez $
10 """
10 """
11
11
12 #*****************************************************************************
12 #*****************************************************************************
13 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
13 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
14 # Copyright (C) 2001-2005 Fernando Perez. <fperez@colorado.edu>
14 # Copyright (C) 2001-2005 Fernando Perez. <fperez@colorado.edu>
15 #
15 #
16 # Distributed under the terms of the BSD License. The full license is in
16 # Distributed under the terms of the BSD License. The full license is in
17 # the file COPYING, distributed as part of this software.
17 # the file COPYING, distributed as part of this software.
18 #
18 #
19 # Note: this code originally subclassed code.InteractiveConsole from the
19 # Note: this code originally subclassed code.InteractiveConsole from the
20 # Python standard library. Over time, all of that class has been copied
20 # Python standard library. Over time, all of that class has been copied
21 # verbatim here for modifications which could not be accomplished by
21 # verbatim here for modifications which could not be accomplished by
22 # subclassing. At this point, there are no dependencies at all on the code
22 # subclassing. At this point, there are no dependencies at all on the code
23 # module anymore (it is not even imported). The Python License (sec. 2)
23 # module anymore (it is not even imported). The Python License (sec. 2)
24 # allows for this, but it's always nice to acknowledge credit where credit is
24 # allows for this, but it's always nice to acknowledge credit where credit is
25 # due.
25 # due.
26 #*****************************************************************************
26 #*****************************************************************************
27
27
28 #****************************************************************************
28 #****************************************************************************
29 # Modules and globals
29 # Modules and globals
30
30
31 from __future__ import generators # for 2.2 backwards-compatibility
31 from __future__ import generators # for 2.2 backwards-compatibility
32
32
33 from IPython import Release
33 from IPython import Release
34 __author__ = '%s <%s>\n%s <%s>' % \
34 __author__ = '%s <%s>\n%s <%s>' % \
35 ( Release.authors['Janko'] + Release.authors['Fernando'] )
35 ( Release.authors['Janko'] + Release.authors['Fernando'] )
36 __license__ = Release.license
36 __license__ = Release.license
37 __version__ = Release.version
37 __version__ = Release.version
38
38
39 # Python standard modules
39 # Python standard modules
40 import __main__
40 import __main__
41 import __builtin__
41 import __builtin__
42 import StringIO
42 import StringIO
43 import bdb
43 import bdb
44 import cPickle as pickle
44 import cPickle as pickle
45 import codeop
45 import codeop
46 import exceptions
46 import exceptions
47 import glob
47 import glob
48 import inspect
48 import inspect
49 import keyword
49 import keyword
50 import new
50 import new
51 import os
51 import os
52 import pdb
52 import pdb
53 import pydoc
53 import pydoc
54 import re
54 import re
55 import shutil
55 import shutil
56 import string
56 import string
57 import sys
57 import sys
58 import traceback
58 import traceback
59 import types
59 import types
60
60
61 from pprint import pprint, pformat
61 from pprint import pprint, pformat
62
62
63 # IPython's own modules
63 # IPython's own modules
64 import IPython
64 import IPython
65 from IPython import OInspect,PyColorize,ultraTB
65 from IPython import OInspect,PyColorize,ultraTB
66 from IPython.ColorANSI import ColorScheme,ColorSchemeTable # too long names
66 from IPython.ColorANSI import ColorScheme,ColorSchemeTable # too long names
67 from IPython.FakeModule import FakeModule
67 from IPython.FakeModule import FakeModule
68 from IPython.Itpl import Itpl,itpl,printpl,ItplNS,itplns
68 from IPython.Itpl import Itpl,itpl,printpl,ItplNS,itplns
69 from IPython.Logger import Logger
69 from IPython.Logger import Logger
70 from IPython.Magic import Magic,magic2python
70 from IPython.Magic import Magic,magic2python
71 from IPython.Struct import Struct
71 from IPython.Struct import Struct
72 from IPython.background_jobs import BackgroundJobManager
72 from IPython.background_jobs import BackgroundJobManager
73 from IPython.usage import cmd_line_usage,interactive_usage
73 from IPython.usage import cmd_line_usage,interactive_usage
74 from IPython.genutils import *
74 from IPython.genutils import *
75
75
76 # store the builtin raw_input globally, and use this always, in case user code
76 # store the builtin raw_input globally, and use this always, in case user code
77 # overwrites it (like wx.py.PyShell does)
77 # overwrites it (like wx.py.PyShell does)
78 raw_input_original = raw_input
78 raw_input_original = raw_input
79
79
80 #****************************************************************************
80 #****************************************************************************
81 # Some utility function definitions
81 # Some utility function definitions
82
82
83 # This can be replaced with an isspace() call once we drop 2.2 compatibility
83 # This can be replaced with an isspace() call once we drop 2.2 compatibility
84 _isspace_match = re.compile(r'^\s+$').match
84 _isspace_match = re.compile(r'^\s+$').match
85 def isspace(s):
85 def isspace(s):
86 return bool(_isspace_match(s))
86 return bool(_isspace_match(s))
87
87
88 def esc_quotes(strng):
88 def esc_quotes(strng):
89 """Return the input string with single and double quotes escaped out"""
89 """Return the input string with single and double quotes escaped out"""
90
90
91 return strng.replace('"','\\"').replace("'","\\'")
91 return strng.replace('"','\\"').replace("'","\\'")
92
92
93 def import_fail_info(mod_name,fns=None):
93 def import_fail_info(mod_name,fns=None):
94 """Inform load failure for a module."""
94 """Inform load failure for a module."""
95
95
96 if fns == None:
96 if fns == None:
97 warn("Loading of %s failed.\n" % (mod_name,))
97 warn("Loading of %s failed.\n" % (mod_name,))
98 else:
98 else:
99 warn("Loading of %s from %s failed.\n" % (fns,mod_name))
99 warn("Loading of %s from %s failed.\n" % (fns,mod_name))
100
100
101 def qw_lol(indata):
101 def qw_lol(indata):
102 """qw_lol('a b') -> [['a','b']],
102 """qw_lol('a b') -> [['a','b']],
103 otherwise it's just a call to qw().
103 otherwise it's just a call to qw().
104
104
105 We need this to make sure the modules_some keys *always* end up as a
105 We need this to make sure the modules_some keys *always* end up as a
106 list of lists."""
106 list of lists."""
107
107
108 if type(indata) in StringTypes:
108 if type(indata) in StringTypes:
109 return [qw(indata)]
109 return [qw(indata)]
110 else:
110 else:
111 return qw(indata)
111 return qw(indata)
112
112
113 def ipmagic(arg_s):
113 def ipmagic(arg_s):
114 """Call a magic function by name.
114 """Call a magic function by name.
115
115
116 Input: a string containing the name of the magic function to call and any
116 Input: a string containing the name of the magic function to call and any
117 additional arguments to be passed to the magic.
117 additional arguments to be passed to the magic.
118
118
119 ipmagic('name -opt foo bar') is equivalent to typing at the ipython
119 ipmagic('name -opt foo bar') is equivalent to typing at the ipython
120 prompt:
120 prompt:
121
121
122 In[1]: %name -opt foo bar
122 In[1]: %name -opt foo bar
123
123
124 To call a magic without arguments, simply use ipmagic('name').
124 To call a magic without arguments, simply use ipmagic('name').
125
125
126 This provides a proper Python function to call IPython's magics in any
126 This provides a proper Python function to call IPython's magics in any
127 valid Python code you can type at the interpreter, including loops and
127 valid Python code you can type at the interpreter, including loops and
128 compound statements. It is added by IPython to the Python builtin
128 compound statements. It is added by IPython to the Python builtin
129 namespace upon initialization."""
129 namespace upon initialization."""
130
130
131 args = arg_s.split(' ',1)
131 args = arg_s.split(' ',1)
132 magic_name = args[0]
132 magic_name = args[0]
133 if magic_name.startswith(__IPYTHON__.ESC_MAGIC):
133 if magic_name.startswith(__IPYTHON__.ESC_MAGIC):
134 magic_name = magic_name[1:]
134 magic_name = magic_name[1:]
135 try:
135 try:
136 magic_args = args[1]
136 magic_args = args[1]
137 except IndexError:
137 except IndexError:
138 magic_args = ''
138 magic_args = ''
139 fn = getattr(__IPYTHON__,'magic_'+magic_name,None)
139 fn = getattr(__IPYTHON__,'magic_'+magic_name,None)
140 if fn is None:
140 if fn is None:
141 error("Magic function `%s` not found." % magic_name)
141 error("Magic function `%s` not found." % magic_name)
142 else:
142 else:
143 magic_args = __IPYTHON__.var_expand(magic_args)
143 magic_args = __IPYTHON__.var_expand(magic_args)
144 return fn(magic_args)
144 return fn(magic_args)
145
145
146 def ipalias(arg_s):
146 def ipalias(arg_s):
147 """Call an alias by name.
147 """Call an alias by name.
148
148
149 Input: a string containing the name of the alias to call and any
149 Input: a string containing the name of the alias to call and any
150 additional arguments to be passed to the magic.
150 additional arguments to be passed to the magic.
151
151
152 ipalias('name -opt foo bar') is equivalent to typing at the ipython
152 ipalias('name -opt foo bar') is equivalent to typing at the ipython
153 prompt:
153 prompt:
154
154
155 In[1]: name -opt foo bar
155 In[1]: name -opt foo bar
156
156
157 To call an alias without arguments, simply use ipalias('name').
157 To call an alias without arguments, simply use ipalias('name').
158
158
159 This provides a proper Python function to call IPython's aliases in any
159 This provides a proper Python function to call IPython's aliases in any
160 valid Python code you can type at the interpreter, including loops and
160 valid Python code you can type at the interpreter, including loops and
161 compound statements. It is added by IPython to the Python builtin
161 compound statements. It is added by IPython to the Python builtin
162 namespace upon initialization."""
162 namespace upon initialization."""
163
163
164 args = arg_s.split(' ',1)
164 args = arg_s.split(' ',1)
165 alias_name = args[0]
165 alias_name = args[0]
166 try:
166 try:
167 alias_args = args[1]
167 alias_args = args[1]
168 except IndexError:
168 except IndexError:
169 alias_args = ''
169 alias_args = ''
170 if alias_name in __IPYTHON__.alias_table:
170 if alias_name in __IPYTHON__.alias_table:
171 __IPYTHON__.call_alias(alias_name,alias_args)
171 __IPYTHON__.call_alias(alias_name,alias_args)
172 else:
172 else:
173 error("Alias `%s` not found." % alias_name)
173 error("Alias `%s` not found." % alias_name)
174
174
175 def softspace(file, newvalue):
175 def softspace(file, newvalue):
176 """Copied from code.py, to remove the dependency"""
176 """Copied from code.py, to remove the dependency"""
177 oldvalue = 0
177 oldvalue = 0
178 try:
178 try:
179 oldvalue = file.softspace
179 oldvalue = file.softspace
180 except AttributeError:
180 except AttributeError:
181 pass
181 pass
182 try:
182 try:
183 file.softspace = newvalue
183 file.softspace = newvalue
184 except (AttributeError, TypeError):
184 except (AttributeError, TypeError):
185 # "attribute-less object" or "read-only attributes"
185 # "attribute-less object" or "read-only attributes"
186 pass
186 pass
187 return oldvalue
187 return oldvalue
188
188
189
189
190 #****************************************************************************
190 #****************************************************************************
191 # Local use exceptions
191 # Local use exceptions
192 class SpaceInInput(exceptions.Exception): pass
192 class SpaceInInput(exceptions.Exception): pass
193
193
194 #****************************************************************************
194 #****************************************************************************
195 # Local use classes
195 # Local use classes
196 class Bunch: pass
196 class Bunch: pass
197
197
198 class InputList(list):
198 class InputList(list):
199 """Class to store user input.
199 """Class to store user input.
200
200
201 It's basically a list, but slices return a string instead of a list, thus
201 It's basically a list, but slices return a string instead of a list, thus
202 allowing things like (assuming 'In' is an instance):
202 allowing things like (assuming 'In' is an instance):
203
203
204 exec In[4:7]
204 exec In[4:7]
205
205
206 or
206 or
207
207
208 exec In[5:9] + In[14] + In[21:25]"""
208 exec In[5:9] + In[14] + In[21:25]"""
209
209
210 def __getslice__(self,i,j):
210 def __getslice__(self,i,j):
211 return ''.join(list.__getslice__(self,i,j))
211 return ''.join(list.__getslice__(self,i,j))
212
212
213 class SyntaxTB(ultraTB.ListTB):
213 class SyntaxTB(ultraTB.ListTB):
214 """Extension which holds some state: the last exception value"""
214 """Extension which holds some state: the last exception value"""
215
215
216 def __init__(self,color_scheme = 'NoColor'):
216 def __init__(self,color_scheme = 'NoColor'):
217 ultraTB.ListTB.__init__(self,color_scheme)
217 ultraTB.ListTB.__init__(self,color_scheme)
218 self.last_syntax_error = None
218 self.last_syntax_error = None
219
219
220 def __call__(self, etype, value, elist):
220 def __call__(self, etype, value, elist):
221 self.last_syntax_error = value
221 self.last_syntax_error = value
222 ultraTB.ListTB.__call__(self,etype,value,elist)
222 ultraTB.ListTB.__call__(self,etype,value,elist)
223
223
224 def clear_err_state(self):
224 def clear_err_state(self):
225 """Return the current error state and clear it"""
225 """Return the current error state and clear it"""
226 e = self.last_syntax_error
226 e = self.last_syntax_error
227 self.last_syntax_error = None
227 self.last_syntax_error = None
228 return e
228 return e
229
229
230 #****************************************************************************
230 #****************************************************************************
231 # Main IPython class
231 # Main IPython class
232 class InteractiveShell(Logger, Magic):
232 class InteractiveShell(Logger, Magic):
233 """An enhanced console for Python."""
233 """An enhanced console for Python."""
234
234
235 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
235 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
236 user_ns = None,user_global_ns=None,banner2='',
236 user_ns = None,user_global_ns=None,banner2='',
237 custom_exceptions=((),None),embedded=False):
237 custom_exceptions=((),None),embedded=False):
238
238
239 # some minimal strict typechecks. For some core data structures, I
240 # want actual basic python types, not just anything that looks like
241 # one. This is especially true for namespaces.
242 for ns in (user_ns,user_global_ns):
243 if ns is not None and type(ns) != types.DictType:
244 raise TypeError,'namespace must be a dictionary'
245
239 # Put a reference to self in builtins so that any form of embedded or
246 # Put a reference to self in builtins so that any form of embedded or
240 # imported code can test for being inside IPython.
247 # imported code can test for being inside IPython.
241 __builtin__.__IPYTHON__ = self
248 __builtin__.__IPYTHON__ = self
242
249
243 # And load into builtins ipmagic/ipalias as well
250 # And load into builtins ipmagic/ipalias as well
244 __builtin__.ipmagic = ipmagic
251 __builtin__.ipmagic = ipmagic
245 __builtin__.ipalias = ipalias
252 __builtin__.ipalias = ipalias
246
253
247 # Add to __builtin__ other parts of IPython's public API
254 # Add to __builtin__ other parts of IPython's public API
248 __builtin__.ip_set_hook = self.set_hook
255 __builtin__.ip_set_hook = self.set_hook
249
256
250 # Keep in the builtins a flag for when IPython is active. We set it
257 # Keep in the builtins a flag for when IPython is active. We set it
251 # with setdefault so that multiple nested IPythons don't clobber one
258 # with setdefault so that multiple nested IPythons don't clobber one
252 # another. Each will increase its value by one upon being activated,
259 # another. Each will increase its value by one upon being activated,
253 # which also gives us a way to determine the nesting level.
260 # which also gives us a way to determine the nesting level.
254 __builtin__.__dict__.setdefault('__IPYTHON__active',0)
261 __builtin__.__dict__.setdefault('__IPYTHON__active',0)
255
262
256 # Do the intuitively correct thing for quit/exit: we remove the
263 # Do the intuitively correct thing for quit/exit: we remove the
257 # builtins if they exist, and our own prefilter routine will handle
264 # builtins if they exist, and our own prefilter routine will handle
258 # these special cases
265 # these special cases
259 try:
266 try:
260 del __builtin__.exit, __builtin__.quit
267 del __builtin__.exit, __builtin__.quit
261 except AttributeError:
268 except AttributeError:
262 pass
269 pass
263
270
264 # We need to know whether the instance is meant for embedding, since
271 # We need to know whether the instance is meant for embedding, since
265 # global/local namespaces need to be handled differently in that case
272 # global/local namespaces need to be handled differently in that case
266 self.embedded = embedded
273 self.embedded = embedded
267
274
268 # command compiler
275 # command compiler
269 self.compile = codeop.CommandCompiler()
276 self.compile = codeop.CommandCompiler()
270
277
271 # User input buffer
278 # User input buffer
272 self.buffer = []
279 self.buffer = []
273
280
274 # Default name given in compilation of code
281 # Default name given in compilation of code
275 self.filename = '<ipython console>'
282 self.filename = '<ipython console>'
276
283
277 # Create the namespace where the user will operate. user_ns is
284 # Create the namespace where the user will operate. user_ns is
278 # normally the only one used, and it is passed to the exec calls as
285 # normally the only one used, and it is passed to the exec calls as
279 # the locals argument. But we do carry a user_global_ns namespace
286 # the locals argument. But we do carry a user_global_ns namespace
280 # given as the exec 'globals' argument, This is useful in embedding
287 # given as the exec 'globals' argument, This is useful in embedding
281 # situations where the ipython shell opens in a context where the
288 # situations where the ipython shell opens in a context where the
282 # distinction between locals and globals is meaningful.
289 # distinction between locals and globals is meaningful.
283
290
284 # FIXME. For some strange reason, __builtins__ is showing up at user
291 # FIXME. For some strange reason, __builtins__ is showing up at user
285 # level as a dict instead of a module. This is a manual fix, but I
292 # level as a dict instead of a module. This is a manual fix, but I
286 # should really track down where the problem is coming from. Alex
293 # should really track down where the problem is coming from. Alex
287 # Schmolck reported this problem first.
294 # Schmolck reported this problem first.
288
295
289 # A useful post by Alex Martelli on this topic:
296 # A useful post by Alex Martelli on this topic:
290 # Re: inconsistent value from __builtins__
297 # Re: inconsistent value from __builtins__
291 # Von: Alex Martelli <aleaxit@yahoo.com>
298 # Von: Alex Martelli <aleaxit@yahoo.com>
292 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
299 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
293 # Gruppen: comp.lang.python
300 # Gruppen: comp.lang.python
294 # Referenzen: 1
301 # Referenzen: 1
295
302
296 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
303 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
297 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
304 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
298 # > <type 'dict'>
305 # > <type 'dict'>
299 # > >>> print type(__builtins__)
306 # > >>> print type(__builtins__)
300 # > <type 'module'>
307 # > <type 'module'>
301 # > Is this difference in return value intentional?
308 # > Is this difference in return value intentional?
302
309
303 # Well, it's documented that '__builtins__' can be either a dictionary
310 # Well, it's documented that '__builtins__' can be either a dictionary
304 # or a module, and it's been that way for a long time. Whether it's
311 # or a module, and it's been that way for a long time. Whether it's
305 # intentional (or sensible), I don't know. In any case, the idea is
312 # intentional (or sensible), I don't know. In any case, the idea is
306 # that if you need to access the built-in namespace directly, you
313 # that if you need to access the built-in namespace directly, you
307 # should start with "import __builtin__" (note, no 's') which will
314 # should start with "import __builtin__" (note, no 's') which will
308 # definitely give you a module. Yeah, it's somewhat confusing:-(.
315 # definitely give you a module. Yeah, it's somewhat confusing:-(.
309
316
310 if user_ns is None:
317 if user_ns is None:
311 # Set __name__ to __main__ to better match the behavior of the
318 # Set __name__ to __main__ to better match the behavior of the
312 # normal interpreter.
319 # normal interpreter.
313 user_ns = {'__name__' :'__main__',
320 user_ns = {'__name__' :'__main__',
314 '__builtins__' : __builtin__,
321 '__builtins__' : __builtin__,
315 }
322 }
316
323
317 if user_global_ns is None:
324 if user_global_ns is None:
318 user_global_ns = {}
325 user_global_ns = {}
319
326
320 # Assign namespaces
327 # Assign namespaces
321 # This is the namespace where all normal user variables live
328 # This is the namespace where all normal user variables live
322 self.user_ns = user_ns
329 self.user_ns = user_ns
323 # Embedded instances require a separate namespace for globals.
330 # Embedded instances require a separate namespace for globals.
324 # Normally this one is unused by non-embedded instances.
331 # Normally this one is unused by non-embedded instances.
325 self.user_global_ns = user_global_ns
332 self.user_global_ns = user_global_ns
326 # A namespace to keep track of internal data structures to prevent
333 # A namespace to keep track of internal data structures to prevent
327 # them from cluttering user-visible stuff. Will be updated later
334 # them from cluttering user-visible stuff. Will be updated later
328 self.internal_ns = {}
335 self.internal_ns = {}
329
336
330 # Namespace of system aliases. Each entry in the alias
337 # Namespace of system aliases. Each entry in the alias
331 # table must be a 2-tuple of the form (N,name), where N is the number
338 # table must be a 2-tuple of the form (N,name), where N is the number
332 # of positional arguments of the alias.
339 # of positional arguments of the alias.
333 self.alias_table = {}
340 self.alias_table = {}
334
341
335 # A table holding all the namespaces IPython deals with, so that
342 # A table holding all the namespaces IPython deals with, so that
336 # introspection facilities can search easily.
343 # introspection facilities can search easily.
337 self.ns_table = {'user':user_ns,
344 self.ns_table = {'user':user_ns,
338 'user_global':user_global_ns,
345 'user_global':user_global_ns,
339 'alias':self.alias_table,
346 'alias':self.alias_table,
340 'internal':self.internal_ns,
347 'internal':self.internal_ns,
341 'builtin':__builtin__.__dict__
348 'builtin':__builtin__.__dict__
342 }
349 }
343
350
344 # The user namespace MUST have a pointer to the shell itself.
351 # The user namespace MUST have a pointer to the shell itself.
345 self.user_ns[name] = self
352 self.user_ns[name] = self
346
353
347 # We need to insert into sys.modules something that looks like a
354 # We need to insert into sys.modules something that looks like a
348 # module but which accesses the IPython namespace, for shelve and
355 # module but which accesses the IPython namespace, for shelve and
349 # pickle to work interactively. Normally they rely on getting
356 # pickle to work interactively. Normally they rely on getting
350 # everything out of __main__, but for embedding purposes each IPython
357 # everything out of __main__, but for embedding purposes each IPython
351 # instance has its own private namespace, so we can't go shoving
358 # instance has its own private namespace, so we can't go shoving
352 # everything into __main__.
359 # everything into __main__.
353
360
354 # note, however, that we should only do this for non-embedded
361 # note, however, that we should only do this for non-embedded
355 # ipythons, which really mimic the __main__.__dict__ with their own
362 # ipythons, which really mimic the __main__.__dict__ with their own
356 # namespace. Embedded instances, on the other hand, should not do
363 # namespace. Embedded instances, on the other hand, should not do
357 # this because they need to manage the user local/global namespaces
364 # this because they need to manage the user local/global namespaces
358 # only, but they live within a 'normal' __main__ (meaning, they
365 # only, but they live within a 'normal' __main__ (meaning, they
359 # shouldn't overtake the execution environment of the script they're
366 # shouldn't overtake the execution environment of the script they're
360 # embedded in).
367 # embedded in).
361
368
362 if not embedded:
369 if not embedded:
363 try:
370 try:
364 main_name = self.user_ns['__name__']
371 main_name = self.user_ns['__name__']
365 except KeyError:
372 except KeyError:
366 raise KeyError,'user_ns dictionary MUST have a "__name__" key'
373 raise KeyError,'user_ns dictionary MUST have a "__name__" key'
367 else:
374 else:
368 #print "pickle hack in place" # dbg
375 #print "pickle hack in place" # dbg
369 sys.modules[main_name] = FakeModule(self.user_ns)
376 sys.modules[main_name] = FakeModule(self.user_ns)
370
377
371 # List of input with multi-line handling.
378 # List of input with multi-line handling.
372 # Fill its zero entry, user counter starts at 1
379 # Fill its zero entry, user counter starts at 1
373 self.input_hist = InputList(['\n'])
380 self.input_hist = InputList(['\n'])
374
381
375 # list of visited directories
382 # list of visited directories
376 try:
383 try:
377 self.dir_hist = [os.getcwd()]
384 self.dir_hist = [os.getcwd()]
378 except IOError, e:
385 except IOError, e:
379 self.dir_hist = []
386 self.dir_hist = []
380
387
381 # dict of output history
388 # dict of output history
382 self.output_hist = {}
389 self.output_hist = {}
383
390
384 # dict of things NOT to alias (keywords, builtins and some magics)
391 # dict of things NOT to alias (keywords, builtins and some magics)
385 no_alias = {}
392 no_alias = {}
386 no_alias_magics = ['cd','popd','pushd','dhist','alias','unalias']
393 no_alias_magics = ['cd','popd','pushd','dhist','alias','unalias']
387 for key in keyword.kwlist + no_alias_magics:
394 for key in keyword.kwlist + no_alias_magics:
388 no_alias[key] = 1
395 no_alias[key] = 1
389 no_alias.update(__builtin__.__dict__)
396 no_alias.update(__builtin__.__dict__)
390 self.no_alias = no_alias
397 self.no_alias = no_alias
391
398
392 # make global variables for user access to these
399 # make global variables for user access to these
393 self.user_ns['_ih'] = self.input_hist
400 self.user_ns['_ih'] = self.input_hist
394 self.user_ns['_oh'] = self.output_hist
401 self.user_ns['_oh'] = self.output_hist
395 self.user_ns['_dh'] = self.dir_hist
402 self.user_ns['_dh'] = self.dir_hist
396
403
397 # user aliases to input and output histories
404 # user aliases to input and output histories
398 self.user_ns['In'] = self.input_hist
405 self.user_ns['In'] = self.input_hist
399 self.user_ns['Out'] = self.output_hist
406 self.user_ns['Out'] = self.output_hist
400
407
401 # Store the actual shell's name
408 # Store the actual shell's name
402 self.name = name
409 self.name = name
403
410
404 # Object variable to store code object waiting execution. This is
411 # Object variable to store code object waiting execution. This is
405 # used mainly by the multithreaded shells, but it can come in handy in
412 # used mainly by the multithreaded shells, but it can come in handy in
406 # other situations. No need to use a Queue here, since it's a single
413 # other situations. No need to use a Queue here, since it's a single
407 # item which gets cleared once run.
414 # item which gets cleared once run.
408 self.code_to_run = None
415 self.code_to_run = None
409
416
410 # Job manager (for jobs run as background threads)
417 # Job manager (for jobs run as background threads)
411 self.jobs = BackgroundJobManager()
418 self.jobs = BackgroundJobManager()
412 # Put the job manager into builtins so it's always there.
419 # Put the job manager into builtins so it's always there.
413 __builtin__.jobs = self.jobs
420 __builtin__.jobs = self.jobs
414
421
415 # escapes for automatic behavior on the command line
422 # escapes for automatic behavior on the command line
416 self.ESC_SHELL = '!'
423 self.ESC_SHELL = '!'
417 self.ESC_HELP = '?'
424 self.ESC_HELP = '?'
418 self.ESC_MAGIC = '%'
425 self.ESC_MAGIC = '%'
419 self.ESC_QUOTE = ','
426 self.ESC_QUOTE = ','
420 self.ESC_QUOTE2 = ';'
427 self.ESC_QUOTE2 = ';'
421 self.ESC_PAREN = '/'
428 self.ESC_PAREN = '/'
422
429
423 # And their associated handlers
430 # And their associated handlers
424 self.esc_handlers = {self.ESC_PAREN:self.handle_auto,
431 self.esc_handlers = {self.ESC_PAREN:self.handle_auto,
425 self.ESC_QUOTE:self.handle_auto,
432 self.ESC_QUOTE:self.handle_auto,
426 self.ESC_QUOTE2:self.handle_auto,
433 self.ESC_QUOTE2:self.handle_auto,
427 self.ESC_MAGIC:self.handle_magic,
434 self.ESC_MAGIC:self.handle_magic,
428 self.ESC_HELP:self.handle_help,
435 self.ESC_HELP:self.handle_help,
429 self.ESC_SHELL:self.handle_shell_escape,
436 self.ESC_SHELL:self.handle_shell_escape,
430 }
437 }
431
438
432 # class initializations
439 # class initializations
433 Logger.__init__(self,log_ns = self.user_ns)
440 Logger.__init__(self,log_ns = self.user_ns)
434 Magic.__init__(self,self)
441 Magic.__init__(self,self)
435
442
436 # an ugly hack to get a pointer to the shell, so I can start writing
443 # an ugly hack to get a pointer to the shell, so I can start writing
437 # magic code via this pointer instead of the current mixin salad.
444 # magic code via this pointer instead of the current mixin salad.
438 Magic.set_shell(self,self)
445 Magic.set_shell(self,self)
439
446
440 # Python source parser/formatter for syntax highlighting
447 # Python source parser/formatter for syntax highlighting
441 pyformat = PyColorize.Parser().format
448 pyformat = PyColorize.Parser().format
442 self.pycolorize = lambda src: pyformat(src,'str',self.rc['colors'])
449 self.pycolorize = lambda src: pyformat(src,'str',self.rc['colors'])
443
450
444 # hooks holds pointers used for user-side customizations
451 # hooks holds pointers used for user-side customizations
445 self.hooks = Struct()
452 self.hooks = Struct()
446
453
447 # Set all default hooks, defined in the IPython.hooks module.
454 # Set all default hooks, defined in the IPython.hooks module.
448 hooks = IPython.hooks
455 hooks = IPython.hooks
449 for hook_name in hooks.__all__:
456 for hook_name in hooks.__all__:
450 self.set_hook(hook_name,getattr(hooks,hook_name))
457 self.set_hook(hook_name,getattr(hooks,hook_name))
451
458
452 # Flag to mark unconditional exit
459 # Flag to mark unconditional exit
453 self.exit_now = False
460 self.exit_now = False
454
461
455 self.usage_min = """\
462 self.usage_min = """\
456 An enhanced console for Python.
463 An enhanced console for Python.
457 Some of its features are:
464 Some of its features are:
458 - Readline support if the readline library is present.
465 - Readline support if the readline library is present.
459 - Tab completion in the local namespace.
466 - Tab completion in the local namespace.
460 - Logging of input, see command-line options.
467 - Logging of input, see command-line options.
461 - System shell escape via ! , eg !ls.
468 - System shell escape via ! , eg !ls.
462 - Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)
469 - Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)
463 - Keeps track of locally defined variables via %who, %whos.
470 - Keeps track of locally defined variables via %who, %whos.
464 - Show object information with a ? eg ?x or x? (use ?? for more info).
471 - Show object information with a ? eg ?x or x? (use ?? for more info).
465 """
472 """
466 if usage: self.usage = usage
473 if usage: self.usage = usage
467 else: self.usage = self.usage_min
474 else: self.usage = self.usage_min
468
475
469 # Storage
476 # Storage
470 self.rc = rc # This will hold all configuration information
477 self.rc = rc # This will hold all configuration information
471 self.inputcache = []
478 self.inputcache = []
472 self._boundcache = []
479 self._boundcache = []
473 self.pager = 'less'
480 self.pager = 'less'
474 # temporary files used for various purposes. Deleted at exit.
481 # temporary files used for various purposes. Deleted at exit.
475 self.tempfiles = []
482 self.tempfiles = []
476
483
477 # Keep track of readline usage (later set by init_readline)
484 # Keep track of readline usage (later set by init_readline)
478 self.has_readline = False
485 self.has_readline = False
479
486
480 # for pushd/popd management
487 # for pushd/popd management
481 try:
488 try:
482 self.home_dir = get_home_dir()
489 self.home_dir = get_home_dir()
483 except HomeDirError,msg:
490 except HomeDirError,msg:
484 fatal(msg)
491 fatal(msg)
485
492
486 self.dir_stack = [os.getcwd().replace(self.home_dir,'~')]
493 self.dir_stack = [os.getcwd().replace(self.home_dir,'~')]
487
494
488 # Functions to call the underlying shell.
495 # Functions to call the underlying shell.
489
496
490 # utility to expand user variables via Itpl
497 # utility to expand user variables via Itpl
491 self.var_expand = lambda cmd: str(ItplNS(cmd.replace('#','\#'),
498 self.var_expand = lambda cmd: str(ItplNS(cmd.replace('#','\#'),
492 self.user_ns))
499 self.user_ns))
493 # The first is similar to os.system, but it doesn't return a value,
500 # The first is similar to os.system, but it doesn't return a value,
494 # and it allows interpolation of variables in the user's namespace.
501 # and it allows interpolation of variables in the user's namespace.
495 self.system = lambda cmd: shell(self.var_expand(cmd),
502 self.system = lambda cmd: shell(self.var_expand(cmd),
496 header='IPython system call: ',
503 header='IPython system call: ',
497 verbose=self.rc.system_verbose)
504 verbose=self.rc.system_verbose)
498 # These are for getoutput and getoutputerror:
505 # These are for getoutput and getoutputerror:
499 self.getoutput = lambda cmd: \
506 self.getoutput = lambda cmd: \
500 getoutput(self.var_expand(cmd),
507 getoutput(self.var_expand(cmd),
501 header='IPython system call: ',
508 header='IPython system call: ',
502 verbose=self.rc.system_verbose)
509 verbose=self.rc.system_verbose)
503 self.getoutputerror = lambda cmd: \
510 self.getoutputerror = lambda cmd: \
504 getoutputerror(str(ItplNS(cmd.replace('#','\#'),
511 getoutputerror(str(ItplNS(cmd.replace('#','\#'),
505 self.user_ns)),
512 self.user_ns)),
506 header='IPython system call: ',
513 header='IPython system call: ',
507 verbose=self.rc.system_verbose)
514 verbose=self.rc.system_verbose)
508
515
509 # RegExp for splitting line contents into pre-char//first
516 # RegExp for splitting line contents into pre-char//first
510 # word-method//rest. For clarity, each group in on one line.
517 # word-method//rest. For clarity, each group in on one line.
511
518
512 # WARNING: update the regexp if the above escapes are changed, as they
519 # WARNING: update the regexp if the above escapes are changed, as they
513 # are hardwired in.
520 # are hardwired in.
514
521
515 # Don't get carried away with trying to make the autocalling catch too
522 # Don't get carried away with trying to make the autocalling catch too
516 # much: it's better to be conservative rather than to trigger hidden
523 # much: it's better to be conservative rather than to trigger hidden
517 # evals() somewhere and end up causing side effects.
524 # evals() somewhere and end up causing side effects.
518
525
519 self.line_split = re.compile(r'^([\s*,;/])'
526 self.line_split = re.compile(r'^([\s*,;/])'
520 r'([\?\w\.]+\w*\s*)'
527 r'([\?\w\.]+\w*\s*)'
521 r'(\(?.*$)')
528 r'(\(?.*$)')
522
529
523 # Original re, keep around for a while in case changes break something
530 # Original re, keep around for a while in case changes break something
524 #self.line_split = re.compile(r'(^[\s*!\?%,/]?)'
531 #self.line_split = re.compile(r'(^[\s*!\?%,/]?)'
525 # r'(\s*[\?\w\.]+\w*\s*)'
532 # r'(\s*[\?\w\.]+\w*\s*)'
526 # r'(\(?.*$)')
533 # r'(\(?.*$)')
527
534
528 # RegExp to identify potential function names
535 # RegExp to identify potential function names
529 self.re_fun_name = re.compile(r'[a-zA-Z_]([a-zA-Z0-9_.]*) *$')
536 self.re_fun_name = re.compile(r'[a-zA-Z_]([a-zA-Z0-9_.]*) *$')
530 # RegExp to exclude strings with this start from autocalling
537 # RegExp to exclude strings with this start from autocalling
531 self.re_exclude_auto = re.compile('^[!=()<>,\*/\+-]|^is ')
538 self.re_exclude_auto = re.compile('^[!=()<>,\*/\+-]|^is ')
532
539
533 # try to catch also methods for stuff in lists/tuples/dicts: off
540 # try to catch also methods for stuff in lists/tuples/dicts: off
534 # (experimental). For this to work, the line_split regexp would need
541 # (experimental). For this to work, the line_split regexp would need
535 # to be modified so it wouldn't break things at '['. That line is
542 # to be modified so it wouldn't break things at '['. That line is
536 # nasty enough that I shouldn't change it until I can test it _well_.
543 # nasty enough that I shouldn't change it until I can test it _well_.
537 #self.re_fun_name = re.compile (r'[a-zA-Z_]([a-zA-Z0-9_.\[\]]*) ?$')
544 #self.re_fun_name = re.compile (r'[a-zA-Z_]([a-zA-Z0-9_.\[\]]*) ?$')
538
545
539 # keep track of where we started running (mainly for crash post-mortem)
546 # keep track of where we started running (mainly for crash post-mortem)
540 self.starting_dir = os.getcwd()
547 self.starting_dir = os.getcwd()
541
548
542 # Attributes for Logger mixin class, make defaults here
549 # Attributes for Logger mixin class, make defaults here
543 self._dolog = False
550 self._dolog = False
544 self.LOG = ''
551 self.LOG = ''
545 self.LOGDEF = '.InteractiveShell.log'
552 self.LOGDEF = '.InteractiveShell.log'
546 self.LOGMODE = 'over'
553 self.LOGMODE = 'over'
547 self.LOGHEAD = Itpl(
554 self.LOGHEAD = Itpl(
548 """#log# Automatic Logger file. *** THIS MUST BE THE FIRST LINE ***
555 """#log# Automatic Logger file. *** THIS MUST BE THE FIRST LINE ***
549 #log# DO NOT CHANGE THIS LINE OR THE TWO BELOW
556 #log# DO NOT CHANGE THIS LINE OR THE TWO BELOW
550 #log# opts = $self.rc.opts
557 #log# opts = $self.rc.opts
551 #log# args = $self.rc.args
558 #log# args = $self.rc.args
552 #log# It is safe to make manual edits below here.
559 #log# It is safe to make manual edits below here.
553 #log#-----------------------------------------------------------------------
560 #log#-----------------------------------------------------------------------
554 """)
561 """)
555 # Various switches which can be set
562 # Various switches which can be set
556 self.CACHELENGTH = 5000 # this is cheap, it's just text
563 self.CACHELENGTH = 5000 # this is cheap, it's just text
557 self.BANNER = "Python %(version)s on %(platform)s\n" % sys.__dict__
564 self.BANNER = "Python %(version)s on %(platform)s\n" % sys.__dict__
558 self.banner2 = banner2
565 self.banner2 = banner2
559
566
560 # TraceBack handlers:
567 # TraceBack handlers:
561 # Need two, one for syntax errors and one for other exceptions.
568 # Need two, one for syntax errors and one for other exceptions.
562 self.SyntaxTB = SyntaxTB(color_scheme='NoColor')
569 self.SyntaxTB = SyntaxTB(color_scheme='NoColor')
563 # The interactive one is initialized with an offset, meaning we always
570 # The interactive one is initialized with an offset, meaning we always
564 # want to remove the topmost item in the traceback, which is our own
571 # want to remove the topmost item in the traceback, which is our own
565 # internal code. Valid modes: ['Plain','Context','Verbose']
572 # internal code. Valid modes: ['Plain','Context','Verbose']
566 self.InteractiveTB = ultraTB.AutoFormattedTB(mode = 'Plain',
573 self.InteractiveTB = ultraTB.AutoFormattedTB(mode = 'Plain',
567 color_scheme='NoColor',
574 color_scheme='NoColor',
568 tb_offset = 1)
575 tb_offset = 1)
569 # and add any custom exception handlers the user may have specified
576 # and add any custom exception handlers the user may have specified
570 self.set_custom_exc(*custom_exceptions)
577 self.set_custom_exc(*custom_exceptions)
571
578
572 # Object inspector
579 # Object inspector
573 self.inspector = OInspect.Inspector(OInspect.InspectColors,
580 self.inspector = OInspect.Inspector(OInspect.InspectColors,
574 PyColorize.ANSICodeColors,
581 PyColorize.ANSICodeColors,
575 'NoColor')
582 'NoColor')
576 # indentation management
583 # indentation management
577 self.autoindent = False
584 self.autoindent = False
578 self.indent_current_nsp = 0
585 self.indent_current_nsp = 0
579 self.indent_current = '' # actual indent string
586 self.indent_current = '' # actual indent string
580
587
581 # Make some aliases automatically
588 # Make some aliases automatically
582 # Prepare list of shell aliases to auto-define
589 # Prepare list of shell aliases to auto-define
583 if os.name == 'posix':
590 if os.name == 'posix':
584 auto_alias = ('mkdir mkdir', 'rmdir rmdir',
591 auto_alias = ('mkdir mkdir', 'rmdir rmdir',
585 'mv mv -i','rm rm -i','cp cp -i',
592 'mv mv -i','rm rm -i','cp cp -i',
586 'cat cat','less less','clear clear',
593 'cat cat','less less','clear clear',
587 # a better ls
594 # a better ls
588 'ls ls -F',
595 'ls ls -F',
589 # long ls
596 # long ls
590 'll ls -lF',
597 'll ls -lF',
591 # color ls
598 # color ls
592 'lc ls -F -o --color',
599 'lc ls -F -o --color',
593 # ls normal files only
600 # ls normal files only
594 'lf ls -F -o --color %l | grep ^-',
601 'lf ls -F -o --color %l | grep ^-',
595 # ls symbolic links
602 # ls symbolic links
596 'lk ls -F -o --color %l | grep ^l',
603 'lk ls -F -o --color %l | grep ^l',
597 # directories or links to directories,
604 # directories or links to directories,
598 'ldir ls -F -o --color %l | grep /$',
605 'ldir ls -F -o --color %l | grep /$',
599 # things which are executable
606 # things which are executable
600 'lx ls -F -o --color %l | grep ^-..x',
607 'lx ls -F -o --color %l | grep ^-..x',
601 )
608 )
602 elif os.name in ['nt','dos']:
609 elif os.name in ['nt','dos']:
603 auto_alias = ('dir dir /on', 'ls dir /on',
610 auto_alias = ('dir dir /on', 'ls dir /on',
604 'ddir dir /ad /on', 'ldir dir /ad /on',
611 'ddir dir /ad /on', 'ldir dir /ad /on',
605 'mkdir mkdir','rmdir rmdir','echo echo',
612 'mkdir mkdir','rmdir rmdir','echo echo',
606 'ren ren','cls cls','copy copy')
613 'ren ren','cls cls','copy copy')
607 else:
614 else:
608 auto_alias = ()
615 auto_alias = ()
609 self.auto_alias = map(lambda s:s.split(None,1),auto_alias)
616 self.auto_alias = map(lambda s:s.split(None,1),auto_alias)
610 # Call the actual (public) initializer
617 # Call the actual (public) initializer
611 self.init_auto_alias()
618 self.init_auto_alias()
612 # end __init__
619 # end __init__
613
620
614 def set_hook(self,name,hook):
621 def set_hook(self,name,hook):
615 """set_hook(name,hook) -> sets an internal IPython hook.
622 """set_hook(name,hook) -> sets an internal IPython hook.
616
623
617 IPython exposes some of its internal API as user-modifiable hooks. By
624 IPython exposes some of its internal API as user-modifiable hooks. By
618 resetting one of these hooks, you can modify IPython's behavior to
625 resetting one of these hooks, you can modify IPython's behavior to
619 call at runtime your own routines."""
626 call at runtime your own routines."""
620
627
621 # At some point in the future, this should validate the hook before it
628 # At some point in the future, this should validate the hook before it
622 # accepts it. Probably at least check that the hook takes the number
629 # accepts it. Probably at least check that the hook takes the number
623 # of args it's supposed to.
630 # of args it's supposed to.
624 setattr(self.hooks,name,new.instancemethod(hook,self,self.__class__))
631 setattr(self.hooks,name,new.instancemethod(hook,self,self.__class__))
625
632
626 def set_custom_exc(self,exc_tuple,handler):
633 def set_custom_exc(self,exc_tuple,handler):
627 """set_custom_exc(exc_tuple,handler)
634 """set_custom_exc(exc_tuple,handler)
628
635
629 Set a custom exception handler, which will be called if any of the
636 Set a custom exception handler, which will be called if any of the
630 exceptions in exc_tuple occur in the mainloop (specifically, in the
637 exceptions in exc_tuple occur in the mainloop (specifically, in the
631 runcode() method.
638 runcode() method.
632
639
633 Inputs:
640 Inputs:
634
641
635 - exc_tuple: a *tuple* of valid exceptions to call the defined
642 - exc_tuple: a *tuple* of valid exceptions to call the defined
636 handler for. It is very important that you use a tuple, and NOT A
643 handler for. It is very important that you use a tuple, and NOT A
637 LIST here, because of the way Python's except statement works. If
644 LIST here, because of the way Python's except statement works. If
638 you only want to trap a single exception, use a singleton tuple:
645 you only want to trap a single exception, use a singleton tuple:
639
646
640 exc_tuple == (MyCustomException,)
647 exc_tuple == (MyCustomException,)
641
648
642 - handler: this must be defined as a function with the following
649 - handler: this must be defined as a function with the following
643 basic interface: def my_handler(self,etype,value,tb).
650 basic interface: def my_handler(self,etype,value,tb).
644
651
645 This will be made into an instance method (via new.instancemethod)
652 This will be made into an instance method (via new.instancemethod)
646 of IPython itself, and it will be called if any of the exceptions
653 of IPython itself, and it will be called if any of the exceptions
647 listed in the exc_tuple are caught. If the handler is None, an
654 listed in the exc_tuple are caught. If the handler is None, an
648 internal basic one is used, which just prints basic info.
655 internal basic one is used, which just prints basic info.
649
656
650 WARNING: by putting in your own exception handler into IPython's main
657 WARNING: by putting in your own exception handler into IPython's main
651 execution loop, you run a very good chance of nasty crashes. This
658 execution loop, you run a very good chance of nasty crashes. This
652 facility should only be used if you really know what you are doing."""
659 facility should only be used if you really know what you are doing."""
653
660
654 assert type(exc_tuple)==type(()) , \
661 assert type(exc_tuple)==type(()) , \
655 "The custom exceptions must be given AS A TUPLE."
662 "The custom exceptions must be given AS A TUPLE."
656
663
657 def dummy_handler(self,etype,value,tb):
664 def dummy_handler(self,etype,value,tb):
658 print '*** Simple custom exception handler ***'
665 print '*** Simple custom exception handler ***'
659 print 'Exception type :',etype
666 print 'Exception type :',etype
660 print 'Exception value:',value
667 print 'Exception value:',value
661 print 'Traceback :',tb
668 print 'Traceback :',tb
662 print 'Source code :','\n'.join(self.buffer)
669 print 'Source code :','\n'.join(self.buffer)
663
670
664 if handler is None: handler = dummy_handler
671 if handler is None: handler = dummy_handler
665
672
666 self.CustomTB = new.instancemethod(handler,self,self.__class__)
673 self.CustomTB = new.instancemethod(handler,self,self.__class__)
667 self.custom_exceptions = exc_tuple
674 self.custom_exceptions = exc_tuple
668
675
669 def set_custom_completer(self,completer,pos=0):
676 def set_custom_completer(self,completer,pos=0):
670 """set_custom_completer(completer,pos=0)
677 """set_custom_completer(completer,pos=0)
671
678
672 Adds a new custom completer function.
679 Adds a new custom completer function.
673
680
674 The position argument (defaults to 0) is the index in the completers
681 The position argument (defaults to 0) is the index in the completers
675 list where you want the completer to be inserted."""
682 list where you want the completer to be inserted."""
676
683
677 newcomp = new.instancemethod(completer,self.Completer,
684 newcomp = new.instancemethod(completer,self.Completer,
678 self.Completer.__class__)
685 self.Completer.__class__)
679 self.Completer.matchers.insert(pos,newcomp)
686 self.Completer.matchers.insert(pos,newcomp)
680
687
681 def complete(self,text):
688 def complete(self,text):
682 """Return a sorted list of all possible completions on text.
689 """Return a sorted list of all possible completions on text.
683
690
684 Inputs:
691 Inputs:
685
692
686 - text: a string of text to be completed on.
693 - text: a string of text to be completed on.
687
694
688 This is a wrapper around the completion mechanism, similar to what
695 This is a wrapper around the completion mechanism, similar to what
689 readline does at the command line when the TAB key is hit. By
696 readline does at the command line when the TAB key is hit. By
690 exposing it as a method, it can be used by other non-readline
697 exposing it as a method, it can be used by other non-readline
691 environments (such as GUIs) for text completion.
698 environments (such as GUIs) for text completion.
692
699
693 Simple usage example:
700 Simple usage example:
694
701
695 In [1]: x = 'hello'
702 In [1]: x = 'hello'
696
703
697 In [2]: __IP.complete('x.l')
704 In [2]: __IP.complete('x.l')
698 Out[2]: ['x.ljust', 'x.lower', 'x.lstrip']"""
705 Out[2]: ['x.ljust', 'x.lower', 'x.lstrip']"""
699
706
700 complete = self.Completer.complete
707 complete = self.Completer.complete
701 state = 0
708 state = 0
702 # use a dict so we get unique keys, since ipyhton's multiple
709 # use a dict so we get unique keys, since ipyhton's multiple
703 # completers can return duplicates.
710 # completers can return duplicates.
704 comps = {}
711 comps = {}
705 while True:
712 while True:
706 newcomp = complete(text,state)
713 newcomp = complete(text,state)
707 if newcomp is None:
714 if newcomp is None:
708 break
715 break
709 comps[newcomp] = 1
716 comps[newcomp] = 1
710 state += 1
717 state += 1
711 outcomps = comps.keys()
718 outcomps = comps.keys()
712 outcomps.sort()
719 outcomps.sort()
713 return outcomps
720 return outcomps
714
721
715 def set_completer_frame(self, frame):
722 def set_completer_frame(self, frame):
716 if frame:
723 if frame:
717 self.Completer.namespace = frame.f_locals
724 self.Completer.namespace = frame.f_locals
718 self.Completer.global_namespace = frame.f_globals
725 self.Completer.global_namespace = frame.f_globals
719 else:
726 else:
720 self.Completer.namespace = self.user_ns
727 self.Completer.namespace = self.user_ns
721 self.Completer.global_namespace = self.user_global_ns
728 self.Completer.global_namespace = self.user_global_ns
722
729
723 def post_config_initialization(self):
730 def post_config_initialization(self):
724 """Post configuration init method
731 """Post configuration init method
725
732
726 This is called after the configuration files have been processed to
733 This is called after the configuration files have been processed to
727 'finalize' the initialization."""
734 'finalize' the initialization."""
728
735
729 rc = self.rc
736 rc = self.rc
730
737
731 # Load readline proper
738 # Load readline proper
732 if rc.readline:
739 if rc.readline:
733 self.init_readline()
740 self.init_readline()
734
741
735 # Set user colors (don't do it in the constructor above so that it
742 # Set user colors (don't do it in the constructor above so that it
736 # doesn't crash if colors option is invalid)
743 # doesn't crash if colors option is invalid)
737 self.magic_colors(rc.colors)
744 self.magic_colors(rc.colors)
738
745
739 # Load user aliases
746 # Load user aliases
740 for alias in rc.alias:
747 for alias in rc.alias:
741 self.magic_alias(alias)
748 self.magic_alias(alias)
742
749
743 # dynamic data that survives through sessions
750 # dynamic data that survives through sessions
744 # XXX make the filename a config option?
751 # XXX make the filename a config option?
745 persist_base = 'persist'
752 persist_base = 'persist'
746 if rc.profile:
753 if rc.profile:
747 persist_base += '_%s' % rc.profile
754 persist_base += '_%s' % rc.profile
748 self.persist_fname = os.path.join(rc.ipythondir,persist_base)
755 self.persist_fname = os.path.join(rc.ipythondir,persist_base)
749
756
750 try:
757 try:
751 self.persist = pickle.load(file(self.persist_fname))
758 self.persist = pickle.load(file(self.persist_fname))
752 except:
759 except:
753 self.persist = {}
760 self.persist = {}
754
761
755 def init_auto_alias(self):
762 def init_auto_alias(self):
756 """Define some aliases automatically.
763 """Define some aliases automatically.
757
764
758 These are ALL parameter-less aliases"""
765 These are ALL parameter-less aliases"""
759 for alias,cmd in self.auto_alias:
766 for alias,cmd in self.auto_alias:
760 self.alias_table[alias] = (0,cmd)
767 self.alias_table[alias] = (0,cmd)
761
768
762 def alias_table_validate(self,verbose=0):
769 def alias_table_validate(self,verbose=0):
763 """Update information about the alias table.
770 """Update information about the alias table.
764
771
765 In particular, make sure no Python keywords/builtins are in it."""
772 In particular, make sure no Python keywords/builtins are in it."""
766
773
767 no_alias = self.no_alias
774 no_alias = self.no_alias
768 for k in self.alias_table.keys():
775 for k in self.alias_table.keys():
769 if k in no_alias:
776 if k in no_alias:
770 del self.alias_table[k]
777 del self.alias_table[k]
771 if verbose:
778 if verbose:
772 print ("Deleting alias <%s>, it's a Python "
779 print ("Deleting alias <%s>, it's a Python "
773 "keyword or builtin." % k)
780 "keyword or builtin." % k)
774
781
775 def set_autoindent(self,value=None):
782 def set_autoindent(self,value=None):
776 """Set the autoindent flag, checking for readline support.
783 """Set the autoindent flag, checking for readline support.
777
784
778 If called with no arguments, it acts as a toggle."""
785 If called with no arguments, it acts as a toggle."""
779
786
780 if not self.has_readline:
787 if not self.has_readline:
781 if os.name == 'posix':
788 if os.name == 'posix':
782 warn("The auto-indent feature requires the readline library")
789 warn("The auto-indent feature requires the readline library")
783 self.autoindent = 0
790 self.autoindent = 0
784 return
791 return
785 if value is None:
792 if value is None:
786 self.autoindent = not self.autoindent
793 self.autoindent = not self.autoindent
787 else:
794 else:
788 self.autoindent = value
795 self.autoindent = value
789
796
790 def rc_set_toggle(self,rc_field,value=None):
797 def rc_set_toggle(self,rc_field,value=None):
791 """Set or toggle a field in IPython's rc config. structure.
798 """Set or toggle a field in IPython's rc config. structure.
792
799
793 If called with no arguments, it acts as a toggle.
800 If called with no arguments, it acts as a toggle.
794
801
795 If called with a non-existent field, the resulting AttributeError
802 If called with a non-existent field, the resulting AttributeError
796 exception will propagate out."""
803 exception will propagate out."""
797
804
798 rc_val = getattr(self.rc,rc_field)
805 rc_val = getattr(self.rc,rc_field)
799 if value is None:
806 if value is None:
800 value = not rc_val
807 value = not rc_val
801 setattr(self.rc,rc_field,value)
808 setattr(self.rc,rc_field,value)
802
809
803 def user_setup(self,ipythondir,rc_suffix,mode='install'):
810 def user_setup(self,ipythondir,rc_suffix,mode='install'):
804 """Install the user configuration directory.
811 """Install the user configuration directory.
805
812
806 Can be called when running for the first time or to upgrade the user's
813 Can be called when running for the first time or to upgrade the user's
807 .ipython/ directory with the mode parameter. Valid modes are 'install'
814 .ipython/ directory with the mode parameter. Valid modes are 'install'
808 and 'upgrade'."""
815 and 'upgrade'."""
809
816
810 def wait():
817 def wait():
811 try:
818 try:
812 raw_input("Please press <RETURN> to start IPython.")
819 raw_input("Please press <RETURN> to start IPython.")
813 except EOFError:
820 except EOFError:
814 print >> Term.cout
821 print >> Term.cout
815 print '*'*70
822 print '*'*70
816
823
817 cwd = os.getcwd() # remember where we started
824 cwd = os.getcwd() # remember where we started
818 glb = glob.glob
825 glb = glob.glob
819 print '*'*70
826 print '*'*70
820 if mode == 'install':
827 if mode == 'install':
821 print \
828 print \
822 """Welcome to IPython. I will try to create a personal configuration directory
829 """Welcome to IPython. I will try to create a personal configuration directory
823 where you can customize many aspects of IPython's functionality in:\n"""
830 where you can customize many aspects of IPython's functionality in:\n"""
824 else:
831 else:
825 print 'I am going to upgrade your configuration in:'
832 print 'I am going to upgrade your configuration in:'
826
833
827 print ipythondir
834 print ipythondir
828
835
829 rcdirend = os.path.join('IPython','UserConfig')
836 rcdirend = os.path.join('IPython','UserConfig')
830 cfg = lambda d: os.path.join(d,rcdirend)
837 cfg = lambda d: os.path.join(d,rcdirend)
831 try:
838 try:
832 rcdir = filter(os.path.isdir,map(cfg,sys.path))[0]
839 rcdir = filter(os.path.isdir,map(cfg,sys.path))[0]
833 except IOError:
840 except IOError:
834 warning = """
841 warning = """
835 Installation error. IPython's directory was not found.
842 Installation error. IPython's directory was not found.
836
843
837 Check the following:
844 Check the following:
838
845
839 The ipython/IPython directory should be in a directory belonging to your
846 The ipython/IPython directory should be in a directory belonging to your
840 PYTHONPATH environment variable (that is, it should be in a directory
847 PYTHONPATH environment variable (that is, it should be in a directory
841 belonging to sys.path). You can copy it explicitly there or just link to it.
848 belonging to sys.path). You can copy it explicitly there or just link to it.
842
849
843 IPython will proceed with builtin defaults.
850 IPython will proceed with builtin defaults.
844 """
851 """
845 warn(warning)
852 warn(warning)
846 wait()
853 wait()
847 return
854 return
848
855
849 if mode == 'install':
856 if mode == 'install':
850 try:
857 try:
851 shutil.copytree(rcdir,ipythondir)
858 shutil.copytree(rcdir,ipythondir)
852 os.chdir(ipythondir)
859 os.chdir(ipythondir)
853 rc_files = glb("ipythonrc*")
860 rc_files = glb("ipythonrc*")
854 for rc_file in rc_files:
861 for rc_file in rc_files:
855 os.rename(rc_file,rc_file+rc_suffix)
862 os.rename(rc_file,rc_file+rc_suffix)
856 except:
863 except:
857 warning = """
864 warning = """
858
865
859 There was a problem with the installation:
866 There was a problem with the installation:
860 %s
867 %s
861 Try to correct it or contact the developers if you think it's a bug.
868 Try to correct it or contact the developers if you think it's a bug.
862 IPython will proceed with builtin defaults.""" % sys.exc_info()[1]
869 IPython will proceed with builtin defaults.""" % sys.exc_info()[1]
863 warn(warning)
870 warn(warning)
864 wait()
871 wait()
865 return
872 return
866
873
867 elif mode == 'upgrade':
874 elif mode == 'upgrade':
868 try:
875 try:
869 os.chdir(ipythondir)
876 os.chdir(ipythondir)
870 except:
877 except:
871 print """
878 print """
872 Can not upgrade: changing to directory %s failed. Details:
879 Can not upgrade: changing to directory %s failed. Details:
873 %s
880 %s
874 """ % (ipythondir,sys.exc_info()[1])
881 """ % (ipythondir,sys.exc_info()[1])
875 wait()
882 wait()
876 return
883 return
877 else:
884 else:
878 sources = glb(os.path.join(rcdir,'[A-Za-z]*'))
885 sources = glb(os.path.join(rcdir,'[A-Za-z]*'))
879 for new_full_path in sources:
886 for new_full_path in sources:
880 new_filename = os.path.basename(new_full_path)
887 new_filename = os.path.basename(new_full_path)
881 if new_filename.startswith('ipythonrc'):
888 if new_filename.startswith('ipythonrc'):
882 new_filename = new_filename + rc_suffix
889 new_filename = new_filename + rc_suffix
883 # The config directory should only contain files, skip any
890 # The config directory should only contain files, skip any
884 # directories which may be there (like CVS)
891 # directories which may be there (like CVS)
885 if os.path.isdir(new_full_path):
892 if os.path.isdir(new_full_path):
886 continue
893 continue
887 if os.path.exists(new_filename):
894 if os.path.exists(new_filename):
888 old_file = new_filename+'.old'
895 old_file = new_filename+'.old'
889 if os.path.exists(old_file):
896 if os.path.exists(old_file):
890 os.remove(old_file)
897 os.remove(old_file)
891 os.rename(new_filename,old_file)
898 os.rename(new_filename,old_file)
892 shutil.copy(new_full_path,new_filename)
899 shutil.copy(new_full_path,new_filename)
893 else:
900 else:
894 raise ValueError,'unrecognized mode for install:',`mode`
901 raise ValueError,'unrecognized mode for install:',`mode`
895
902
896 # Fix line-endings to those native to each platform in the config
903 # Fix line-endings to those native to each platform in the config
897 # directory.
904 # directory.
898 try:
905 try:
899 os.chdir(ipythondir)
906 os.chdir(ipythondir)
900 except:
907 except:
901 print """
908 print """
902 Problem: changing to directory %s failed.
909 Problem: changing to directory %s failed.
903 Details:
910 Details:
904 %s
911 %s
905
912
906 Some configuration files may have incorrect line endings. This should not
913 Some configuration files may have incorrect line endings. This should not
907 cause any problems during execution. """ % (ipythondir,sys.exc_info()[1])
914 cause any problems during execution. """ % (ipythondir,sys.exc_info()[1])
908 wait()
915 wait()
909 else:
916 else:
910 for fname in glb('ipythonrc*'):
917 for fname in glb('ipythonrc*'):
911 try:
918 try:
912 native_line_ends(fname,backup=0)
919 native_line_ends(fname,backup=0)
913 except IOError:
920 except IOError:
914 pass
921 pass
915
922
916 if mode == 'install':
923 if mode == 'install':
917 print """
924 print """
918 Successful installation!
925 Successful installation!
919
926
920 Please read the sections 'Initial Configuration' and 'Quick Tips' in the
927 Please read the sections 'Initial Configuration' and 'Quick Tips' in the
921 IPython manual (there are both HTML and PDF versions supplied with the
928 IPython manual (there are both HTML and PDF versions supplied with the
922 distribution) to make sure that your system environment is properly configured
929 distribution) to make sure that your system environment is properly configured
923 to take advantage of IPython's features."""
930 to take advantage of IPython's features."""
924 else:
931 else:
925 print """
932 print """
926 Successful upgrade!
933 Successful upgrade!
927
934
928 All files in your directory:
935 All files in your directory:
929 %(ipythondir)s
936 %(ipythondir)s
930 which would have been overwritten by the upgrade were backed up with a .old
937 which would have been overwritten by the upgrade were backed up with a .old
931 extension. If you had made particular customizations in those files you may
938 extension. If you had made particular customizations in those files you may
932 want to merge them back into the new files.""" % locals()
939 want to merge them back into the new files.""" % locals()
933 wait()
940 wait()
934 os.chdir(cwd)
941 os.chdir(cwd)
935 # end user_setup()
942 # end user_setup()
936
943
937 def atexit_operations(self):
944 def atexit_operations(self):
938 """This will be executed at the time of exit.
945 """This will be executed at the time of exit.
939
946
940 Saving of persistent data should be performed here. """
947 Saving of persistent data should be performed here. """
941
948
942 # input history
949 # input history
943 self.savehist()
950 self.savehist()
944
951
945 # Cleanup all tempfiles left around
952 # Cleanup all tempfiles left around
946 for tfile in self.tempfiles:
953 for tfile in self.tempfiles:
947 try:
954 try:
948 os.unlink(tfile)
955 os.unlink(tfile)
949 except OSError:
956 except OSError:
950 pass
957 pass
951
958
952 # save the "persistent data" catch-all dictionary
959 # save the "persistent data" catch-all dictionary
953 try:
960 try:
954 pickle.dump(self.persist, open(self.persist_fname,"w"))
961 pickle.dump(self.persist, open(self.persist_fname,"w"))
955 except:
962 except:
956 print "*** ERROR *** persistent data saving failed."
963 print "*** ERROR *** persistent data saving failed."
957
964
958 def savehist(self):
965 def savehist(self):
959 """Save input history to a file (via readline library)."""
966 """Save input history to a file (via readline library)."""
960 try:
967 try:
961 self.readline.write_history_file(self.histfile)
968 self.readline.write_history_file(self.histfile)
962 except:
969 except:
963 print 'Unable to save IPython command history to file: ' + \
970 print 'Unable to save IPython command history to file: ' + \
964 `self.histfile`
971 `self.histfile`
965
972
966 def pre_readline(self):
973 def pre_readline(self):
967 """readline hook to be used at the start of each line.
974 """readline hook to be used at the start of each line.
968
975
969 Currently it handles auto-indent only."""
976 Currently it handles auto-indent only."""
970
977
971 self.readline.insert_text(self.indent_current)
978 self.readline.insert_text(self.indent_current)
972
979
973 def init_readline(self):
980 def init_readline(self):
974 """Command history completion/saving/reloading."""
981 """Command history completion/saving/reloading."""
975 try:
982 try:
976 import readline
983 import readline
977 except ImportError:
984 except ImportError:
978 self.has_readline = 0
985 self.has_readline = 0
979 self.readline = None
986 self.readline = None
980 # no point in bugging windows users with this every time:
987 # no point in bugging windows users with this every time:
981 if os.name == 'posix':
988 if os.name == 'posix':
982 warn('Readline services not available on this platform.')
989 warn('Readline services not available on this platform.')
983 else:
990 else:
984 import atexit
991 import atexit
985 from IPython.completer import IPCompleter
992 from IPython.completer import IPCompleter
986 self.Completer = IPCompleter(self,
993 self.Completer = IPCompleter(self,
987 self.user_ns,
994 self.user_ns,
988 self.user_global_ns,
995 self.user_global_ns,
989 self.rc.readline_omit__names,
996 self.rc.readline_omit__names,
990 self.alias_table)
997 self.alias_table)
991
998
992 # Platform-specific configuration
999 # Platform-specific configuration
993 if os.name == 'nt':
1000 if os.name == 'nt':
994 self.readline_startup_hook = readline.set_pre_input_hook
1001 self.readline_startup_hook = readline.set_pre_input_hook
995 else:
1002 else:
996 self.readline_startup_hook = readline.set_startup_hook
1003 self.readline_startup_hook = readline.set_startup_hook
997
1004
998 # Load user's initrc file (readline config)
1005 # Load user's initrc file (readline config)
999 inputrc_name = os.environ.get('INPUTRC')
1006 inputrc_name = os.environ.get('INPUTRC')
1000 if inputrc_name is None:
1007 if inputrc_name is None:
1001 home_dir = get_home_dir()
1008 home_dir = get_home_dir()
1002 if home_dir is not None:
1009 if home_dir is not None:
1003 inputrc_name = os.path.join(home_dir,'.inputrc')
1010 inputrc_name = os.path.join(home_dir,'.inputrc')
1004 if os.path.isfile(inputrc_name):
1011 if os.path.isfile(inputrc_name):
1005 try:
1012 try:
1006 readline.read_init_file(inputrc_name)
1013 readline.read_init_file(inputrc_name)
1007 except:
1014 except:
1008 warn('Problems reading readline initialization file <%s>'
1015 warn('Problems reading readline initialization file <%s>'
1009 % inputrc_name)
1016 % inputrc_name)
1010
1017
1011 self.has_readline = 1
1018 self.has_readline = 1
1012 self.readline = readline
1019 self.readline = readline
1013 # save this in sys so embedded copies can restore it properly
1020 # save this in sys so embedded copies can restore it properly
1014 sys.ipcompleter = self.Completer.complete
1021 sys.ipcompleter = self.Completer.complete
1015 readline.set_completer(self.Completer.complete)
1022 readline.set_completer(self.Completer.complete)
1016
1023
1017 # Configure readline according to user's prefs
1024 # Configure readline according to user's prefs
1018 for rlcommand in self.rc.readline_parse_and_bind:
1025 for rlcommand in self.rc.readline_parse_and_bind:
1019 readline.parse_and_bind(rlcommand)
1026 readline.parse_and_bind(rlcommand)
1020
1027
1021 # remove some chars from the delimiters list
1028 # remove some chars from the delimiters list
1022 delims = readline.get_completer_delims()
1029 delims = readline.get_completer_delims()
1023 delims = delims.translate(string._idmap,
1030 delims = delims.translate(string._idmap,
1024 self.rc.readline_remove_delims)
1031 self.rc.readline_remove_delims)
1025 readline.set_completer_delims(delims)
1032 readline.set_completer_delims(delims)
1026 # otherwise we end up with a monster history after a while:
1033 # otherwise we end up with a monster history after a while:
1027 readline.set_history_length(1000)
1034 readline.set_history_length(1000)
1028 try:
1035 try:
1029 #print '*** Reading readline history' # dbg
1036 #print '*** Reading readline history' # dbg
1030 readline.read_history_file(self.histfile)
1037 readline.read_history_file(self.histfile)
1031 except IOError:
1038 except IOError:
1032 pass # It doesn't exist yet.
1039 pass # It doesn't exist yet.
1033
1040
1034 atexit.register(self.atexit_operations)
1041 atexit.register(self.atexit_operations)
1035 del atexit
1042 del atexit
1036
1043
1037 # Configure auto-indent for all platforms
1044 # Configure auto-indent for all platforms
1038 self.set_autoindent(self.rc.autoindent)
1045 self.set_autoindent(self.rc.autoindent)
1039
1046
1040 def _should_recompile(self,e):
1047 def _should_recompile(self,e):
1041 """Utility routine for edit_syntax_error"""
1048 """Utility routine for edit_syntax_error"""
1042
1049
1043 if e.filename in ('<ipython console>','<input>','<string>',
1050 if e.filename in ('<ipython console>','<input>','<string>',
1044 '<console>'):
1051 '<console>'):
1045 return False
1052 return False
1046 try:
1053 try:
1047 if not ask_yes_no('Return to editor to correct syntax error? '
1054 if not ask_yes_no('Return to editor to correct syntax error? '
1048 '[Y/n] ','y'):
1055 '[Y/n] ','y'):
1049 return False
1056 return False
1050 except EOFError:
1057 except EOFError:
1051 return False
1058 return False
1052 self.hooks.fix_error_editor(e.filename,e.lineno,e.offset,e.msg)
1059 self.hooks.fix_error_editor(e.filename,e.lineno,e.offset,e.msg)
1053 return True
1060 return True
1054
1061
1055 def edit_syntax_error(self):
1062 def edit_syntax_error(self):
1056 """The bottom half of the syntax error handler called in the main loop.
1063 """The bottom half of the syntax error handler called in the main loop.
1057
1064
1058 Loop until syntax error is fixed or user cancels.
1065 Loop until syntax error is fixed or user cancels.
1059 """
1066 """
1060
1067
1061 while self.SyntaxTB.last_syntax_error:
1068 while self.SyntaxTB.last_syntax_error:
1062 # copy and clear last_syntax_error
1069 # copy and clear last_syntax_error
1063 err = self.SyntaxTB.clear_err_state()
1070 err = self.SyntaxTB.clear_err_state()
1064 if not self._should_recompile(err):
1071 if not self._should_recompile(err):
1065 return
1072 return
1066 try:
1073 try:
1067 # may set last_syntax_error again if a SyntaxError is raised
1074 # may set last_syntax_error again if a SyntaxError is raised
1068 self.safe_execfile(err.filename,self.shell.user_ns)
1075 self.safe_execfile(err.filename,self.shell.user_ns)
1069 except:
1076 except:
1070 self.showtraceback()
1077 self.showtraceback()
1071 else:
1078 else:
1072 f = file(err.filename)
1079 f = file(err.filename)
1073 try:
1080 try:
1074 sys.displayhook(f.read())
1081 sys.displayhook(f.read())
1075 finally:
1082 finally:
1076 f.close()
1083 f.close()
1077
1084
1078 def showsyntaxerror(self, filename=None):
1085 def showsyntaxerror(self, filename=None):
1079 """Display the syntax error that just occurred.
1086 """Display the syntax error that just occurred.
1080
1087
1081 This doesn't display a stack trace because there isn't one.
1088 This doesn't display a stack trace because there isn't one.
1082
1089
1083 If a filename is given, it is stuffed in the exception instead
1090 If a filename is given, it is stuffed in the exception instead
1084 of what was there before (because Python's parser always uses
1091 of what was there before (because Python's parser always uses
1085 "<string>" when reading from a string).
1092 "<string>" when reading from a string).
1086 """
1093 """
1087 type, value, sys.last_traceback = sys.exc_info()
1094 type, value, sys.last_traceback = sys.exc_info()
1088 sys.last_type = type
1095 sys.last_type = type
1089 sys.last_value = value
1096 sys.last_value = value
1090 if filename and type is SyntaxError:
1097 if filename and type is SyntaxError:
1091 # Work hard to stuff the correct filename in the exception
1098 # Work hard to stuff the correct filename in the exception
1092 try:
1099 try:
1093 msg, (dummy_filename, lineno, offset, line) = value
1100 msg, (dummy_filename, lineno, offset, line) = value
1094 except:
1101 except:
1095 # Not the format we expect; leave it alone
1102 # Not the format we expect; leave it alone
1096 pass
1103 pass
1097 else:
1104 else:
1098 # Stuff in the right filename
1105 # Stuff in the right filename
1099 try:
1106 try:
1100 # Assume SyntaxError is a class exception
1107 # Assume SyntaxError is a class exception
1101 value = SyntaxError(msg, (filename, lineno, offset, line))
1108 value = SyntaxError(msg, (filename, lineno, offset, line))
1102 except:
1109 except:
1103 # If that failed, assume SyntaxError is a string
1110 # If that failed, assume SyntaxError is a string
1104 value = msg, (filename, lineno, offset, line)
1111 value = msg, (filename, lineno, offset, line)
1105 self.SyntaxTB(type,value,[])
1112 self.SyntaxTB(type,value,[])
1106
1113
1107 def debugger(self):
1114 def debugger(self):
1108 """Call the pdb debugger."""
1115 """Call the pdb debugger."""
1109
1116
1110 if not self.rc.pdb:
1117 if not self.rc.pdb:
1111 return
1118 return
1112 pdb.pm()
1119 pdb.pm()
1113
1120
1114 def showtraceback(self,exc_tuple = None,filename=None):
1121 def showtraceback(self,exc_tuple = None,filename=None):
1115 """Display the exception that just occurred."""
1122 """Display the exception that just occurred."""
1116
1123
1117 # Though this won't be called by syntax errors in the input line,
1124 # Though this won't be called by syntax errors in the input line,
1118 # there may be SyntaxError cases whith imported code.
1125 # there may be SyntaxError cases whith imported code.
1119 if exc_tuple is None:
1126 if exc_tuple is None:
1120 type, value, tb = sys.exc_info()
1127 type, value, tb = sys.exc_info()
1121 else:
1128 else:
1122 type, value, tb = exc_tuple
1129 type, value, tb = exc_tuple
1123 if type is SyntaxError:
1130 if type is SyntaxError:
1124 self.showsyntaxerror(filename)
1131 self.showsyntaxerror(filename)
1125 else:
1132 else:
1126 sys.last_type = type
1133 sys.last_type = type
1127 sys.last_value = value
1134 sys.last_value = value
1128 sys.last_traceback = tb
1135 sys.last_traceback = tb
1129 self.InteractiveTB()
1136 self.InteractiveTB()
1130 if self.InteractiveTB.call_pdb and self.has_readline:
1137 if self.InteractiveTB.call_pdb and self.has_readline:
1131 # pdb mucks up readline, fix it back
1138 # pdb mucks up readline, fix it back
1132 self.readline.set_completer(self.Completer.complete)
1139 self.readline.set_completer(self.Completer.complete)
1133
1140
1134 def update_cache(self, line):
1141 def update_cache(self, line):
1135 """puts line into cache"""
1142 """puts line into cache"""
1136 self.inputcache.insert(0, line) # This copies the cache every time ... :-(
1143 self.inputcache.insert(0, line) # This copies the cache every time ... :-(
1137 if len(self.inputcache) >= self.CACHELENGTH:
1144 if len(self.inputcache) >= self.CACHELENGTH:
1138 self.inputcache.pop() # This doesn't :-)
1145 self.inputcache.pop() # This doesn't :-)
1139
1146
1140 def mainloop(self,banner=None):
1147 def mainloop(self,banner=None):
1141 """Creates the local namespace and starts the mainloop.
1148 """Creates the local namespace and starts the mainloop.
1142
1149
1143 If an optional banner argument is given, it will override the
1150 If an optional banner argument is given, it will override the
1144 internally created default banner."""
1151 internally created default banner."""
1145
1152
1146 if self.rc.c: # Emulate Python's -c option
1153 if self.rc.c: # Emulate Python's -c option
1147 self.exec_init_cmd()
1154 self.exec_init_cmd()
1148 if banner is None:
1155 if banner is None:
1149 if self.rc.banner:
1156 if self.rc.banner:
1150 banner = self.BANNER+self.banner2
1157 banner = self.BANNER+self.banner2
1151 else:
1158 else:
1152 banner = ''
1159 banner = ''
1153 self.interact(banner)
1160 self.interact(banner)
1154
1161
1155 def exec_init_cmd(self):
1162 def exec_init_cmd(self):
1156 """Execute a command given at the command line.
1163 """Execute a command given at the command line.
1157
1164
1158 This emulates Python's -c option."""
1165 This emulates Python's -c option."""
1159
1166
1160 sys.argv = ['-c']
1167 sys.argv = ['-c']
1161 self.push(self.rc.c)
1168 self.push(self.rc.c)
1162
1169
1163 def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):
1170 def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):
1164 """Embeds IPython into a running python program.
1171 """Embeds IPython into a running python program.
1165
1172
1166 Input:
1173 Input:
1167
1174
1168 - header: An optional header message can be specified.
1175 - header: An optional header message can be specified.
1169
1176
1170 - local_ns, global_ns: working namespaces. If given as None, the
1177 - local_ns, global_ns: working namespaces. If given as None, the
1171 IPython-initialized one is updated with __main__.__dict__, so that
1178 IPython-initialized one is updated with __main__.__dict__, so that
1172 program variables become visible but user-specific configuration
1179 program variables become visible but user-specific configuration
1173 remains possible.
1180 remains possible.
1174
1181
1175 - stack_depth: specifies how many levels in the stack to go to
1182 - stack_depth: specifies how many levels in the stack to go to
1176 looking for namespaces (when local_ns and global_ns are None). This
1183 looking for namespaces (when local_ns and global_ns are None). This
1177 allows an intermediate caller to make sure that this function gets
1184 allows an intermediate caller to make sure that this function gets
1178 the namespace from the intended level in the stack. By default (0)
1185 the namespace from the intended level in the stack. By default (0)
1179 it will get its locals and globals from the immediate caller.
1186 it will get its locals and globals from the immediate caller.
1180
1187
1181 Warning: it's possible to use this in a program which is being run by
1188 Warning: it's possible to use this in a program which is being run by
1182 IPython itself (via %run), but some funny things will happen (a few
1189 IPython itself (via %run), but some funny things will happen (a few
1183 globals get overwritten). In the future this will be cleaned up, as
1190 globals get overwritten). In the future this will be cleaned up, as
1184 there is no fundamental reason why it can't work perfectly."""
1191 there is no fundamental reason why it can't work perfectly."""
1185
1192
1186 # Get locals and globals from caller
1193 # Get locals and globals from caller
1187 if local_ns is None or global_ns is None:
1194 if local_ns is None or global_ns is None:
1188 call_frame = sys._getframe(stack_depth).f_back
1195 call_frame = sys._getframe(stack_depth).f_back
1189
1196
1190 if local_ns is None:
1197 if local_ns is None:
1191 local_ns = call_frame.f_locals
1198 local_ns = call_frame.f_locals
1192 if global_ns is None:
1199 if global_ns is None:
1193 global_ns = call_frame.f_globals
1200 global_ns = call_frame.f_globals
1194
1201
1195 # Update namespaces and fire up interpreter
1202 # Update namespaces and fire up interpreter
1196 self.user_ns = local_ns
1203 self.user_ns = local_ns
1197 self.user_global_ns = global_ns
1204 self.user_global_ns = global_ns
1198
1205
1199 # Patch for global embedding to make sure that things don't overwrite
1206 # Patch for global embedding to make sure that things don't overwrite
1200 # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
1207 # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
1201 # FIXME. Test this a bit more carefully (the if.. is new)
1208 # FIXME. Test this a bit more carefully (the if.. is new)
1202 if local_ns is None and global_ns is None:
1209 if local_ns is None and global_ns is None:
1203 self.user_global_ns.update(__main__.__dict__)
1210 self.user_global_ns.update(__main__.__dict__)
1204
1211
1205 # make sure the tab-completer has the correct frame information, so it
1212 # make sure the tab-completer has the correct frame information, so it
1206 # actually completes using the frame's locals/globals
1213 # actually completes using the frame's locals/globals
1207 self.set_completer_frame(call_frame)
1214 self.set_completer_frame(call_frame)
1208
1215
1209 self.interact(header)
1216 self.interact(header)
1210
1217
1211 def interact(self, banner=None):
1218 def interact(self, banner=None):
1212 """Closely emulate the interactive Python console.
1219 """Closely emulate the interactive Python console.
1213
1220
1214 The optional banner argument specify the banner to print
1221 The optional banner argument specify the banner to print
1215 before the first interaction; by default it prints a banner
1222 before the first interaction; by default it prints a banner
1216 similar to the one printed by the real Python interpreter,
1223 similar to the one printed by the real Python interpreter,
1217 followed by the current class name in parentheses (so as not
1224 followed by the current class name in parentheses (so as not
1218 to confuse this with the real interpreter -- since it's so
1225 to confuse this with the real interpreter -- since it's so
1219 close!).
1226 close!).
1220
1227
1221 """
1228 """
1222 cprt = 'Type "copyright", "credits" or "license" for more information.'
1229 cprt = 'Type "copyright", "credits" or "license" for more information.'
1223 if banner is None:
1230 if banner is None:
1224 self.write("Python %s on %s\n%s\n(%s)\n" %
1231 self.write("Python %s on %s\n%s\n(%s)\n" %
1225 (sys.version, sys.platform, cprt,
1232 (sys.version, sys.platform, cprt,
1226 self.__class__.__name__))
1233 self.__class__.__name__))
1227 else:
1234 else:
1228 self.write(banner)
1235 self.write(banner)
1229
1236
1230 more = 0
1237 more = 0
1231
1238
1232 # Mark activity in the builtins
1239 # Mark activity in the builtins
1233 __builtin__.__dict__['__IPYTHON__active'] += 1
1240 __builtin__.__dict__['__IPYTHON__active'] += 1
1234
1241
1235 # compiled regexps for autoindent management
1242 # compiled regexps for autoindent management
1236 ini_spaces_re = re.compile(r'^(\s+)')
1243 ini_spaces_re = re.compile(r'^(\s+)')
1237 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
1244 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
1238
1245
1239 # exit_now is set by a call to %Exit or %Quit
1246 # exit_now is set by a call to %Exit or %Quit
1240 while not self.exit_now:
1247 while not self.exit_now:
1241 try:
1248 try:
1242 if more:
1249 if more:
1243 prompt = self.outputcache.prompt2
1250 prompt = self.outputcache.prompt2
1244 if self.autoindent:
1251 if self.autoindent:
1245 self.readline_startup_hook(self.pre_readline)
1252 self.readline_startup_hook(self.pre_readline)
1246 else:
1253 else:
1247 prompt = self.outputcache.prompt1
1254 prompt = self.outputcache.prompt1
1248 try:
1255 try:
1249 line = self.raw_input(prompt,more)
1256 line = self.raw_input(prompt,more)
1250 if self.autoindent:
1257 if self.autoindent:
1251 self.readline_startup_hook(None)
1258 self.readline_startup_hook(None)
1252 except EOFError:
1259 except EOFError:
1253 if self.autoindent:
1260 if self.autoindent:
1254 self.readline_startup_hook(None)
1261 self.readline_startup_hook(None)
1255 self.write("\n")
1262 self.write("\n")
1256 self.exit()
1263 self.exit()
1257 else:
1264 else:
1258 more = self.push(line)
1265 more = self.push(line)
1259 # Auto-indent management
1266 # Auto-indent management
1260 if self.autoindent:
1267 if self.autoindent:
1261 if line:
1268 if line:
1262 ini_spaces = ini_spaces_re.match(line)
1269 ini_spaces = ini_spaces_re.match(line)
1263 if ini_spaces:
1270 if ini_spaces:
1264 nspaces = ini_spaces.end()
1271 nspaces = ini_spaces.end()
1265 else:
1272 else:
1266 nspaces = 0
1273 nspaces = 0
1267 self.indent_current_nsp = nspaces
1274 self.indent_current_nsp = nspaces
1268
1275
1269 if line[-1] == ':':
1276 if line[-1] == ':':
1270 self.indent_current_nsp += 4
1277 self.indent_current_nsp += 4
1271 elif dedent_re.match(line):
1278 elif dedent_re.match(line):
1272 self.indent_current_nsp -= 4
1279 self.indent_current_nsp -= 4
1273 else:
1280 else:
1274 self.indent_current_nsp = 0
1281 self.indent_current_nsp = 0
1275
1282
1276 # indent_current is the actual string to be inserted
1283 # indent_current is the actual string to be inserted
1277 # by the readline hooks for indentation
1284 # by the readline hooks for indentation
1278 self.indent_current = ' '* self.indent_current_nsp
1285 self.indent_current = ' '* self.indent_current_nsp
1279
1286
1280 if (self.SyntaxTB.last_syntax_error and
1287 if (self.SyntaxTB.last_syntax_error and
1281 self.rc.autoedit_syntax):
1288 self.rc.autoedit_syntax):
1282 self.edit_syntax_error()
1289 self.edit_syntax_error()
1283
1290
1284 except KeyboardInterrupt:
1291 except KeyboardInterrupt:
1285 self.write("\nKeyboardInterrupt\n")
1292 self.write("\nKeyboardInterrupt\n")
1286 self.resetbuffer()
1293 self.resetbuffer()
1287 more = 0
1294 more = 0
1288 # keep cache in sync with the prompt counter:
1295 # keep cache in sync with the prompt counter:
1289 self.outputcache.prompt_count -= 1
1296 self.outputcache.prompt_count -= 1
1290
1297
1291 if self.autoindent:
1298 if self.autoindent:
1292 self.indent_current_nsp = 0
1299 self.indent_current_nsp = 0
1293 self.indent_current = ' '* self.indent_current_nsp
1300 self.indent_current = ' '* self.indent_current_nsp
1294
1301
1295 except bdb.BdbQuit:
1302 except bdb.BdbQuit:
1296 warn("The Python debugger has exited with a BdbQuit exception.\n"
1303 warn("The Python debugger has exited with a BdbQuit exception.\n"
1297 "Because of how pdb handles the stack, it is impossible\n"
1304 "Because of how pdb handles the stack, it is impossible\n"
1298 "for IPython to properly format this particular exception.\n"
1305 "for IPython to properly format this particular exception.\n"
1299 "IPython will resume normal operation.")
1306 "IPython will resume normal operation.")
1300
1307
1301 # We are off again...
1308 # We are off again...
1302 __builtin__.__dict__['__IPYTHON__active'] -= 1
1309 __builtin__.__dict__['__IPYTHON__active'] -= 1
1303
1310
1304 def excepthook(self, type, value, tb):
1311 def excepthook(self, type, value, tb):
1305 """One more defense for GUI apps that call sys.excepthook.
1312 """One more defense for GUI apps that call sys.excepthook.
1306
1313
1307 GUI frameworks like wxPython trap exceptions and call
1314 GUI frameworks like wxPython trap exceptions and call
1308 sys.excepthook themselves. I guess this is a feature that
1315 sys.excepthook themselves. I guess this is a feature that
1309 enables them to keep running after exceptions that would
1316 enables them to keep running after exceptions that would
1310 otherwise kill their mainloop. This is a bother for IPython
1317 otherwise kill their mainloop. This is a bother for IPython
1311 which excepts to catch all of the program exceptions with a try:
1318 which excepts to catch all of the program exceptions with a try:
1312 except: statement.
1319 except: statement.
1313
1320
1314 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1321 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1315 any app directly invokes sys.excepthook, it will look to the user like
1322 any app directly invokes sys.excepthook, it will look to the user like
1316 IPython crashed. In order to work around this, we can disable the
1323 IPython crashed. In order to work around this, we can disable the
1317 CrashHandler and replace it with this excepthook instead, which prints a
1324 CrashHandler and replace it with this excepthook instead, which prints a
1318 regular traceback using our InteractiveTB. In this fashion, apps which
1325 regular traceback using our InteractiveTB. In this fashion, apps which
1319 call sys.excepthook will generate a regular-looking exception from
1326 call sys.excepthook will generate a regular-looking exception from
1320 IPython, and the CrashHandler will only be triggered by real IPython
1327 IPython, and the CrashHandler will only be triggered by real IPython
1321 crashes.
1328 crashes.
1322
1329
1323 This hook should be used sparingly, only in places which are not likely
1330 This hook should be used sparingly, only in places which are not likely
1324 to be true IPython errors.
1331 to be true IPython errors.
1325 """
1332 """
1326
1333
1327 self.InteractiveTB(type, value, tb, tb_offset=0)
1334 self.InteractiveTB(type, value, tb, tb_offset=0)
1328 if self.InteractiveTB.call_pdb and self.has_readline:
1335 if self.InteractiveTB.call_pdb and self.has_readline:
1329 self.readline.set_completer(self.Completer.complete)
1336 self.readline.set_completer(self.Completer.complete)
1330
1337
1331 def call_alias(self,alias,rest=''):
1338 def call_alias(self,alias,rest=''):
1332 """Call an alias given its name and the rest of the line.
1339 """Call an alias given its name and the rest of the line.
1333
1340
1334 This function MUST be given a proper alias, because it doesn't make
1341 This function MUST be given a proper alias, because it doesn't make
1335 any checks when looking up into the alias table. The caller is
1342 any checks when looking up into the alias table. The caller is
1336 responsible for invoking it only with a valid alias."""
1343 responsible for invoking it only with a valid alias."""
1337
1344
1338 #print 'ALIAS: <%s>+<%s>' % (alias,rest) # dbg
1345 #print 'ALIAS: <%s>+<%s>' % (alias,rest) # dbg
1339 nargs,cmd = self.alias_table[alias]
1346 nargs,cmd = self.alias_table[alias]
1340 # Expand the %l special to be the user's input line
1347 # Expand the %l special to be the user's input line
1341 if cmd.find('%l') >= 0:
1348 if cmd.find('%l') >= 0:
1342 cmd = cmd.replace('%l',rest)
1349 cmd = cmd.replace('%l',rest)
1343 rest = ''
1350 rest = ''
1344 if nargs==0:
1351 if nargs==0:
1345 # Simple, argument-less aliases
1352 # Simple, argument-less aliases
1346 cmd = '%s %s' % (cmd,rest)
1353 cmd = '%s %s' % (cmd,rest)
1347 else:
1354 else:
1348 # Handle aliases with positional arguments
1355 # Handle aliases with positional arguments
1349 args = rest.split(None,nargs)
1356 args = rest.split(None,nargs)
1350 if len(args)< nargs:
1357 if len(args)< nargs:
1351 error('Alias <%s> requires %s arguments, %s given.' %
1358 error('Alias <%s> requires %s arguments, %s given.' %
1352 (alias,nargs,len(args)))
1359 (alias,nargs,len(args)))
1353 return
1360 return
1354 cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))
1361 cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))
1355 # Now call the macro, evaluating in the user's namespace
1362 # Now call the macro, evaluating in the user's namespace
1356 try:
1363 try:
1357 self.system(cmd)
1364 self.system(cmd)
1358 except:
1365 except:
1359 self.showtraceback()
1366 self.showtraceback()
1360
1367
1361 def runlines(self,lines):
1368 def runlines(self,lines):
1362 """Run a string of one or more lines of source.
1369 """Run a string of one or more lines of source.
1363
1370
1364 This method is capable of running a string containing multiple source
1371 This method is capable of running a string containing multiple source
1365 lines, as if they had been entered at the IPython prompt. Since it
1372 lines, as if they had been entered at the IPython prompt. Since it
1366 exposes IPython's processing machinery, the given strings can contain
1373 exposes IPython's processing machinery, the given strings can contain
1367 magic calls (%magic), special shell access (!cmd), etc."""
1374 magic calls (%magic), special shell access (!cmd), etc."""
1368
1375
1369 # We must start with a clean buffer, in case this is run from an
1376 # We must start with a clean buffer, in case this is run from an
1370 # interactive IPython session (via a magic, for example).
1377 # interactive IPython session (via a magic, for example).
1371 self.resetbuffer()
1378 self.resetbuffer()
1372 lines = lines.split('\n')
1379 lines = lines.split('\n')
1373 more = 0
1380 more = 0
1374 for line in lines:
1381 for line in lines:
1375 # skip blank lines so we don't mess up the prompt counter, but do
1382 # skip blank lines so we don't mess up the prompt counter, but do
1376 # NOT skip even a blank line if we are in a code block (more is
1383 # NOT skip even a blank line if we are in a code block (more is
1377 # true)
1384 # true)
1378 if line or more:
1385 if line or more:
1379 more = self.push((self.prefilter(line,more)))
1386 more = self.push((self.prefilter(line,more)))
1380 # IPython's runsource returns None if there was an error
1387 # IPython's runsource returns None if there was an error
1381 # compiling the code. This allows us to stop processing right
1388 # compiling the code. This allows us to stop processing right
1382 # away, so the user gets the error message at the right place.
1389 # away, so the user gets the error message at the right place.
1383 if more is None:
1390 if more is None:
1384 break
1391 break
1385 # final newline in case the input didn't have it, so that the code
1392 # final newline in case the input didn't have it, so that the code
1386 # actually does get executed
1393 # actually does get executed
1387 if more:
1394 if more:
1388 self.push('\n')
1395 self.push('\n')
1389
1396
1390 def runsource(self, source, filename='<input>', symbol='single'):
1397 def runsource(self, source, filename='<input>', symbol='single'):
1391 """Compile and run some source in the interpreter.
1398 """Compile and run some source in the interpreter.
1392
1399
1393 Arguments are as for compile_command().
1400 Arguments are as for compile_command().
1394
1401
1395 One several things can happen:
1402 One several things can happen:
1396
1403
1397 1) The input is incorrect; compile_command() raised an
1404 1) The input is incorrect; compile_command() raised an
1398 exception (SyntaxError or OverflowError). A syntax traceback
1405 exception (SyntaxError or OverflowError). A syntax traceback
1399 will be printed by calling the showsyntaxerror() method.
1406 will be printed by calling the showsyntaxerror() method.
1400
1407
1401 2) The input is incomplete, and more input is required;
1408 2) The input is incomplete, and more input is required;
1402 compile_command() returned None. Nothing happens.
1409 compile_command() returned None. Nothing happens.
1403
1410
1404 3) The input is complete; compile_command() returned a code
1411 3) The input is complete; compile_command() returned a code
1405 object. The code is executed by calling self.runcode() (which
1412 object. The code is executed by calling self.runcode() (which
1406 also handles run-time exceptions, except for SystemExit).
1413 also handles run-time exceptions, except for SystemExit).
1407
1414
1408 The return value is:
1415 The return value is:
1409
1416
1410 - True in case 2
1417 - True in case 2
1411
1418
1412 - False in the other cases, unless an exception is raised, where
1419 - False in the other cases, unless an exception is raised, where
1413 None is returned instead. This can be used by external callers to
1420 None is returned instead. This can be used by external callers to
1414 know whether to continue feeding input or not.
1421 know whether to continue feeding input or not.
1415
1422
1416 The return value can be used to decide whether to use sys.ps1 or
1423 The return value can be used to decide whether to use sys.ps1 or
1417 sys.ps2 to prompt the next line."""
1424 sys.ps2 to prompt the next line."""
1418
1425
1419 try:
1426 try:
1420 code = self.compile(source,filename,symbol)
1427 code = self.compile(source,filename,symbol)
1421 except (OverflowError, SyntaxError, ValueError):
1428 except (OverflowError, SyntaxError, ValueError):
1422 # Case 1
1429 # Case 1
1423 self.showsyntaxerror(filename)
1430 self.showsyntaxerror(filename)
1424 return None
1431 return None
1425
1432
1426 if code is None:
1433 if code is None:
1427 # Case 2
1434 # Case 2
1428 return True
1435 return True
1429
1436
1430 # Case 3
1437 # Case 3
1431 # We store the code object so that threaded shells and
1438 # We store the code object so that threaded shells and
1432 # custom exception handlers can access all this info if needed.
1439 # custom exception handlers can access all this info if needed.
1433 # The source corresponding to this can be obtained from the
1440 # The source corresponding to this can be obtained from the
1434 # buffer attribute as '\n'.join(self.buffer).
1441 # buffer attribute as '\n'.join(self.buffer).
1435 self.code_to_run = code
1442 self.code_to_run = code
1436 # now actually execute the code object
1443 # now actually execute the code object
1437 if self.runcode(code) == 0:
1444 if self.runcode(code) == 0:
1438 return False
1445 return False
1439 else:
1446 else:
1440 return None
1447 return None
1441
1448
1442 def runcode(self,code_obj):
1449 def runcode(self,code_obj):
1443 """Execute a code object.
1450 """Execute a code object.
1444
1451
1445 When an exception occurs, self.showtraceback() is called to display a
1452 When an exception occurs, self.showtraceback() is called to display a
1446 traceback.
1453 traceback.
1447
1454
1448 Return value: a flag indicating whether the code to be run completed
1455 Return value: a flag indicating whether the code to be run completed
1449 successfully:
1456 successfully:
1450
1457
1451 - 0: successful execution.
1458 - 0: successful execution.
1452 - 1: an error occurred.
1459 - 1: an error occurred.
1453 """
1460 """
1454
1461
1455 # Set our own excepthook in case the user code tries to call it
1462 # Set our own excepthook in case the user code tries to call it
1456 # directly, so that the IPython crash handler doesn't get triggered
1463 # directly, so that the IPython crash handler doesn't get triggered
1457 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
1464 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
1458 outflag = 1 # happens in more places, so it's easier as default
1465 outflag = 1 # happens in more places, so it's easier as default
1459 try:
1466 try:
1460 try:
1467 try:
1461 # Embedded instances require separate global/local namespaces
1468 # Embedded instances require separate global/local namespaces
1462 # so they can see both the surrounding (local) namespace and
1469 # so they can see both the surrounding (local) namespace and
1463 # the module-level globals when called inside another function.
1470 # the module-level globals when called inside another function.
1464 if self.embedded:
1471 if self.embedded:
1465 exec code_obj in self.user_global_ns, self.user_ns
1472 exec code_obj in self.user_global_ns, self.user_ns
1466 # Normal (non-embedded) instances should only have a single
1473 # Normal (non-embedded) instances should only have a single
1467 # namespace for user code execution, otherwise functions won't
1474 # namespace for user code execution, otherwise functions won't
1468 # see interactive top-level globals.
1475 # see interactive top-level globals.
1469 else:
1476 else:
1470 exec code_obj in self.user_ns
1477 exec code_obj in self.user_ns
1471 finally:
1478 finally:
1472 # Reset our crash handler in place
1479 # Reset our crash handler in place
1473 sys.excepthook = old_excepthook
1480 sys.excepthook = old_excepthook
1474 except SystemExit:
1481 except SystemExit:
1475 self.resetbuffer()
1482 self.resetbuffer()
1476 self.showtraceback()
1483 self.showtraceback()
1477 warn("Type exit or quit to exit IPython "
1484 warn("Type exit or quit to exit IPython "
1478 "(%Exit or %Quit do so unconditionally).",level=1)
1485 "(%Exit or %Quit do so unconditionally).",level=1)
1479 except self.custom_exceptions:
1486 except self.custom_exceptions:
1480 etype,value,tb = sys.exc_info()
1487 etype,value,tb = sys.exc_info()
1481 self.CustomTB(etype,value,tb)
1488 self.CustomTB(etype,value,tb)
1482 except:
1489 except:
1483 self.showtraceback()
1490 self.showtraceback()
1484 else:
1491 else:
1485 outflag = 0
1492 outflag = 0
1486 if softspace(sys.stdout, 0):
1493 if softspace(sys.stdout, 0):
1487 print
1494 print
1488 # Flush out code object which has been run (and source)
1495 # Flush out code object which has been run (and source)
1489 self.code_to_run = None
1496 self.code_to_run = None
1490 return outflag
1497 return outflag
1491
1498
1492 def push(self, line):
1499 def push(self, line):
1493 """Push a line to the interpreter.
1500 """Push a line to the interpreter.
1494
1501
1495 The line should not have a trailing newline; it may have
1502 The line should not have a trailing newline; it may have
1496 internal newlines. The line is appended to a buffer and the
1503 internal newlines. The line is appended to a buffer and the
1497 interpreter's runsource() method is called with the
1504 interpreter's runsource() method is called with the
1498 concatenated contents of the buffer as source. If this
1505 concatenated contents of the buffer as source. If this
1499 indicates that the command was executed or invalid, the buffer
1506 indicates that the command was executed or invalid, the buffer
1500 is reset; otherwise, the command is incomplete, and the buffer
1507 is reset; otherwise, the command is incomplete, and the buffer
1501 is left as it was after the line was appended. The return
1508 is left as it was after the line was appended. The return
1502 value is 1 if more input is required, 0 if the line was dealt
1509 value is 1 if more input is required, 0 if the line was dealt
1503 with in some way (this is the same as runsource()).
1510 with in some way (this is the same as runsource()).
1504
1511
1505 """
1512 """
1506 self.buffer.append(line)
1513 self.buffer.append(line)
1507 more = self.runsource('\n'.join(self.buffer), self.filename)
1514 more = self.runsource('\n'.join(self.buffer), self.filename)
1508 if not more:
1515 if not more:
1509 self.resetbuffer()
1516 self.resetbuffer()
1510 return more
1517 return more
1511
1518
1512 def resetbuffer(self):
1519 def resetbuffer(self):
1513 """Reset the input buffer."""
1520 """Reset the input buffer."""
1514 self.buffer[:] = []
1521 self.buffer[:] = []
1515
1522
1516 def raw_input(self,prompt='',continue_prompt=False):
1523 def raw_input(self,prompt='',continue_prompt=False):
1517 """Write a prompt and read a line.
1524 """Write a prompt and read a line.
1518
1525
1519 The returned line does not include the trailing newline.
1526 The returned line does not include the trailing newline.
1520 When the user enters the EOF key sequence, EOFError is raised.
1527 When the user enters the EOF key sequence, EOFError is raised.
1521
1528
1522 Optional inputs:
1529 Optional inputs:
1523
1530
1524 - prompt(''): a string to be printed to prompt the user.
1531 - prompt(''): a string to be printed to prompt the user.
1525
1532
1526 - continue_prompt(False): whether this line is the first one or a
1533 - continue_prompt(False): whether this line is the first one or a
1527 continuation in a sequence of inputs.
1534 continuation in a sequence of inputs.
1528 """
1535 """
1529
1536
1530 line = raw_input_original(prompt)
1537 line = raw_input_original(prompt)
1531 # Try to be reasonably smart about not re-indenting pasted input more
1538 # Try to be reasonably smart about not re-indenting pasted input more
1532 # than necessary. We do this by trimming out the auto-indent initial
1539 # than necessary. We do this by trimming out the auto-indent initial
1533 # spaces, if the user's actual input started itself with whitespace.
1540 # spaces, if the user's actual input started itself with whitespace.
1534 if self.autoindent:
1541 if self.autoindent:
1535 line2 = line[self.indent_current_nsp:]
1542 line2 = line[self.indent_current_nsp:]
1536 if line2[0:1] in (' ','\t'):
1543 if line2[0:1] in (' ','\t'):
1537 line = line2
1544 line = line2
1538 return self.prefilter(line,continue_prompt)
1545 return self.prefilter(line,continue_prompt)
1539
1546
1540 def split_user_input(self,line):
1547 def split_user_input(self,line):
1541 """Split user input into pre-char, function part and rest."""
1548 """Split user input into pre-char, function part and rest."""
1542
1549
1543 lsplit = self.line_split.match(line)
1550 lsplit = self.line_split.match(line)
1544 if lsplit is None: # no regexp match returns None
1551 if lsplit is None: # no regexp match returns None
1545 try:
1552 try:
1546 iFun,theRest = line.split(None,1)
1553 iFun,theRest = line.split(None,1)
1547 except ValueError:
1554 except ValueError:
1548 iFun,theRest = line,''
1555 iFun,theRest = line,''
1549 pre = re.match('^(\s*)(.*)',line).groups()[0]
1556 pre = re.match('^(\s*)(.*)',line).groups()[0]
1550 else:
1557 else:
1551 pre,iFun,theRest = lsplit.groups()
1558 pre,iFun,theRest = lsplit.groups()
1552
1559
1553 #print 'line:<%s>' % line # dbg
1560 #print 'line:<%s>' % line # dbg
1554 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun.strip(),theRest) # dbg
1561 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun.strip(),theRest) # dbg
1555 return pre,iFun.strip(),theRest
1562 return pre,iFun.strip(),theRest
1556
1563
1557 def _prefilter(self, line, continue_prompt):
1564 def _prefilter(self, line, continue_prompt):
1558 """Calls different preprocessors, depending on the form of line."""
1565 """Calls different preprocessors, depending on the form of line."""
1559
1566
1560 # All handlers *must* return a value, even if it's blank ('').
1567 # All handlers *must* return a value, even if it's blank ('').
1561
1568
1562 # Lines are NOT logged here. Handlers should process the line as
1569 # Lines are NOT logged here. Handlers should process the line as
1563 # needed, update the cache AND log it (so that the input cache array
1570 # needed, update the cache AND log it (so that the input cache array
1564 # stays synced).
1571 # stays synced).
1565
1572
1566 # This function is _very_ delicate, and since it's also the one which
1573 # This function is _very_ delicate, and since it's also the one which
1567 # determines IPython's response to user input, it must be as efficient
1574 # determines IPython's response to user input, it must be as efficient
1568 # as possible. For this reason it has _many_ returns in it, trying
1575 # as possible. For this reason it has _many_ returns in it, trying
1569 # always to exit as quickly as it can figure out what it needs to do.
1576 # always to exit as quickly as it can figure out what it needs to do.
1570
1577
1571 # This function is the main responsible for maintaining IPython's
1578 # This function is the main responsible for maintaining IPython's
1572 # behavior respectful of Python's semantics. So be _very_ careful if
1579 # behavior respectful of Python's semantics. So be _very_ careful if
1573 # making changes to anything here.
1580 # making changes to anything here.
1574
1581
1575 #.....................................................................
1582 #.....................................................................
1576 # Code begins
1583 # Code begins
1577
1584
1578 #if line.startswith('%crash'): raise RuntimeError,'Crash now!' # dbg
1585 #if line.startswith('%crash'): raise RuntimeError,'Crash now!' # dbg
1579
1586
1580 # save the line away in case we crash, so the post-mortem handler can
1587 # save the line away in case we crash, so the post-mortem handler can
1581 # record it
1588 # record it
1582 self._last_input_line = line
1589 self._last_input_line = line
1583
1590
1584 #print '***line: <%s>' % line # dbg
1591 #print '***line: <%s>' % line # dbg
1585
1592
1586 # the input history needs to track even empty lines
1593 # the input history needs to track even empty lines
1587 if not line.strip():
1594 if not line.strip():
1588 if not continue_prompt:
1595 if not continue_prompt:
1589 self.outputcache.prompt_count -= 1
1596 self.outputcache.prompt_count -= 1
1590 return self.handle_normal(line,continue_prompt)
1597 return self.handle_normal(line,continue_prompt)
1591 #return self.handle_normal('',continue_prompt)
1598 #return self.handle_normal('',continue_prompt)
1592
1599
1593 # print '***cont',continue_prompt # dbg
1600 # print '***cont',continue_prompt # dbg
1594 # special handlers are only allowed for single line statements
1601 # special handlers are only allowed for single line statements
1595 if continue_prompt and not self.rc.multi_line_specials:
1602 if continue_prompt and not self.rc.multi_line_specials:
1596 return self.handle_normal(line,continue_prompt)
1603 return self.handle_normal(line,continue_prompt)
1597
1604
1598 # For the rest, we need the structure of the input
1605 # For the rest, we need the structure of the input
1599 pre,iFun,theRest = self.split_user_input(line)
1606 pre,iFun,theRest = self.split_user_input(line)
1600 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
1607 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
1601
1608
1602 # First check for explicit escapes in the last/first character
1609 # First check for explicit escapes in the last/first character
1603 handler = None
1610 handler = None
1604 if line[-1] == self.ESC_HELP:
1611 if line[-1] == self.ESC_HELP:
1605 handler = self.esc_handlers.get(line[-1]) # the ? can be at the end
1612 handler = self.esc_handlers.get(line[-1]) # the ? can be at the end
1606 if handler is None:
1613 if handler is None:
1607 # look at the first character of iFun, NOT of line, so we skip
1614 # look at the first character of iFun, NOT of line, so we skip
1608 # leading whitespace in multiline input
1615 # leading whitespace in multiline input
1609 handler = self.esc_handlers.get(iFun[0:1])
1616 handler = self.esc_handlers.get(iFun[0:1])
1610 if handler is not None:
1617 if handler is not None:
1611 return handler(line,continue_prompt,pre,iFun,theRest)
1618 return handler(line,continue_prompt,pre,iFun,theRest)
1612 # Emacs ipython-mode tags certain input lines
1619 # Emacs ipython-mode tags certain input lines
1613 if line.endswith('# PYTHON-MODE'):
1620 if line.endswith('# PYTHON-MODE'):
1614 return self.handle_emacs(line,continue_prompt)
1621 return self.handle_emacs(line,continue_prompt)
1615
1622
1616 # Next, check if we can automatically execute this thing
1623 # Next, check if we can automatically execute this thing
1617
1624
1618 # Allow ! in multi-line statements if multi_line_specials is on:
1625 # Allow ! in multi-line statements if multi_line_specials is on:
1619 if continue_prompt and self.rc.multi_line_specials and \
1626 if continue_prompt and self.rc.multi_line_specials and \
1620 iFun.startswith(self.ESC_SHELL):
1627 iFun.startswith(self.ESC_SHELL):
1621 return self.handle_shell_escape(line,continue_prompt,
1628 return self.handle_shell_escape(line,continue_prompt,
1622 pre=pre,iFun=iFun,
1629 pre=pre,iFun=iFun,
1623 theRest=theRest)
1630 theRest=theRest)
1624
1631
1625 # Let's try to find if the input line is a magic fn
1632 # Let's try to find if the input line is a magic fn
1626 oinfo = None
1633 oinfo = None
1627 if hasattr(self,'magic_'+iFun):
1634 if hasattr(self,'magic_'+iFun):
1628 oinfo = self._ofind(iFun) # FIXME - _ofind is part of Magic
1635 oinfo = self._ofind(iFun) # FIXME - _ofind is part of Magic
1629 if oinfo['ismagic']:
1636 if oinfo['ismagic']:
1630 # Be careful not to call magics when a variable assignment is
1637 # Be careful not to call magics when a variable assignment is
1631 # being made (ls='hi', for example)
1638 # being made (ls='hi', for example)
1632 if self.rc.automagic and \
1639 if self.rc.automagic and \
1633 (len(theRest)==0 or theRest[0] not in '!=()<>,') and \
1640 (len(theRest)==0 or theRest[0] not in '!=()<>,') and \
1634 (self.rc.multi_line_specials or not continue_prompt):
1641 (self.rc.multi_line_specials or not continue_prompt):
1635 return self.handle_magic(line,continue_prompt,
1642 return self.handle_magic(line,continue_prompt,
1636 pre,iFun,theRest)
1643 pre,iFun,theRest)
1637 else:
1644 else:
1638 return self.handle_normal(line,continue_prompt)
1645 return self.handle_normal(line,continue_prompt)
1639
1646
1640 # If the rest of the line begins with an (in)equality, assginment or
1647 # If the rest of the line begins with an (in)equality, assginment or
1641 # function call, we should not call _ofind but simply execute it.
1648 # function call, we should not call _ofind but simply execute it.
1642 # This avoids spurious geattr() accesses on objects upon assignment.
1649 # This avoids spurious geattr() accesses on objects upon assignment.
1643 #
1650 #
1644 # It also allows users to assign to either alias or magic names true
1651 # It also allows users to assign to either alias or magic names true
1645 # python variables (the magic/alias systems always take second seat to
1652 # python variables (the magic/alias systems always take second seat to
1646 # true python code).
1653 # true python code).
1647 if theRest and theRest[0] in '!=()':
1654 if theRest and theRest[0] in '!=()':
1648 return self.handle_normal(line,continue_prompt)
1655 return self.handle_normal(line,continue_prompt)
1649
1656
1650 if oinfo is None:
1657 if oinfo is None:
1651 oinfo = self._ofind(iFun) # FIXME - _ofind is part of Magic
1658 oinfo = self._ofind(iFun) # FIXME - _ofind is part of Magic
1652
1659
1653 if not oinfo['found']:
1660 if not oinfo['found']:
1654 return self.handle_normal(line,continue_prompt)
1661 return self.handle_normal(line,continue_prompt)
1655 else:
1662 else:
1656 #print 'iFun <%s> rest <%s>' % (iFun,theRest) # dbg
1663 #print 'iFun <%s> rest <%s>' % (iFun,theRest) # dbg
1657 if oinfo['isalias']:
1664 if oinfo['isalias']:
1658 return self.handle_alias(line,continue_prompt,
1665 return self.handle_alias(line,continue_prompt,
1659 pre,iFun,theRest)
1666 pre,iFun,theRest)
1660
1667
1661 if self.rc.autocall and \
1668 if self.rc.autocall and \
1662 not self.re_exclude_auto.match(theRest) and \
1669 not self.re_exclude_auto.match(theRest) and \
1663 self.re_fun_name.match(iFun) and \
1670 self.re_fun_name.match(iFun) and \
1664 callable(oinfo['obj']) :
1671 callable(oinfo['obj']) :
1665 #print 'going auto' # dbg
1672 #print 'going auto' # dbg
1666 return self.handle_auto(line,continue_prompt,pre,iFun,theRest)
1673 return self.handle_auto(line,continue_prompt,pre,iFun,theRest)
1667 else:
1674 else:
1668 #print 'was callable?', callable(oinfo['obj']) # dbg
1675 #print 'was callable?', callable(oinfo['obj']) # dbg
1669 return self.handle_normal(line,continue_prompt)
1676 return self.handle_normal(line,continue_prompt)
1670
1677
1671 # If we get here, we have a normal Python line. Log and return.
1678 # If we get here, we have a normal Python line. Log and return.
1672 return self.handle_normal(line,continue_prompt)
1679 return self.handle_normal(line,continue_prompt)
1673
1680
1674 def _prefilter_dumb(self, line, continue_prompt):
1681 def _prefilter_dumb(self, line, continue_prompt):
1675 """simple prefilter function, for debugging"""
1682 """simple prefilter function, for debugging"""
1676 return self.handle_normal(line,continue_prompt)
1683 return self.handle_normal(line,continue_prompt)
1677
1684
1678 # Set the default prefilter() function (this can be user-overridden)
1685 # Set the default prefilter() function (this can be user-overridden)
1679 prefilter = _prefilter
1686 prefilter = _prefilter
1680
1687
1681 def handle_normal(self,line,continue_prompt=None,
1688 def handle_normal(self,line,continue_prompt=None,
1682 pre=None,iFun=None,theRest=None):
1689 pre=None,iFun=None,theRest=None):
1683 """Handle normal input lines. Use as a template for handlers."""
1690 """Handle normal input lines. Use as a template for handlers."""
1684
1691
1685 # With autoindent on, we need some way to exit the input loop, and I
1692 # With autoindent on, we need some way to exit the input loop, and I
1686 # don't want to force the user to have to backspace all the way to
1693 # don't want to force the user to have to backspace all the way to
1687 # clear the line. The rule will be in this case, that either two
1694 # clear the line. The rule will be in this case, that either two
1688 # lines of pure whitespace in a row, or a line of pure whitespace but
1695 # lines of pure whitespace in a row, or a line of pure whitespace but
1689 # of a size different to the indent level, will exit the input loop.
1696 # of a size different to the indent level, will exit the input loop.
1690 if (continue_prompt and self.autoindent and isspace(line) and
1697 if (continue_prompt and self.autoindent and isspace(line) and
1691 (line != self.indent_current or isspace(self.buffer[-1]))):
1698 (line != self.indent_current or isspace(self.buffer[-1]))):
1692 line = ''
1699 line = ''
1693
1700
1694 self.log(line,continue_prompt)
1701 self.log(line,continue_prompt)
1695 self.update_cache(line)
1702 self.update_cache(line)
1696 return line
1703 return line
1697
1704
1698 def handle_alias(self,line,continue_prompt=None,
1705 def handle_alias(self,line,continue_prompt=None,
1699 pre=None,iFun=None,theRest=None):
1706 pre=None,iFun=None,theRest=None):
1700 """Handle alias input lines. """
1707 """Handle alias input lines. """
1701
1708
1702 theRest = esc_quotes(theRest)
1709 theRest = esc_quotes(theRest)
1703 line_out = "%s%s.call_alias('%s','%s')" % (pre,self.name,iFun,theRest)
1710 line_out = "%s%s.call_alias('%s','%s')" % (pre,self.name,iFun,theRest)
1704 self.log(line_out,continue_prompt)
1711 self.log(line_out,continue_prompt)
1705 self.update_cache(line_out)
1712 self.update_cache(line_out)
1706 return line_out
1713 return line_out
1707
1714
1708 def handle_shell_escape(self, line, continue_prompt=None,
1715 def handle_shell_escape(self, line, continue_prompt=None,
1709 pre=None,iFun=None,theRest=None):
1716 pre=None,iFun=None,theRest=None):
1710 """Execute the line in a shell, empty return value"""
1717 """Execute the line in a shell, empty return value"""
1711
1718
1712 #print 'line in :', `line` # dbg
1719 #print 'line in :', `line` # dbg
1713 # Example of a special handler. Others follow a similar pattern.
1720 # Example of a special handler. Others follow a similar pattern.
1714 if continue_prompt: # multi-line statements
1721 if continue_prompt: # multi-line statements
1715 if iFun.startswith('!!'):
1722 if iFun.startswith('!!'):
1716 print 'SyntaxError: !! is not allowed in multiline statements'
1723 print 'SyntaxError: !! is not allowed in multiline statements'
1717 return pre
1724 return pre
1718 else:
1725 else:
1719 cmd = ("%s %s" % (iFun[1:],theRest)) #.replace('"','\\"')
1726 cmd = ("%s %s" % (iFun[1:],theRest)) #.replace('"','\\"')
1720 #line_out = '%s%s.system("%s")' % (pre,self.name,cmd)
1727 #line_out = '%s%s.system("%s")' % (pre,self.name,cmd)
1721 line_out = '%s%s.system(r"""%s"""[:-1])' % (pre,self.name,cmd + "_")
1728 line_out = '%s%s.system(r"""%s"""[:-1])' % (pre,self.name,cmd + "_")
1722 #line_out = ('%s%s.system(' % (pre,self.name)) + repr(cmd) + ')'
1729 #line_out = ('%s%s.system(' % (pre,self.name)) + repr(cmd) + ')'
1723 else: # single-line input
1730 else: # single-line input
1724 if line.startswith('!!'):
1731 if line.startswith('!!'):
1725 # rewrite iFun/theRest to properly hold the call to %sx and
1732 # rewrite iFun/theRest to properly hold the call to %sx and
1726 # the actual command to be executed, so handle_magic can work
1733 # the actual command to be executed, so handle_magic can work
1727 # correctly
1734 # correctly
1728 theRest = '%s %s' % (iFun[2:],theRest)
1735 theRest = '%s %s' % (iFun[2:],theRest)
1729 iFun = 'sx'
1736 iFun = 'sx'
1730 return self.handle_magic('%ssx %s' % (self.ESC_MAGIC,line[2:]),
1737 return self.handle_magic('%ssx %s' % (self.ESC_MAGIC,line[2:]),
1731 continue_prompt,pre,iFun,theRest)
1738 continue_prompt,pre,iFun,theRest)
1732 else:
1739 else:
1733 #cmd = esc_quotes(line[1:])
1740 #cmd = esc_quotes(line[1:])
1734 cmd=line[1:]
1741 cmd=line[1:]
1735 #line_out = '%s.system("%s")' % (self.name,cmd)
1742 #line_out = '%s.system("%s")' % (self.name,cmd)
1736 line_out = '%s.system(r"""%s"""[:-1])' % (self.name,cmd +"_")
1743 line_out = '%s.system(r"""%s"""[:-1])' % (self.name,cmd +"_")
1737 #line_out = ('%s.system(' % self.name) + repr(cmd)+ ')'
1744 #line_out = ('%s.system(' % self.name) + repr(cmd)+ ')'
1738 # update cache/log and return
1745 # update cache/log and return
1739 self.log(line_out,continue_prompt)
1746 self.log(line_out,continue_prompt)
1740 self.update_cache(line_out) # readline cache gets normal line
1747 self.update_cache(line_out) # readline cache gets normal line
1741 #print 'line out r:', `line_out` # dbg
1748 #print 'line out r:', `line_out` # dbg
1742 #print 'line out s:', line_out # dbg
1749 #print 'line out s:', line_out # dbg
1743 return line_out
1750 return line_out
1744
1751
1745 def handle_magic(self, line, continue_prompt=None,
1752 def handle_magic(self, line, continue_prompt=None,
1746 pre=None,iFun=None,theRest=None):
1753 pre=None,iFun=None,theRest=None):
1747 """Execute magic functions.
1754 """Execute magic functions.
1748
1755
1749 Also log them with a prepended # so the log is clean Python."""
1756 Also log them with a prepended # so the log is clean Python."""
1750
1757
1751 cmd = '%sipmagic("%s")' % (pre,esc_quotes('%s %s' % (iFun,theRest)))
1758 cmd = '%sipmagic("%s")' % (pre,esc_quotes('%s %s' % (iFun,theRest)))
1752 self.log(cmd,continue_prompt)
1759 self.log(cmd,continue_prompt)
1753 self.update_cache(line)
1760 self.update_cache(line)
1754 #print 'in handle_magic, cmd=<%s>' % cmd # dbg
1761 #print 'in handle_magic, cmd=<%s>' % cmd # dbg
1755 return cmd
1762 return cmd
1756
1763
1757 def handle_auto(self, line, continue_prompt=None,
1764 def handle_auto(self, line, continue_prompt=None,
1758 pre=None,iFun=None,theRest=None):
1765 pre=None,iFun=None,theRest=None):
1759 """Hande lines which can be auto-executed, quoting if requested."""
1766 """Hande lines which can be auto-executed, quoting if requested."""
1760
1767
1761 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
1768 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
1762
1769
1763 # This should only be active for single-line input!
1770 # This should only be active for single-line input!
1764 if continue_prompt:
1771 if continue_prompt:
1765 return line
1772 return line
1766
1773
1767 if pre == self.ESC_QUOTE:
1774 if pre == self.ESC_QUOTE:
1768 # Auto-quote splitting on whitespace
1775 # Auto-quote splitting on whitespace
1769 newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) )
1776 newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) )
1770 elif pre == self.ESC_QUOTE2:
1777 elif pre == self.ESC_QUOTE2:
1771 # Auto-quote whole string
1778 # Auto-quote whole string
1772 newcmd = '%s("%s")' % (iFun,theRest)
1779 newcmd = '%s("%s")' % (iFun,theRest)
1773 else:
1780 else:
1774 # Auto-paren
1781 # Auto-paren
1775 if theRest[0:1] in ('=','['):
1782 if theRest[0:1] in ('=','['):
1776 # Don't autocall in these cases. They can be either
1783 # Don't autocall in these cases. They can be either
1777 # rebindings of an existing callable's name, or item access
1784 # rebindings of an existing callable's name, or item access
1778 # for an object which is BOTH callable and implements
1785 # for an object which is BOTH callable and implements
1779 # __getitem__.
1786 # __getitem__.
1780 return '%s %s' % (iFun,theRest)
1787 return '%s %s' % (iFun,theRest)
1781 if theRest.endswith(';'):
1788 if theRest.endswith(';'):
1782 newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1])
1789 newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1])
1783 else:
1790 else:
1784 newcmd = '%s(%s)' % (iFun.rstrip(),theRest)
1791 newcmd = '%s(%s)' % (iFun.rstrip(),theRest)
1785
1792
1786 print >>Term.cout, self.outputcache.prompt1.auto_rewrite() + newcmd
1793 print >>Term.cout, self.outputcache.prompt1.auto_rewrite() + newcmd
1787 # log what is now valid Python, not the actual user input (without the
1794 # log what is now valid Python, not the actual user input (without the
1788 # final newline)
1795 # final newline)
1789 self.log(newcmd,continue_prompt)
1796 self.log(newcmd,continue_prompt)
1790 return newcmd
1797 return newcmd
1791
1798
1792 def handle_help(self, line, continue_prompt=None,
1799 def handle_help(self, line, continue_prompt=None,
1793 pre=None,iFun=None,theRest=None):
1800 pre=None,iFun=None,theRest=None):
1794 """Try to get some help for the object.
1801 """Try to get some help for the object.
1795
1802
1796 obj? or ?obj -> basic information.
1803 obj? or ?obj -> basic information.
1797 obj?? or ??obj -> more details.
1804 obj?? or ??obj -> more details.
1798 """
1805 """
1799
1806
1800 # We need to make sure that we don't process lines which would be
1807 # We need to make sure that we don't process lines which would be
1801 # otherwise valid python, such as "x=1 # what?"
1808 # otherwise valid python, such as "x=1 # what?"
1802 try:
1809 try:
1803 codeop.compile_command(line)
1810 codeop.compile_command(line)
1804 except SyntaxError:
1811 except SyntaxError:
1805 # We should only handle as help stuff which is NOT valid syntax
1812 # We should only handle as help stuff which is NOT valid syntax
1806 if line[0]==self.ESC_HELP:
1813 if line[0]==self.ESC_HELP:
1807 line = line[1:]
1814 line = line[1:]
1808 elif line[-1]==self.ESC_HELP:
1815 elif line[-1]==self.ESC_HELP:
1809 line = line[:-1]
1816 line = line[:-1]
1810 self.log('#?'+line)
1817 self.log('#?'+line)
1811 self.update_cache(line)
1818 self.update_cache(line)
1812 if line:
1819 if line:
1813 self.magic_pinfo(line)
1820 self.magic_pinfo(line)
1814 else:
1821 else:
1815 page(self.usage,screen_lines=self.rc.screen_length)
1822 page(self.usage,screen_lines=self.rc.screen_length)
1816 return '' # Empty string is needed here!
1823 return '' # Empty string is needed here!
1817 except:
1824 except:
1818 # Pass any other exceptions through to the normal handler
1825 # Pass any other exceptions through to the normal handler
1819 return self.handle_normal(line,continue_prompt)
1826 return self.handle_normal(line,continue_prompt)
1820 else:
1827 else:
1821 # If the code compiles ok, we should handle it normally
1828 # If the code compiles ok, we should handle it normally
1822 return self.handle_normal(line,continue_prompt)
1829 return self.handle_normal(line,continue_prompt)
1823
1830
1824 def handle_emacs(self,line,continue_prompt=None,
1831 def handle_emacs(self,line,continue_prompt=None,
1825 pre=None,iFun=None,theRest=None):
1832 pre=None,iFun=None,theRest=None):
1826 """Handle input lines marked by python-mode."""
1833 """Handle input lines marked by python-mode."""
1827
1834
1828 # Currently, nothing is done. Later more functionality can be added
1835 # Currently, nothing is done. Later more functionality can be added
1829 # here if needed.
1836 # here if needed.
1830
1837
1831 # The input cache shouldn't be updated
1838 # The input cache shouldn't be updated
1832
1839
1833 return line
1840 return line
1834
1841
1835 def write(self,data):
1842 def write(self,data):
1836 """Write a string to the default output"""
1843 """Write a string to the default output"""
1837 Term.cout.write(data)
1844 Term.cout.write(data)
1838
1845
1839 def write_err(self,data):
1846 def write_err(self,data):
1840 """Write a string to the default error output"""
1847 """Write a string to the default error output"""
1841 Term.cerr.write(data)
1848 Term.cerr.write(data)
1842
1849
1843 def exit(self):
1850 def exit(self):
1844 """Handle interactive exit.
1851 """Handle interactive exit.
1845
1852
1846 This method sets the exit_now attribute."""
1853 This method sets the exit_now attribute."""
1847
1854
1848 if self.rc.confirm_exit:
1855 if self.rc.confirm_exit:
1849 if ask_yes_no('Do you really want to exit ([y]/n)?','y'):
1856 if ask_yes_no('Do you really want to exit ([y]/n)?','y'):
1850 self.exit_now = True
1857 self.exit_now = True
1851 else:
1858 else:
1852 self.exit_now = True
1859 self.exit_now = True
1853 return self.exit_now
1860 return self.exit_now
1854
1861
1855 def safe_execfile(self,fname,*where,**kw):
1862 def safe_execfile(self,fname,*where,**kw):
1856 fname = os.path.expanduser(fname)
1863 fname = os.path.expanduser(fname)
1857
1864
1858 # find things also in current directory
1865 # find things also in current directory
1859 dname = os.path.dirname(fname)
1866 dname = os.path.dirname(fname)
1860 if not sys.path.count(dname):
1867 if not sys.path.count(dname):
1861 sys.path.append(dname)
1868 sys.path.append(dname)
1862
1869
1863 try:
1870 try:
1864 xfile = open(fname)
1871 xfile = open(fname)
1865 except:
1872 except:
1866 print >> Term.cerr, \
1873 print >> Term.cerr, \
1867 'Could not open file <%s> for safe execution.' % fname
1874 'Could not open file <%s> for safe execution.' % fname
1868 return None
1875 return None
1869
1876
1870 kw.setdefault('islog',0)
1877 kw.setdefault('islog',0)
1871 kw.setdefault('quiet',1)
1878 kw.setdefault('quiet',1)
1872 kw.setdefault('exit_ignore',0)
1879 kw.setdefault('exit_ignore',0)
1873 first = xfile.readline()
1880 first = xfile.readline()
1874 _LOGHEAD = str(self.LOGHEAD).split('\n',1)[0].strip()
1881 _LOGHEAD = str(self.LOGHEAD).split('\n',1)[0].strip()
1875 xfile.close()
1882 xfile.close()
1876 # line by line execution
1883 # line by line execution
1877 if first.startswith(_LOGHEAD) or kw['islog']:
1884 if first.startswith(_LOGHEAD) or kw['islog']:
1878 print 'Loading log file <%s> one line at a time...' % fname
1885 print 'Loading log file <%s> one line at a time...' % fname
1879 if kw['quiet']:
1886 if kw['quiet']:
1880 stdout_save = sys.stdout
1887 stdout_save = sys.stdout
1881 sys.stdout = StringIO.StringIO()
1888 sys.stdout = StringIO.StringIO()
1882 try:
1889 try:
1883 globs,locs = where[0:2]
1890 globs,locs = where[0:2]
1884 except:
1891 except:
1885 try:
1892 try:
1886 globs = locs = where[0]
1893 globs = locs = where[0]
1887 except:
1894 except:
1888 globs = locs = globals()
1895 globs = locs = globals()
1889 badblocks = []
1896 badblocks = []
1890
1897
1891 # we also need to identify indented blocks of code when replaying
1898 # we also need to identify indented blocks of code when replaying
1892 # logs and put them together before passing them to an exec
1899 # logs and put them together before passing them to an exec
1893 # statement. This takes a bit of regexp and look-ahead work in the
1900 # statement. This takes a bit of regexp and look-ahead work in the
1894 # file. It's easiest if we swallow the whole thing in memory
1901 # file. It's easiest if we swallow the whole thing in memory
1895 # first, and manually walk through the lines list moving the
1902 # first, and manually walk through the lines list moving the
1896 # counter ourselves.
1903 # counter ourselves.
1897 indent_re = re.compile('\s+\S')
1904 indent_re = re.compile('\s+\S')
1898 xfile = open(fname)
1905 xfile = open(fname)
1899 filelines = xfile.readlines()
1906 filelines = xfile.readlines()
1900 xfile.close()
1907 xfile.close()
1901 nlines = len(filelines)
1908 nlines = len(filelines)
1902 lnum = 0
1909 lnum = 0
1903 while lnum < nlines:
1910 while lnum < nlines:
1904 line = filelines[lnum]
1911 line = filelines[lnum]
1905 lnum += 1
1912 lnum += 1
1906 # don't re-insert logger status info into cache
1913 # don't re-insert logger status info into cache
1907 if line.startswith('#log#'):
1914 if line.startswith('#log#'):
1908 continue
1915 continue
1909 elif line.startswith('#%s'% self.ESC_MAGIC):
1916 elif line.startswith('#%s'% self.ESC_MAGIC):
1910 self.update_cache(line[1:])
1917 self.update_cache(line[1:])
1911 line = magic2python(line)
1918 line = magic2python(line)
1912 elif line.startswith('#!'):
1919 elif line.startswith('#!'):
1913 self.update_cache(line[1:])
1920 self.update_cache(line[1:])
1914 else:
1921 else:
1915 # build a block of code (maybe a single line) for execution
1922 # build a block of code (maybe a single line) for execution
1916 block = line
1923 block = line
1917 try:
1924 try:
1918 next = filelines[lnum] # lnum has already incremented
1925 next = filelines[lnum] # lnum has already incremented
1919 except:
1926 except:
1920 next = None
1927 next = None
1921 while next and indent_re.match(next):
1928 while next and indent_re.match(next):
1922 block += next
1929 block += next
1923 lnum += 1
1930 lnum += 1
1924 try:
1931 try:
1925 next = filelines[lnum]
1932 next = filelines[lnum]
1926 except:
1933 except:
1927 next = None
1934 next = None
1928 # now execute the block of one or more lines
1935 # now execute the block of one or more lines
1929 try:
1936 try:
1930 exec block in globs,locs
1937 exec block in globs,locs
1931 self.update_cache(block.rstrip())
1938 self.update_cache(block.rstrip())
1932 except SystemExit:
1939 except SystemExit:
1933 pass
1940 pass
1934 except:
1941 except:
1935 badblocks.append(block.rstrip())
1942 badblocks.append(block.rstrip())
1936 if kw['quiet']: # restore stdout
1943 if kw['quiet']: # restore stdout
1937 sys.stdout.close()
1944 sys.stdout.close()
1938 sys.stdout = stdout_save
1945 sys.stdout = stdout_save
1939 print 'Finished replaying log file <%s>' % fname
1946 print 'Finished replaying log file <%s>' % fname
1940 if badblocks:
1947 if badblocks:
1941 print >> sys.stderr, ('\nThe following lines/blocks in file '
1948 print >> sys.stderr, ('\nThe following lines/blocks in file '
1942 '<%s> reported errors:' % fname)
1949 '<%s> reported errors:' % fname)
1943
1950
1944 for badline in badblocks:
1951 for badline in badblocks:
1945 print >> sys.stderr, badline
1952 print >> sys.stderr, badline
1946 else: # regular file execution
1953 else: # regular file execution
1947 try:
1954 try:
1948 execfile(fname,*where)
1955 execfile(fname,*where)
1949 except SyntaxError:
1956 except SyntaxError:
1950 etype, evalue = sys.exc_info()[0:2]
1957 etype, evalue = sys.exc_info()[0:2]
1951 self.SyntaxTB(etype,evalue,[])
1958 self.SyntaxTB(etype,evalue,[])
1952 warn('Failure executing file: <%s>' % fname)
1959 warn('Failure executing file: <%s>' % fname)
1953 except SystemExit,status:
1960 except SystemExit,status:
1954 if not kw['exit_ignore']:
1961 if not kw['exit_ignore']:
1955 self.InteractiveTB()
1962 self.InteractiveTB()
1956 warn('Failure executing file: <%s>' % fname)
1963 warn('Failure executing file: <%s>' % fname)
1957 except:
1964 except:
1958 self.InteractiveTB()
1965 self.InteractiveTB()
1959 warn('Failure executing file: <%s>' % fname)
1966 warn('Failure executing file: <%s>' % fname)
1960
1967
1961 #************************* end of file <iplib.py> *****************************
1968 #************************* end of file <iplib.py> *****************************
@@ -1,737 +1,739 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """
2 """
3 IPython -- An enhanced Interactive Python
3 IPython -- An enhanced Interactive Python
4
4
5 Requires Python 2.1 or better.
5 Requires Python 2.1 or better.
6
6
7 This file contains the main make_IPython() starter function.
7 This file contains the main make_IPython() starter function.
8
8
9 $Id: ipmaker.py 963 2005-12-28 19:21:29Z fperez $"""
9 $Id: ipmaker.py 964 2005-12-28 21:03:01Z fperez $"""
10
10
11 #*****************************************************************************
11 #*****************************************************************************
12 # Copyright (C) 2001-2004 Fernando Perez. <fperez@colorado.edu>
12 # Copyright (C) 2001-2004 Fernando Perez. <fperez@colorado.edu>
13 #
13 #
14 # Distributed under the terms of the BSD License. The full license is in
14 # Distributed under the terms of the BSD License. The full license is in
15 # the file COPYING, distributed as part of this software.
15 # the file COPYING, distributed as part of this software.
16 #*****************************************************************************
16 #*****************************************************************************
17
17
18 from IPython import Release
18 from IPython import Release
19 __author__ = '%s <%s>' % Release.authors['Fernando']
19 __author__ = '%s <%s>' % Release.authors['Fernando']
20 __license__ = Release.license
20 __license__ = Release.license
21 __version__ = Release.version
21 __version__ = Release.version
22
22
23 credits._Printer__data = """
23 credits._Printer__data = """
24 Python: %s
24 Python: %s
25
25
26 IPython: Fernando Perez, Janko Hauser, Nathan Gray, and many users.
26 IPython: Fernando Perez, Janko Hauser, Nathan Gray, and many users.
27 See http://ipython.scipy.org for more information.""" \
27 See http://ipython.scipy.org for more information.""" \
28 % credits._Printer__data
28 % credits._Printer__data
29
29
30 copyright._Printer__data += """
30 copyright._Printer__data += """
31
31
32 Copyright (c) 2001-2004 Fernando Perez, Janko Hauser, Nathan Gray.
32 Copyright (c) 2001-2004 Fernando Perez, Janko Hauser, Nathan Gray.
33 All Rights Reserved."""
33 All Rights Reserved."""
34
34
35 #****************************************************************************
35 #****************************************************************************
36 # Required modules
36 # Required modules
37
37
38 # From the standard library
38 # From the standard library
39 import __main__
39 import __main__
40 import __builtin__
40 import __builtin__
41 import os
41 import os
42 import re
42 import re
43 import sys
43 import sys
44 import types
44 import types
45 from pprint import pprint,pformat
45 from pprint import pprint,pformat
46
46
47 # Our own
47 # Our own
48 from IPython import DPyGetOpt
48 from IPython import DPyGetOpt
49 from IPython.Struct import Struct
49 from IPython.Struct import Struct
50 from IPython.OutputTrap import OutputTrap
50 from IPython.OutputTrap import OutputTrap
51 from IPython.ConfigLoader import ConfigLoader
51 from IPython.ConfigLoader import ConfigLoader
52 from IPython.iplib import InteractiveShell,qw_lol,import_fail_info
52 from IPython.iplib import InteractiveShell,qw_lol,import_fail_info
53 from IPython.usage import cmd_line_usage,interactive_usage
53 from IPython.usage import cmd_line_usage,interactive_usage
54 from IPython.Prompts import CachedOutput
54 from IPython.Prompts import CachedOutput
55 from IPython.genutils import *
55 from IPython.genutils import *
56
56
57 #-----------------------------------------------------------------------------
57 #-----------------------------------------------------------------------------
58 def make_IPython(argv=None,user_ns=None,debug=1,rc_override=None,
58 def make_IPython(argv=None,user_ns=None,user_global_ns=None,debug=1,
59 shell_class=InteractiveShell,embedded=False,**kw):
59 rc_override=None,shell_class=InteractiveShell,
60 embedded=False,**kw):
60 """This is a dump of IPython into a single function.
61 """This is a dump of IPython into a single function.
61
62
62 Later it will have to be broken up in a sensible manner.
63 Later it will have to be broken up in a sensible manner.
63
64
64 Arguments:
65 Arguments:
65
66
66 - argv: a list similar to sys.argv[1:]. It should NOT contain the desired
67 - argv: a list similar to sys.argv[1:]. It should NOT contain the desired
67 script name, b/c DPyGetOpt strips the first argument only for the real
68 script name, b/c DPyGetOpt strips the first argument only for the real
68 sys.argv.
69 sys.argv.
69
70
70 - user_ns: a dict to be used as the user's namespace."""
71 - user_ns: a dict to be used as the user's namespace."""
71
72
72 #----------------------------------------------------------------------
73 #----------------------------------------------------------------------
73 # Defaults and initialization
74 # Defaults and initialization
74
75
75 # For developer debugging, deactivates crash handler and uses pdb.
76 # For developer debugging, deactivates crash handler and uses pdb.
76 DEVDEBUG = False
77 DEVDEBUG = False
77
78
78 if argv is None:
79 if argv is None:
79 argv = sys.argv
80 argv = sys.argv
80
81
81 # __IP is the main global that lives throughout and represents the whole
82 # __IP is the main global that lives throughout and represents the whole
82 # application. If the user redefines it, all bets are off as to what
83 # application. If the user redefines it, all bets are off as to what
83 # happens.
84 # happens.
84
85
85 # __IP is the name of he global which the caller will have accessible as
86 # __IP is the name of he global which the caller will have accessible as
86 # __IP.name. We set its name via the first parameter passed to
87 # __IP.name. We set its name via the first parameter passed to
87 # InteractiveShell:
88 # InteractiveShell:
88
89
89 IP = shell_class('__IP',user_ns=user_ns,embedded=embedded,**kw)
90 IP = shell_class('__IP',user_ns=user_ns,user_global_ns=user_global_ns,
91 embedded=embedded,**kw)
90
92
91 # Put 'help' in the user namespace
93 # Put 'help' in the user namespace
92 from site import _Helper
94 from site import _Helper
93 IP.user_ns['help'] = _Helper()
95 IP.user_ns['help'] = _Helper()
94
96
95 if DEVDEBUG:
97 if DEVDEBUG:
96 # For developer debugging only (global flag)
98 # For developer debugging only (global flag)
97 from IPython import ultraTB
99 from IPython import ultraTB
98 sys.excepthook = ultraTB.VerboseTB(call_pdb=1)
100 sys.excepthook = ultraTB.VerboseTB(call_pdb=1)
99 else:
101 else:
100 # IPython itself shouldn't crash. This will produce a detailed
102 # IPython itself shouldn't crash. This will produce a detailed
101 # post-mortem if it does
103 # post-mortem if it does
102 from IPython import CrashHandler
104 from IPython import CrashHandler
103 sys.excepthook = CrashHandler.CrashHandler(IP)
105 sys.excepthook = CrashHandler.CrashHandler(IP)
104
106
105 IP.BANNER_PARTS = ['Python %s\n'
107 IP.BANNER_PARTS = ['Python %s\n'
106 'Type "copyright", "credits" or "license" '
108 'Type "copyright", "credits" or "license" '
107 'for more information.\n'
109 'for more information.\n'
108 % (sys.version.split('\n')[0],),
110 % (sys.version.split('\n')[0],),
109 "IPython %s -- An enhanced Interactive Python."
111 "IPython %s -- An enhanced Interactive Python."
110 % (__version__,),
112 % (__version__,),
111 """? -> Introduction to IPython's features.
113 """? -> Introduction to IPython's features.
112 %magic -> Information about IPython's 'magic' % functions.
114 %magic -> Information about IPython's 'magic' % functions.
113 help -> Python's own help system.
115 help -> Python's own help system.
114 object? -> Details about 'object'. ?object also works, ?? prints more.
116 object? -> Details about 'object'. ?object also works, ?? prints more.
115 """ ]
117 """ ]
116
118
117 IP.usage = interactive_usage
119 IP.usage = interactive_usage
118
120
119 # Platform-dependent suffix and directory names. We use _ipython instead
121 # Platform-dependent suffix and directory names. We use _ipython instead
120 # of .ipython under win32 b/c there's software that breaks with .named
122 # of .ipython under win32 b/c there's software that breaks with .named
121 # directories on that platform.
123 # directories on that platform.
122 if os.name == 'posix':
124 if os.name == 'posix':
123 rc_suffix = ''
125 rc_suffix = ''
124 ipdir_def = '.ipython'
126 ipdir_def = '.ipython'
125 else:
127 else:
126 rc_suffix = '.ini'
128 rc_suffix = '.ini'
127 ipdir_def = '_ipython'
129 ipdir_def = '_ipython'
128
130
129 # default directory for configuration
131 # default directory for configuration
130 ipythondir = os.path.abspath(os.environ.get('IPYTHONDIR',
132 ipythondir = os.path.abspath(os.environ.get('IPYTHONDIR',
131 os.path.join(IP.home_dir,ipdir_def)))
133 os.path.join(IP.home_dir,ipdir_def)))
132
134
133 # we need the directory where IPython itself is installed
135 # we need the directory where IPython itself is installed
134 import IPython
136 import IPython
135 IPython_dir = os.path.dirname(IPython.__file__)
137 IPython_dir = os.path.dirname(IPython.__file__)
136 del IPython
138 del IPython
137
139
138 #-------------------------------------------------------------------------
140 #-------------------------------------------------------------------------
139 # Command line handling
141 # Command line handling
140
142
141 # Valid command line options (uses DPyGetOpt syntax, like Perl's
143 # Valid command line options (uses DPyGetOpt syntax, like Perl's
142 # GetOpt::Long)
144 # GetOpt::Long)
143
145
144 # Any key not listed here gets deleted even if in the file (like session
146 # Any key not listed here gets deleted even if in the file (like session
145 # or profile). That's deliberate, to maintain the rc namespace clean.
147 # or profile). That's deliberate, to maintain the rc namespace clean.
146
148
147 # Each set of options appears twice: under _conv only the names are
149 # Each set of options appears twice: under _conv only the names are
148 # listed, indicating which type they must be converted to when reading the
150 # listed, indicating which type they must be converted to when reading the
149 # ipythonrc file. And under DPyGetOpt they are listed with the regular
151 # ipythonrc file. And under DPyGetOpt they are listed with the regular
150 # DPyGetOpt syntax (=s,=i,:f,etc).
152 # DPyGetOpt syntax (=s,=i,:f,etc).
151
153
152 # Make sure there's a space before each end of line (they get auto-joined!)
154 # Make sure there's a space before each end of line (they get auto-joined!)
153 cmdline_opts = ('autocall! autoindent! automagic! banner! cache_size|cs=i '
155 cmdline_opts = ('autocall! autoindent! automagic! banner! cache_size|cs=i '
154 'c=s classic|cl color_info! colors=s confirm_exit! '
156 'c=s classic|cl color_info! colors=s confirm_exit! '
155 'debug! deep_reload! editor=s log|l messages! nosep pdb! '
157 'debug! deep_reload! editor=s log|l messages! nosep pdb! '
156 'pprint! prompt_in1|pi1=s prompt_in2|pi2=s prompt_out|po=s '
158 'pprint! prompt_in1|pi1=s prompt_in2|pi2=s prompt_out|po=s '
157 'quick screen_length|sl=i prompts_pad_left=i '
159 'quick screen_length|sl=i prompts_pad_left=i '
158 'logfile|lf=s logplay|lp=s profile|p=s '
160 'logfile|lf=s logplay|lp=s profile|p=s '
159 'readline! readline_merge_completions! '
161 'readline! readline_merge_completions! '
160 'readline_omit__names! '
162 'readline_omit__names! '
161 'rcfile=s separate_in|si=s separate_out|so=s '
163 'rcfile=s separate_in|si=s separate_out|so=s '
162 'separate_out2|so2=s xmode=s wildcards_case_sensitive! '
164 'separate_out2|so2=s xmode=s wildcards_case_sensitive! '
163 'magic_docstrings system_verbose! '
165 'magic_docstrings system_verbose! '
164 'multi_line_specials! '
166 'multi_line_specials! '
165 'autoedit_syntax!')
167 'autoedit_syntax!')
166
168
167 # Options that can *only* appear at the cmd line (not in rcfiles).
169 # Options that can *only* appear at the cmd line (not in rcfiles).
168
170
169 # The "ignore" option is a kludge so that Emacs buffers don't crash, since
171 # The "ignore" option is a kludge so that Emacs buffers don't crash, since
170 # the 'C-c !' command in emacs automatically appends a -i option at the end.
172 # the 'C-c !' command in emacs automatically appends a -i option at the end.
171 cmdline_only = ('help ignore|i ipythondir=s Version upgrade '
173 cmdline_only = ('help ignore|i ipythondir=s Version upgrade '
172 'gthread! qthread! wthread! pylab! tk!')
174 'gthread! qthread! wthread! pylab! tk!')
173
175
174 # Build the actual name list to be used by DPyGetOpt
176 # Build the actual name list to be used by DPyGetOpt
175 opts_names = qw(cmdline_opts) + qw(cmdline_only)
177 opts_names = qw(cmdline_opts) + qw(cmdline_only)
176
178
177 # Set sensible command line defaults.
179 # Set sensible command line defaults.
178 # This should have everything from cmdline_opts and cmdline_only
180 # This should have everything from cmdline_opts and cmdline_only
179 opts_def = Struct(autocall = 1,
181 opts_def = Struct(autocall = 1,
180 autoedit_syntax = 1,
182 autoedit_syntax = 1,
181 autoindent=0,
183 autoindent=0,
182 automagic = 1,
184 automagic = 1,
183 banner = 1,
185 banner = 1,
184 cache_size = 1000,
186 cache_size = 1000,
185 c = '',
187 c = '',
186 classic = 0,
188 classic = 0,
187 colors = 'NoColor',
189 colors = 'NoColor',
188 color_info = 0,
190 color_info = 0,
189 confirm_exit = 1,
191 confirm_exit = 1,
190 debug = 0,
192 debug = 0,
191 deep_reload = 0,
193 deep_reload = 0,
192 editor = '0',
194 editor = '0',
193 help = 0,
195 help = 0,
194 ignore = 0,
196 ignore = 0,
195 ipythondir = ipythondir,
197 ipythondir = ipythondir,
196 log = 0,
198 log = 0,
197 logfile = '',
199 logfile = '',
198 logplay = '',
200 logplay = '',
199 multi_line_specials = 1,
201 multi_line_specials = 1,
200 messages = 1,
202 messages = 1,
201 nosep = 0,
203 nosep = 0,
202 pdb = 0,
204 pdb = 0,
203 pprint = 0,
205 pprint = 0,
204 profile = '',
206 profile = '',
205 prompt_in1 = 'In [\\#]: ',
207 prompt_in1 = 'In [\\#]: ',
206 prompt_in2 = ' .\\D.: ',
208 prompt_in2 = ' .\\D.: ',
207 prompt_out = 'Out[\\#]: ',
209 prompt_out = 'Out[\\#]: ',
208 prompts_pad_left = 1,
210 prompts_pad_left = 1,
209 quick = 0,
211 quick = 0,
210 readline = 1,
212 readline = 1,
211 readline_merge_completions = 1,
213 readline_merge_completions = 1,
212 readline_omit__names = 0,
214 readline_omit__names = 0,
213 rcfile = 'ipythonrc' + rc_suffix,
215 rcfile = 'ipythonrc' + rc_suffix,
214 screen_length = 0,
216 screen_length = 0,
215 separate_in = '\n',
217 separate_in = '\n',
216 separate_out = '\n',
218 separate_out = '\n',
217 separate_out2 = '',
219 separate_out2 = '',
218 system_verbose = 0,
220 system_verbose = 0,
219 gthread = 0,
221 gthread = 0,
220 qthread = 0,
222 qthread = 0,
221 wthread = 0,
223 wthread = 0,
222 pylab = 0,
224 pylab = 0,
223 tk = 0,
225 tk = 0,
224 upgrade = 0,
226 upgrade = 0,
225 Version = 0,
227 Version = 0,
226 xmode = 'Verbose',
228 xmode = 'Verbose',
227 wildcards_case_sensitive = 1,
229 wildcards_case_sensitive = 1,
228 magic_docstrings = 0, # undocumented, for doc generation
230 magic_docstrings = 0, # undocumented, for doc generation
229 )
231 )
230
232
231 # Things that will *only* appear in rcfiles (not at the command line).
233 # Things that will *only* appear in rcfiles (not at the command line).
232 # Make sure there's a space before each end of line (they get auto-joined!)
234 # Make sure there's a space before each end of line (they get auto-joined!)
233 rcfile_opts = { qwflat: 'include import_mod import_all execfile ',
235 rcfile_opts = { qwflat: 'include import_mod import_all execfile ',
234 qw_lol: 'import_some ',
236 qw_lol: 'import_some ',
235 # for things with embedded whitespace:
237 # for things with embedded whitespace:
236 list_strings:'execute alias readline_parse_and_bind ',
238 list_strings:'execute alias readline_parse_and_bind ',
237 # Regular strings need no conversion:
239 # Regular strings need no conversion:
238 None:'readline_remove_delims ',
240 None:'readline_remove_delims ',
239 }
241 }
240 # Default values for these
242 # Default values for these
241 rc_def = Struct(include = [],
243 rc_def = Struct(include = [],
242 import_mod = [],
244 import_mod = [],
243 import_all = [],
245 import_all = [],
244 import_some = [[]],
246 import_some = [[]],
245 execute = [],
247 execute = [],
246 execfile = [],
248 execfile = [],
247 alias = [],
249 alias = [],
248 readline_parse_and_bind = [],
250 readline_parse_and_bind = [],
249 readline_remove_delims = '',
251 readline_remove_delims = '',
250 )
252 )
251
253
252 # Build the type conversion dictionary from the above tables:
254 # Build the type conversion dictionary from the above tables:
253 typeconv = rcfile_opts.copy()
255 typeconv = rcfile_opts.copy()
254 typeconv.update(optstr2types(cmdline_opts))
256 typeconv.update(optstr2types(cmdline_opts))
255
257
256 # FIXME: the None key appears in both, put that back together by hand. Ugly!
258 # FIXME: the None key appears in both, put that back together by hand. Ugly!
257 typeconv[None] += ' ' + rcfile_opts[None]
259 typeconv[None] += ' ' + rcfile_opts[None]
258
260
259 # Remove quotes at ends of all strings (used to protect spaces)
261 # Remove quotes at ends of all strings (used to protect spaces)
260 typeconv[unquote_ends] = typeconv[None]
262 typeconv[unquote_ends] = typeconv[None]
261 del typeconv[None]
263 del typeconv[None]
262
264
263 # Build the list we'll use to make all config decisions with defaults:
265 # Build the list we'll use to make all config decisions with defaults:
264 opts_all = opts_def.copy()
266 opts_all = opts_def.copy()
265 opts_all.update(rc_def)
267 opts_all.update(rc_def)
266
268
267 # Build conflict resolver for recursive loading of config files:
269 # Build conflict resolver for recursive loading of config files:
268 # - preserve means the outermost file maintains the value, it is not
270 # - preserve means the outermost file maintains the value, it is not
269 # overwritten if an included file has the same key.
271 # overwritten if an included file has the same key.
270 # - add_flip applies + to the two values, so it better make sense to add
272 # - add_flip applies + to the two values, so it better make sense to add
271 # those types of keys. But it flips them first so that things loaded
273 # those types of keys. But it flips them first so that things loaded
272 # deeper in the inclusion chain have lower precedence.
274 # deeper in the inclusion chain have lower precedence.
273 conflict = {'preserve': ' '.join([ typeconv[int],
275 conflict = {'preserve': ' '.join([ typeconv[int],
274 typeconv[unquote_ends] ]),
276 typeconv[unquote_ends] ]),
275 'add_flip': ' '.join([ typeconv[qwflat],
277 'add_flip': ' '.join([ typeconv[qwflat],
276 typeconv[qw_lol],
278 typeconv[qw_lol],
277 typeconv[list_strings] ])
279 typeconv[list_strings] ])
278 }
280 }
279
281
280 # Now actually process the command line
282 # Now actually process the command line
281 getopt = DPyGetOpt.DPyGetOpt()
283 getopt = DPyGetOpt.DPyGetOpt()
282 getopt.setIgnoreCase(0)
284 getopt.setIgnoreCase(0)
283
285
284 getopt.parseConfiguration(opts_names)
286 getopt.parseConfiguration(opts_names)
285
287
286 try:
288 try:
287 getopt.processArguments(argv)
289 getopt.processArguments(argv)
288 except:
290 except:
289 print cmd_line_usage
291 print cmd_line_usage
290 warn('\nError in Arguments: ' + `sys.exc_value`)
292 warn('\nError in Arguments: ' + `sys.exc_value`)
291 sys.exit(1)
293 sys.exit(1)
292
294
293 # convert the options dict to a struct for much lighter syntax later
295 # convert the options dict to a struct for much lighter syntax later
294 opts = Struct(getopt.optionValues)
296 opts = Struct(getopt.optionValues)
295 args = getopt.freeValues
297 args = getopt.freeValues
296
298
297 # this is the struct (which has default values at this point) with which
299 # this is the struct (which has default values at this point) with which
298 # we make all decisions:
300 # we make all decisions:
299 opts_all.update(opts)
301 opts_all.update(opts)
300
302
301 # Options that force an immediate exit
303 # Options that force an immediate exit
302 if opts_all.help:
304 if opts_all.help:
303 page(cmd_line_usage)
305 page(cmd_line_usage)
304 sys.exit()
306 sys.exit()
305
307
306 if opts_all.Version:
308 if opts_all.Version:
307 print __version__
309 print __version__
308 sys.exit()
310 sys.exit()
309
311
310 if opts_all.magic_docstrings:
312 if opts_all.magic_docstrings:
311 IP.magic_magic('-latex')
313 IP.magic_magic('-latex')
312 sys.exit()
314 sys.exit()
313
315
314 # Create user config directory if it doesn't exist. This must be done
316 # Create user config directory if it doesn't exist. This must be done
315 # *after* getting the cmd line options.
317 # *after* getting the cmd line options.
316 if not os.path.isdir(opts_all.ipythondir):
318 if not os.path.isdir(opts_all.ipythondir):
317 IP.user_setup(opts_all.ipythondir,rc_suffix,'install')
319 IP.user_setup(opts_all.ipythondir,rc_suffix,'install')
318
320
319 # upgrade user config files while preserving a copy of the originals
321 # upgrade user config files while preserving a copy of the originals
320 if opts_all.upgrade:
322 if opts_all.upgrade:
321 IP.user_setup(opts_all.ipythondir,rc_suffix,'upgrade')
323 IP.user_setup(opts_all.ipythondir,rc_suffix,'upgrade')
322
324
323 # check mutually exclusive options in the *original* command line
325 # check mutually exclusive options in the *original* command line
324 mutex_opts(opts,[qw('log logfile'),qw('rcfile profile'),
326 mutex_opts(opts,[qw('log logfile'),qw('rcfile profile'),
325 qw('classic profile'),qw('classic rcfile')])
327 qw('classic profile'),qw('classic rcfile')])
326
328
327 # default logfilename used when -log is called.
329 # default logfilename used when -log is called.
328 IP.LOGDEF = 'ipython.log'
330 IP.LOGDEF = 'ipython.log'
329
331
330 #---------------------------------------------------------------------------
332 #---------------------------------------------------------------------------
331 # Log replay
333 # Log replay
332
334
333 # if -logplay, we need to 'become' the other session. That basically means
335 # if -logplay, we need to 'become' the other session. That basically means
334 # replacing the current command line environment with that of the old
336 # replacing the current command line environment with that of the old
335 # session and moving on.
337 # session and moving on.
336
338
337 # this is needed so that later we know we're in session reload mode, as
339 # this is needed so that later we know we're in session reload mode, as
338 # opts_all will get overwritten:
340 # opts_all will get overwritten:
339 load_logplay = 0
341 load_logplay = 0
340
342
341 if opts_all.logplay:
343 if opts_all.logplay:
342 load_logplay = opts_all.logplay
344 load_logplay = opts_all.logplay
343 opts_debug_save = opts_all.debug
345 opts_debug_save = opts_all.debug
344 try:
346 try:
345 logplay = open(opts_all.logplay)
347 logplay = open(opts_all.logplay)
346 except IOError:
348 except IOError:
347 if opts_all.debug: IP.InteractiveTB()
349 if opts_all.debug: IP.InteractiveTB()
348 warn('Could not open logplay file '+`opts_all.logplay`)
350 warn('Could not open logplay file '+`opts_all.logplay`)
349 # restore state as if nothing had happened and move on, but make
351 # restore state as if nothing had happened and move on, but make
350 # sure that later we don't try to actually load the session file
352 # sure that later we don't try to actually load the session file
351 logplay = None
353 logplay = None
352 load_logplay = 0
354 load_logplay = 0
353 del opts_all.logplay
355 del opts_all.logplay
354 else:
356 else:
355 try:
357 try:
356 logplay.readline()
358 logplay.readline()
357 logplay.readline();
359 logplay.readline();
358 # this reloads that session's command line
360 # this reloads that session's command line
359 cmd = logplay.readline()[6:]
361 cmd = logplay.readline()[6:]
360 exec cmd
362 exec cmd
361 # restore the true debug flag given so that the process of
363 # restore the true debug flag given so that the process of
362 # session loading itself can be monitored.
364 # session loading itself can be monitored.
363 opts.debug = opts_debug_save
365 opts.debug = opts_debug_save
364 # save the logplay flag so later we don't overwrite the log
366 # save the logplay flag so later we don't overwrite the log
365 opts.logplay = load_logplay
367 opts.logplay = load_logplay
366 # now we must update our own structure with defaults
368 # now we must update our own structure with defaults
367 opts_all.update(opts)
369 opts_all.update(opts)
368 # now load args
370 # now load args
369 cmd = logplay.readline()[6:]
371 cmd = logplay.readline()[6:]
370 exec cmd
372 exec cmd
371 logplay.close()
373 logplay.close()
372 except:
374 except:
373 logplay.close()
375 logplay.close()
374 if opts_all.debug: IP.InteractiveTB()
376 if opts_all.debug: IP.InteractiveTB()
375 warn("Logplay file lacking full configuration information.\n"
377 warn("Logplay file lacking full configuration information.\n"
376 "I'll try to read it, but some things may not work.")
378 "I'll try to read it, but some things may not work.")
377
379
378 #-------------------------------------------------------------------------
380 #-------------------------------------------------------------------------
379 # set up output traps: catch all output from files, being run, modules
381 # set up output traps: catch all output from files, being run, modules
380 # loaded, etc. Then give it to the user in a clean form at the end.
382 # loaded, etc. Then give it to the user in a clean form at the end.
381
383
382 msg_out = 'Output messages. '
384 msg_out = 'Output messages. '
383 msg_err = 'Error messages. '
385 msg_err = 'Error messages. '
384 msg_sep = '\n'
386 msg_sep = '\n'
385 msg = Struct(config = OutputTrap('Configuration Loader',msg_out,
387 msg = Struct(config = OutputTrap('Configuration Loader',msg_out,
386 msg_err,msg_sep,debug,
388 msg_err,msg_sep,debug,
387 quiet_out=1),
389 quiet_out=1),
388 user_exec = OutputTrap('User File Execution',msg_out,
390 user_exec = OutputTrap('User File Execution',msg_out,
389 msg_err,msg_sep,debug),
391 msg_err,msg_sep,debug),
390 logplay = OutputTrap('Log Loader',msg_out,
392 logplay = OutputTrap('Log Loader',msg_out,
391 msg_err,msg_sep,debug),
393 msg_err,msg_sep,debug),
392 summary = ''
394 summary = ''
393 )
395 )
394
396
395 #-------------------------------------------------------------------------
397 #-------------------------------------------------------------------------
396 # Process user ipythonrc-type configuration files
398 # Process user ipythonrc-type configuration files
397
399
398 # turn on output trapping and log to msg.config
400 # turn on output trapping and log to msg.config
399 # remember that with debug on, trapping is actually disabled
401 # remember that with debug on, trapping is actually disabled
400 msg.config.trap_all()
402 msg.config.trap_all()
401
403
402 # look for rcfile in current or default directory
404 # look for rcfile in current or default directory
403 try:
405 try:
404 opts_all.rcfile = filefind(opts_all.rcfile,opts_all.ipythondir)
406 opts_all.rcfile = filefind(opts_all.rcfile,opts_all.ipythondir)
405 except IOError:
407 except IOError:
406 if opts_all.debug: IP.InteractiveTB()
408 if opts_all.debug: IP.InteractiveTB()
407 warn('Configuration file %s not found. Ignoring request.'
409 warn('Configuration file %s not found. Ignoring request.'
408 % (opts_all.rcfile) )
410 % (opts_all.rcfile) )
409
411
410 # 'profiles' are a shorthand notation for config filenames
412 # 'profiles' are a shorthand notation for config filenames
411 if opts_all.profile:
413 if opts_all.profile:
412 try:
414 try:
413 opts_all.rcfile = filefind('ipythonrc-' + opts_all.profile
415 opts_all.rcfile = filefind('ipythonrc-' + opts_all.profile
414 + rc_suffix,
416 + rc_suffix,
415 opts_all.ipythondir)
417 opts_all.ipythondir)
416 except IOError:
418 except IOError:
417 if opts_all.debug: IP.InteractiveTB()
419 if opts_all.debug: IP.InteractiveTB()
418 opts.profile = '' # remove profile from options if invalid
420 opts.profile = '' # remove profile from options if invalid
419 warn('Profile configuration file %s not found. Ignoring request.'
421 warn('Profile configuration file %s not found. Ignoring request.'
420 % (opts_all.profile) )
422 % (opts_all.profile) )
421
423
422 # load the config file
424 # load the config file
423 rcfiledata = None
425 rcfiledata = None
424 if opts_all.quick:
426 if opts_all.quick:
425 print 'Launching IPython in quick mode. No config file read.'
427 print 'Launching IPython in quick mode. No config file read.'
426 elif opts_all.classic:
428 elif opts_all.classic:
427 print 'Launching IPython in classic mode. No config file read.'
429 print 'Launching IPython in classic mode. No config file read.'
428 elif opts_all.rcfile:
430 elif opts_all.rcfile:
429 try:
431 try:
430 cfg_loader = ConfigLoader(conflict)
432 cfg_loader = ConfigLoader(conflict)
431 rcfiledata = cfg_loader.load(opts_all.rcfile,typeconv,
433 rcfiledata = cfg_loader.load(opts_all.rcfile,typeconv,
432 'include',opts_all.ipythondir,
434 'include',opts_all.ipythondir,
433 purge = 1,
435 purge = 1,
434 unique = conflict['preserve'])
436 unique = conflict['preserve'])
435 except:
437 except:
436 IP.InteractiveTB()
438 IP.InteractiveTB()
437 warn('Problems loading configuration file '+
439 warn('Problems loading configuration file '+
438 `opts_all.rcfile`+
440 `opts_all.rcfile`+
439 '\nStarting with default -bare bones- configuration.')
441 '\nStarting with default -bare bones- configuration.')
440 else:
442 else:
441 warn('No valid configuration file found in either currrent directory\n'+
443 warn('No valid configuration file found in either currrent directory\n'+
442 'or in the IPython config. directory: '+`opts_all.ipythondir`+
444 'or in the IPython config. directory: '+`opts_all.ipythondir`+
443 '\nProceeding with internal defaults.')
445 '\nProceeding with internal defaults.')
444
446
445 #------------------------------------------------------------------------
447 #------------------------------------------------------------------------
446 # Set exception handlers in mode requested by user.
448 # Set exception handlers in mode requested by user.
447 otrap = OutputTrap(trap_out=1) # trap messages from magic_xmode
449 otrap = OutputTrap(trap_out=1) # trap messages from magic_xmode
448 IP.magic_xmode(opts_all.xmode)
450 IP.magic_xmode(opts_all.xmode)
449 otrap.release_out()
451 otrap.release_out()
450
452
451 #------------------------------------------------------------------------
453 #------------------------------------------------------------------------
452 # Execute user config
454 # Execute user config
453
455
454 # Create a valid config structure with the right precedence order:
456 # Create a valid config structure with the right precedence order:
455 # defaults < rcfile < command line. This needs to be in the instance, so
457 # defaults < rcfile < command line. This needs to be in the instance, so
456 # that method calls below that rely on it find it.
458 # that method calls below that rely on it find it.
457 IP.rc = rc_def.copy()
459 IP.rc = rc_def.copy()
458
460
459 # Work with a local alias inside this routine to avoid unnecessary
461 # Work with a local alias inside this routine to avoid unnecessary
460 # attribute lookups.
462 # attribute lookups.
461 IP_rc = IP.rc
463 IP_rc = IP.rc
462
464
463 IP_rc.update(opts_def)
465 IP_rc.update(opts_def)
464 if rcfiledata:
466 if rcfiledata:
465 # now we can update
467 # now we can update
466 IP_rc.update(rcfiledata)
468 IP_rc.update(rcfiledata)
467 IP_rc.update(opts)
469 IP_rc.update(opts)
468 IP_rc.update(rc_override)
470 IP_rc.update(rc_override)
469
471
470 # Store the original cmd line for reference:
472 # Store the original cmd line for reference:
471 IP_rc.opts = opts
473 IP_rc.opts = opts
472 IP_rc.args = args
474 IP_rc.args = args
473
475
474 # create a *runtime* Struct like rc for holding parameters which may be
476 # create a *runtime* Struct like rc for holding parameters which may be
475 # created and/or modified by runtime user extensions.
477 # created and/or modified by runtime user extensions.
476 IP.runtime_rc = Struct()
478 IP.runtime_rc = Struct()
477
479
478 # from this point on, all config should be handled through IP_rc,
480 # from this point on, all config should be handled through IP_rc,
479 # opts* shouldn't be used anymore.
481 # opts* shouldn't be used anymore.
480
482
481 # add personal .ipython dir to sys.path so that users can put things in
483 # add personal .ipython dir to sys.path so that users can put things in
482 # there for customization
484 # there for customization
483 sys.path.append(IP_rc.ipythondir)
485 sys.path.append(IP_rc.ipythondir)
484 sys.path.insert(0, '') # add . to sys.path. Fix from Prabhu Ramachandran
486 sys.path.insert(0, '') # add . to sys.path. Fix from Prabhu Ramachandran
485
487
486 # update IP_rc with some special things that need manual
488 # update IP_rc with some special things that need manual
487 # tweaks. Basically options which affect other options. I guess this
489 # tweaks. Basically options which affect other options. I guess this
488 # should just be written so that options are fully orthogonal and we
490 # should just be written so that options are fully orthogonal and we
489 # wouldn't worry about this stuff!
491 # wouldn't worry about this stuff!
490
492
491 if IP_rc.classic:
493 if IP_rc.classic:
492 IP_rc.quick = 1
494 IP_rc.quick = 1
493 IP_rc.cache_size = 0
495 IP_rc.cache_size = 0
494 IP_rc.pprint = 0
496 IP_rc.pprint = 0
495 IP_rc.prompt_in1 = '>>> '
497 IP_rc.prompt_in1 = '>>> '
496 IP_rc.prompt_in2 = '... '
498 IP_rc.prompt_in2 = '... '
497 IP_rc.prompt_out = ''
499 IP_rc.prompt_out = ''
498 IP_rc.separate_in = IP_rc.separate_out = IP_rc.separate_out2 = '0'
500 IP_rc.separate_in = IP_rc.separate_out = IP_rc.separate_out2 = '0'
499 IP_rc.colors = 'NoColor'
501 IP_rc.colors = 'NoColor'
500 IP_rc.xmode = 'Plain'
502 IP_rc.xmode = 'Plain'
501
503
502 # configure readline
504 # configure readline
503 # Define the history file for saving commands in between sessions
505 # Define the history file for saving commands in between sessions
504 if IP_rc.profile:
506 if IP_rc.profile:
505 histfname = 'history-%s' % IP_rc.profile
507 histfname = 'history-%s' % IP_rc.profile
506 else:
508 else:
507 histfname = 'history'
509 histfname = 'history'
508 IP.histfile = os.path.join(opts_all.ipythondir,histfname)
510 IP.histfile = os.path.join(opts_all.ipythondir,histfname)
509
511
510 # update exception handlers with rc file status
512 # update exception handlers with rc file status
511 otrap.trap_out() # I don't want these messages ever.
513 otrap.trap_out() # I don't want these messages ever.
512 IP.magic_xmode(IP_rc.xmode)
514 IP.magic_xmode(IP_rc.xmode)
513 otrap.release_out()
515 otrap.release_out()
514
516
515 # activate logging if requested and not reloading a log
517 # activate logging if requested and not reloading a log
516 if IP_rc.logplay:
518 if IP_rc.logplay:
517 IP.magic_logstart(IP_rc.logplay + ' append')
519 IP.magic_logstart(IP_rc.logplay + ' append')
518 elif IP_rc.logfile:
520 elif IP_rc.logfile:
519 IP.magic_logstart(IP_rc.logfile)
521 IP.magic_logstart(IP_rc.logfile)
520 elif IP_rc.log:
522 elif IP_rc.log:
521 IP.magic_logstart()
523 IP.magic_logstart()
522
524
523 # find user editor so that it we don't have to look it up constantly
525 # find user editor so that it we don't have to look it up constantly
524 if IP_rc.editor.strip()=='0':
526 if IP_rc.editor.strip()=='0':
525 try:
527 try:
526 ed = os.environ['EDITOR']
528 ed = os.environ['EDITOR']
527 except KeyError:
529 except KeyError:
528 if os.name == 'posix':
530 if os.name == 'posix':
529 ed = 'vi' # the only one guaranteed to be there!
531 ed = 'vi' # the only one guaranteed to be there!
530 else:
532 else:
531 ed = 'notepad' # same in Windows!
533 ed = 'notepad' # same in Windows!
532 IP_rc.editor = ed
534 IP_rc.editor = ed
533
535
534 # Keep track of whether this is an embedded instance or not (useful for
536 # Keep track of whether this is an embedded instance or not (useful for
535 # post-mortems).
537 # post-mortems).
536 IP_rc.embedded = IP.embedded
538 IP_rc.embedded = IP.embedded
537
539
538 # Recursive reload
540 # Recursive reload
539 try:
541 try:
540 from IPython import deep_reload
542 from IPython import deep_reload
541 if IP_rc.deep_reload:
543 if IP_rc.deep_reload:
542 __builtin__.reload = deep_reload.reload
544 __builtin__.reload = deep_reload.reload
543 else:
545 else:
544 __builtin__.dreload = deep_reload.reload
546 __builtin__.dreload = deep_reload.reload
545 del deep_reload
547 del deep_reload
546 except ImportError:
548 except ImportError:
547 pass
549 pass
548
550
549 # Save the current state of our namespace so that the interactive shell
551 # Save the current state of our namespace so that the interactive shell
550 # can later know which variables have been created by us from config files
552 # can later know which variables have been created by us from config files
551 # and loading. This way, loading a file (in any way) is treated just like
553 # and loading. This way, loading a file (in any way) is treated just like
552 # defining things on the command line, and %who works as expected.
554 # defining things on the command line, and %who works as expected.
553
555
554 # DON'T do anything that affects the namespace beyond this point!
556 # DON'T do anything that affects the namespace beyond this point!
555 IP.internal_ns.update(__main__.__dict__)
557 IP.internal_ns.update(__main__.__dict__)
556
558
557 #IP.internal_ns.update(locals()) # so our stuff doesn't show up in %who
559 #IP.internal_ns.update(locals()) # so our stuff doesn't show up in %who
558
560
559 # Now run through the different sections of the users's config
561 # Now run through the different sections of the users's config
560 if IP_rc.debug:
562 if IP_rc.debug:
561 print 'Trying to execute the following configuration structure:'
563 print 'Trying to execute the following configuration structure:'
562 print '(Things listed first are deeper in the inclusion tree and get'
564 print '(Things listed first are deeper in the inclusion tree and get'
563 print 'loaded first).\n'
565 print 'loaded first).\n'
564 pprint(IP_rc.__dict__)
566 pprint(IP_rc.__dict__)
565
567
566 for mod in IP_rc.import_mod:
568 for mod in IP_rc.import_mod:
567 try:
569 try:
568 exec 'import '+mod in IP.user_ns
570 exec 'import '+mod in IP.user_ns
569 except :
571 except :
570 IP.InteractiveTB()
572 IP.InteractiveTB()
571 import_fail_info(mod)
573 import_fail_info(mod)
572
574
573 for mod_fn in IP_rc.import_some:
575 for mod_fn in IP_rc.import_some:
574 if mod_fn == []: break
576 if mod_fn == []: break
575 mod,fn = mod_fn[0],','.join(mod_fn[1:])
577 mod,fn = mod_fn[0],','.join(mod_fn[1:])
576 try:
578 try:
577 exec 'from '+mod+' import '+fn in IP.user_ns
579 exec 'from '+mod+' import '+fn in IP.user_ns
578 except :
580 except :
579 IP.InteractiveTB()
581 IP.InteractiveTB()
580 import_fail_info(mod,fn)
582 import_fail_info(mod,fn)
581
583
582 for mod in IP_rc.import_all:
584 for mod in IP_rc.import_all:
583 try:
585 try:
584 exec 'from '+mod+' import *' in IP.user_ns
586 exec 'from '+mod+' import *' in IP.user_ns
585 except :
587 except :
586 IP.InteractiveTB()
588 IP.InteractiveTB()
587 import_fail_info(mod)
589 import_fail_info(mod)
588
590
589 for code in IP_rc.execute:
591 for code in IP_rc.execute:
590 try:
592 try:
591 exec code in IP.user_ns
593 exec code in IP.user_ns
592 except:
594 except:
593 IP.InteractiveTB()
595 IP.InteractiveTB()
594 warn('Failure executing code: ' + `code`)
596 warn('Failure executing code: ' + `code`)
595
597
596 # Execute the files the user wants in ipythonrc
598 # Execute the files the user wants in ipythonrc
597 for file in IP_rc.execfile:
599 for file in IP_rc.execfile:
598 try:
600 try:
599 file = filefind(file,sys.path+[IPython_dir])
601 file = filefind(file,sys.path+[IPython_dir])
600 except IOError:
602 except IOError:
601 warn(itpl('File $file not found. Skipping it.'))
603 warn(itpl('File $file not found. Skipping it.'))
602 else:
604 else:
603 IP.safe_execfile(os.path.expanduser(file),IP.user_ns)
605 IP.safe_execfile(os.path.expanduser(file),IP.user_ns)
604
606
605 # release stdout and stderr and save config log into a global summary
607 # release stdout and stderr and save config log into a global summary
606 msg.config.release_all()
608 msg.config.release_all()
607 if IP_rc.messages:
609 if IP_rc.messages:
608 msg.summary += msg.config.summary_all()
610 msg.summary += msg.config.summary_all()
609
611
610 #------------------------------------------------------------------------
612 #------------------------------------------------------------------------
611 # Setup interactive session
613 # Setup interactive session
612
614
613 # Now we should be fully configured. We can then execute files or load
615 # Now we should be fully configured. We can then execute files or load
614 # things only needed for interactive use. Then we'll open the shell.
616 # things only needed for interactive use. Then we'll open the shell.
615
617
616 # Take a snapshot of the user namespace before opening the shell. That way
618 # Take a snapshot of the user namespace before opening the shell. That way
617 # we'll be able to identify which things were interactively defined and
619 # we'll be able to identify which things were interactively defined and
618 # which were defined through config files.
620 # which were defined through config files.
619 IP.user_config_ns = IP.user_ns.copy()
621 IP.user_config_ns = IP.user_ns.copy()
620
622
621 # Force reading a file as if it were a session log. Slower but safer.
623 # Force reading a file as if it were a session log. Slower but safer.
622 if load_logplay:
624 if load_logplay:
623 print 'Replaying log...'
625 print 'Replaying log...'
624 try:
626 try:
625 if IP_rc.debug:
627 if IP_rc.debug:
626 logplay_quiet = 0
628 logplay_quiet = 0
627 else:
629 else:
628 logplay_quiet = 1
630 logplay_quiet = 1
629
631
630 msg.logplay.trap_all()
632 msg.logplay.trap_all()
631 IP.safe_execfile(load_logplay,IP.user_ns,
633 IP.safe_execfile(load_logplay,IP.user_ns,
632 islog = 1, quiet = logplay_quiet)
634 islog = 1, quiet = logplay_quiet)
633 msg.logplay.release_all()
635 msg.logplay.release_all()
634 if IP_rc.messages:
636 if IP_rc.messages:
635 msg.summary += msg.logplay.summary_all()
637 msg.summary += msg.logplay.summary_all()
636 except:
638 except:
637 warn('Problems replaying logfile %s.' % load_logplay)
639 warn('Problems replaying logfile %s.' % load_logplay)
638 IP.InteractiveTB()
640 IP.InteractiveTB()
639
641
640 # Load remaining files in command line
642 # Load remaining files in command line
641 msg.user_exec.trap_all()
643 msg.user_exec.trap_all()
642
644
643 # Do NOT execute files named in the command line as scripts to be loaded
645 # Do NOT execute files named in the command line as scripts to be loaded
644 # by embedded instances. Doing so has the potential for an infinite
646 # by embedded instances. Doing so has the potential for an infinite
645 # recursion if there are exceptions thrown in the process.
647 # recursion if there are exceptions thrown in the process.
646
648
647 # XXX FIXME: the execution of user files should be moved out to after
649 # XXX FIXME: the execution of user files should be moved out to after
648 # ipython is fully initialized, just as if they were run via %run at the
650 # ipython is fully initialized, just as if they were run via %run at the
649 # ipython prompt. This would also give them the benefit of ipython's
651 # ipython prompt. This would also give them the benefit of ipython's
650 # nice tracebacks.
652 # nice tracebacks.
651
653
652 if not embedded and IP_rc.args:
654 if not embedded and IP_rc.args:
653 name_save = IP.user_ns['__name__']
655 name_save = IP.user_ns['__name__']
654 IP.user_ns['__name__'] = '__main__'
656 IP.user_ns['__name__'] = '__main__'
655 try:
657 try:
656 # Set our own excepthook in case the user code tries to call it
658 # Set our own excepthook in case the user code tries to call it
657 # directly. This prevents triggering the IPython crash handler.
659 # directly. This prevents triggering the IPython crash handler.
658 old_excepthook,sys.excepthook = sys.excepthook, IP.excepthook
660 old_excepthook,sys.excepthook = sys.excepthook, IP.excepthook
659 for run in args:
661 for run in args:
660 IP.safe_execfile(run,IP.user_ns)
662 IP.safe_execfile(run,IP.user_ns)
661 finally:
663 finally:
662 # Reset our crash handler in place
664 # Reset our crash handler in place
663 sys.excepthook = old_excepthook
665 sys.excepthook = old_excepthook
664
666
665 IP.user_ns['__name__'] = name_save
667 IP.user_ns['__name__'] = name_save
666
668
667 msg.user_exec.release_all()
669 msg.user_exec.release_all()
668 if IP_rc.messages:
670 if IP_rc.messages:
669 msg.summary += msg.user_exec.summary_all()
671 msg.summary += msg.user_exec.summary_all()
670
672
671 # since we can't specify a null string on the cmd line, 0 is the equivalent:
673 # since we can't specify a null string on the cmd line, 0 is the equivalent:
672 if IP_rc.nosep:
674 if IP_rc.nosep:
673 IP_rc.separate_in = IP_rc.separate_out = IP_rc.separate_out2 = '0'
675 IP_rc.separate_in = IP_rc.separate_out = IP_rc.separate_out2 = '0'
674 if IP_rc.separate_in == '0': IP_rc.separate_in = ''
676 if IP_rc.separate_in == '0': IP_rc.separate_in = ''
675 if IP_rc.separate_out == '0': IP_rc.separate_out = ''
677 if IP_rc.separate_out == '0': IP_rc.separate_out = ''
676 if IP_rc.separate_out2 == '0': IP_rc.separate_out2 = ''
678 if IP_rc.separate_out2 == '0': IP_rc.separate_out2 = ''
677 IP_rc.separate_in = IP_rc.separate_in.replace('\\n','\n')
679 IP_rc.separate_in = IP_rc.separate_in.replace('\\n','\n')
678 IP_rc.separate_out = IP_rc.separate_out.replace('\\n','\n')
680 IP_rc.separate_out = IP_rc.separate_out.replace('\\n','\n')
679 IP_rc.separate_out2 = IP_rc.separate_out2.replace('\\n','\n')
681 IP_rc.separate_out2 = IP_rc.separate_out2.replace('\\n','\n')
680
682
681 # Determine how many lines at the bottom of the screen are needed for
683 # Determine how many lines at the bottom of the screen are needed for
682 # showing prompts, so we can know wheter long strings are to be printed or
684 # showing prompts, so we can know wheter long strings are to be printed or
683 # paged:
685 # paged:
684 num_lines_bot = IP_rc.separate_in.count('\n')+1
686 num_lines_bot = IP_rc.separate_in.count('\n')+1
685 IP_rc.screen_length = IP_rc.screen_length - num_lines_bot
687 IP_rc.screen_length = IP_rc.screen_length - num_lines_bot
686 # Initialize cache, set in/out prompts and printing system
688 # Initialize cache, set in/out prompts and printing system
687 IP.outputcache = CachedOutput(IP_rc.cache_size,
689 IP.outputcache = CachedOutput(IP_rc.cache_size,
688 IP_rc.pprint,
690 IP_rc.pprint,
689 input_sep = IP_rc.separate_in,
691 input_sep = IP_rc.separate_in,
690 output_sep = IP_rc.separate_out,
692 output_sep = IP_rc.separate_out,
691 output_sep2 = IP_rc.separate_out2,
693 output_sep2 = IP_rc.separate_out2,
692 ps1 = IP_rc.prompt_in1,
694 ps1 = IP_rc.prompt_in1,
693 ps2 = IP_rc.prompt_in2,
695 ps2 = IP_rc.prompt_in2,
694 ps_out = IP_rc.prompt_out,
696 ps_out = IP_rc.prompt_out,
695 user_ns = IP.user_ns,
697 user_ns = IP.user_ns,
696 input_hist = IP.input_hist,
698 input_hist = IP.input_hist,
697 pad_left = IP_rc.prompts_pad_left)
699 pad_left = IP_rc.prompts_pad_left)
698
700
699 # user may have over-ridden the default print hook:
701 # user may have over-ridden the default print hook:
700 try:
702 try:
701 IP.outputcache.__class__.display = IP.hooks.display
703 IP.outputcache.__class__.display = IP.hooks.display
702 except AttributeError:
704 except AttributeError:
703 pass
705 pass
704
706
705 # Set calling of pdb on exceptions
707 # Set calling of pdb on exceptions
706 IP.InteractiveTB.call_pdb = IP_rc.pdb
708 IP.InteractiveTB.call_pdb = IP_rc.pdb
707
709
708 # I don't like assigning globally to sys, because it means when embedding
710 # I don't like assigning globally to sys, because it means when embedding
709 # instances, each embedded instance overrides the previous choice. But
711 # instances, each embedded instance overrides the previous choice. But
710 # sys.displayhook seems to be called internally by exec, so I don't see a
712 # sys.displayhook seems to be called internally by exec, so I don't see a
711 # way around it.
713 # way around it.
712 sys.displayhook = IP.outputcache
714 sys.displayhook = IP.outputcache
713
715
714 # we need to know globally if we're caching i/o or not
716 # we need to know globally if we're caching i/o or not
715 IP.do_full_cache = IP.outputcache.do_full_cache
717 IP.do_full_cache = IP.outputcache.do_full_cache
716
718
717 # configure startup banner
719 # configure startup banner
718 if IP_rc.c: # regular python doesn't print the banner with -c
720 if IP_rc.c: # regular python doesn't print the banner with -c
719 IP_rc.banner = 0
721 IP_rc.banner = 0
720 if IP_rc.banner:
722 if IP_rc.banner:
721 BANN_P = IP.BANNER_PARTS
723 BANN_P = IP.BANNER_PARTS
722 else:
724 else:
723 BANN_P = []
725 BANN_P = []
724
726
725 if IP_rc.profile: BANN_P.append('IPython profile: %s\n' % IP_rc.profile)
727 if IP_rc.profile: BANN_P.append('IPython profile: %s\n' % IP_rc.profile)
726
728
727 # add message log (possibly empty)
729 # add message log (possibly empty)
728 if msg.summary: BANN_P.append(msg.summary)
730 if msg.summary: BANN_P.append(msg.summary)
729 # Final banner is a string
731 # Final banner is a string
730 IP.BANNER = '\n'.join(BANN_P)
732 IP.BANNER = '\n'.join(BANN_P)
731
733
732 # Finalize the IPython instance. This assumes the rc structure is fully
734 # Finalize the IPython instance. This assumes the rc structure is fully
733 # in place.
735 # in place.
734 IP.post_config_initialization()
736 IP.post_config_initialization()
735
737
736 return IP
738 return IP
737 #************************ end of file <ipmaker.py> **************************
739 #************************ end of file <ipmaker.py> **************************
1 NO CONTENT: modified file
NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
General Comments 0
You need to be logged in to leave comments. Login now