##// END OF EJS Templates
Fix http://www.scipy.net/roundup/ipython/issue55, a threading bug. It was...
fperez -
r267:04f05db2
parent child
Show More
@@ -1,955 +1,956
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 1079 2006-01-24 21:52:31Z vivainio $"""
7 $Id: Shell.py 1297 2006-05-13 19:14:48Z fperez $"""
8
8
9 #*****************************************************************************
9 #*****************************************************************************
10 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
10 # Copyright (C) 2001-2006 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 __builtin__
21 import __builtin__
22 import __main__
22 import __main__
23 import Queue
23 import Queue
24 import os
24 import os
25 import signal
25 import signal
26 import sys
26 import sys
27 import threading
27 import threading
28 import time
28 import time
29
29
30 import IPython
30 import IPython
31 from IPython import ultraTB
31 from IPython import ultraTB
32 from IPython.genutils import Term,warn,error,flag_calls
32 from IPython.genutils import Term,warn,error,flag_calls
33 from IPython.iplib import InteractiveShell
33 from IPython.iplib import InteractiveShell
34 from IPython.ipmaker import make_IPython
34 from IPython.ipmaker import make_IPython
35 from IPython.Magic import Magic
35 from IPython.Magic import Magic
36 from IPython.ipstruct import Struct
36 from IPython.ipstruct import Struct
37
37
38 # global flag to pass around information about Ctrl-C without exceptions
38 # global flag to pass around information about Ctrl-C without exceptions
39 KBINT = False
39 KBINT = False
40
40
41 # global flag to turn on/off Tk support.
41 # global flag to turn on/off Tk support.
42 USE_TK = False
42 USE_TK = False
43
43
44 #-----------------------------------------------------------------------------
44 #-----------------------------------------------------------------------------
45 # This class is trivial now, but I want to have it in to publish a clean
45 # This class is trivial now, but I want to have it in to publish a clean
46 # interface. Later when the internals are reorganized, code that uses this
46 # interface. Later when the internals are reorganized, code that uses this
47 # shouldn't have to change.
47 # shouldn't have to change.
48
48
49 class IPShell:
49 class IPShell:
50 """Create an IPython instance."""
50 """Create an IPython instance."""
51
51
52 def __init__(self,argv=None,user_ns=None,user_global_ns=None,
52 def __init__(self,argv=None,user_ns=None,user_global_ns=None,
53 debug=1,shell_class=InteractiveShell):
53 debug=1,shell_class=InteractiveShell):
54 self.IP = make_IPython(argv,user_ns=user_ns,user_global_ns=user_global_ns,
54 self.IP = make_IPython(argv,user_ns=user_ns,user_global_ns=user_global_ns,
55 debug=debug,shell_class=shell_class)
55 debug=debug,shell_class=shell_class)
56
56
57 def mainloop(self,sys_exit=0,banner=None):
57 def mainloop(self,sys_exit=0,banner=None):
58 self.IP.mainloop(banner)
58 self.IP.mainloop(banner)
59 if sys_exit:
59 if sys_exit:
60 sys.exit()
60 sys.exit()
61
61
62 #-----------------------------------------------------------------------------
62 #-----------------------------------------------------------------------------
63 class IPShellEmbed:
63 class IPShellEmbed:
64 """Allow embedding an IPython shell into a running program.
64 """Allow embedding an IPython shell into a running program.
65
65
66 Instances of this class are callable, with the __call__ method being an
66 Instances of this class are callable, with the __call__ method being an
67 alias to the embed() method of an InteractiveShell instance.
67 alias to the embed() method of an InteractiveShell instance.
68
68
69 Usage (see also the example-embed.py file for a running example):
69 Usage (see also the example-embed.py file for a running example):
70
70
71 ipshell = IPShellEmbed([argv,banner,exit_msg,rc_override])
71 ipshell = IPShellEmbed([argv,banner,exit_msg,rc_override])
72
72
73 - argv: list containing valid command-line options for IPython, as they
73 - argv: list containing valid command-line options for IPython, as they
74 would appear in sys.argv[1:].
74 would appear in sys.argv[1:].
75
75
76 For example, the following command-line options:
76 For example, the following command-line options:
77
77
78 $ ipython -prompt_in1 'Input <\\#>' -colors LightBG
78 $ ipython -prompt_in1 'Input <\\#>' -colors LightBG
79
79
80 would be passed in the argv list as:
80 would be passed in the argv list as:
81
81
82 ['-prompt_in1','Input <\\#>','-colors','LightBG']
82 ['-prompt_in1','Input <\\#>','-colors','LightBG']
83
83
84 - banner: string which gets printed every time the interpreter starts.
84 - banner: string which gets printed every time the interpreter starts.
85
85
86 - exit_msg: string which gets printed every time the interpreter exits.
86 - exit_msg: string which gets printed every time the interpreter exits.
87
87
88 - rc_override: a dict or Struct of configuration options such as those
88 - rc_override: a dict or Struct of configuration options such as those
89 used by IPython. These options are read from your ~/.ipython/ipythonrc
89 used by IPython. These options are read from your ~/.ipython/ipythonrc
90 file when the Shell object is created. Passing an explicit rc_override
90 file when the Shell object is created. Passing an explicit rc_override
91 dict with any options you want allows you to override those values at
91 dict with any options you want allows you to override those values at
92 creation time without having to modify the file. This way you can create
92 creation time without having to modify the file. This way you can create
93 embeddable instances configured in any way you want without editing any
93 embeddable instances configured in any way you want without editing any
94 global files (thus keeping your interactive IPython configuration
94 global files (thus keeping your interactive IPython configuration
95 unchanged).
95 unchanged).
96
96
97 Then the ipshell instance can be called anywhere inside your code:
97 Then the ipshell instance can be called anywhere inside your code:
98
98
99 ipshell(header='') -> Opens up an IPython shell.
99 ipshell(header='') -> Opens up an IPython shell.
100
100
101 - header: string printed by the IPython shell upon startup. This can let
101 - header: string printed by the IPython shell upon startup. This can let
102 you know where in your code you are when dropping into the shell. Note
102 you know where in your code you are when dropping into the shell. Note
103 that 'banner' gets prepended to all calls, so header is used for
103 that 'banner' gets prepended to all calls, so header is used for
104 location-specific information.
104 location-specific information.
105
105
106 For more details, see the __call__ method below.
106 For more details, see the __call__ method below.
107
107
108 When the IPython shell is exited with Ctrl-D, normal program execution
108 When the IPython shell is exited with Ctrl-D, normal program execution
109 resumes.
109 resumes.
110
110
111 This functionality was inspired by a posting on comp.lang.python by cmkl
111 This functionality was inspired by a posting on comp.lang.python by cmkl
112 <cmkleffner@gmx.de> on Dec. 06/01 concerning similar uses of pyrepl, and
112 <cmkleffner@gmx.de> on Dec. 06/01 concerning similar uses of pyrepl, and
113 by the IDL stop/continue commands."""
113 by the IDL stop/continue commands."""
114
114
115 def __init__(self,argv=None,banner='',exit_msg=None,rc_override=None):
115 def __init__(self,argv=None,banner='',exit_msg=None,rc_override=None):
116 """Note that argv here is a string, NOT a list."""
116 """Note that argv here is a string, NOT a list."""
117 self.set_banner(banner)
117 self.set_banner(banner)
118 self.set_exit_msg(exit_msg)
118 self.set_exit_msg(exit_msg)
119 self.set_dummy_mode(0)
119 self.set_dummy_mode(0)
120
120
121 # sys.displayhook is a global, we need to save the user's original
121 # sys.displayhook is a global, we need to save the user's original
122 # Don't rely on __displayhook__, as the user may have changed that.
122 # Don't rely on __displayhook__, as the user may have changed that.
123 self.sys_displayhook_ori = sys.displayhook
123 self.sys_displayhook_ori = sys.displayhook
124
124
125 # save readline completer status
125 # save readline completer status
126 try:
126 try:
127 #print 'Save completer',sys.ipcompleter # dbg
127 #print 'Save completer',sys.ipcompleter # dbg
128 self.sys_ipcompleter_ori = sys.ipcompleter
128 self.sys_ipcompleter_ori = sys.ipcompleter
129 except:
129 except:
130 pass # not nested with IPython
130 pass # not nested with IPython
131
131
132 # FIXME. Passing user_ns breaks namespace handling.
132 # FIXME. Passing user_ns breaks namespace handling.
133 #self.IP = make_IPython(argv,user_ns=__main__.__dict__)
133 #self.IP = make_IPython(argv,user_ns=__main__.__dict__)
134 self.IP = make_IPython(argv,rc_override=rc_override,embedded=True)
134 self.IP = make_IPython(argv,rc_override=rc_override,embedded=True)
135
135
136 # copy our own displayhook also
136 # copy our own displayhook also
137 self.sys_displayhook_embed = sys.displayhook
137 self.sys_displayhook_embed = sys.displayhook
138 # and leave the system's display hook clean
138 # and leave the system's display hook clean
139 sys.displayhook = self.sys_displayhook_ori
139 sys.displayhook = self.sys_displayhook_ori
140 # don't use the ipython crash handler so that user exceptions aren't
140 # don't use the ipython crash handler so that user exceptions aren't
141 # trapped
141 # trapped
142 sys.excepthook = ultraTB.FormattedTB(color_scheme = self.IP.rc.colors,
142 sys.excepthook = ultraTB.FormattedTB(color_scheme = self.IP.rc.colors,
143 mode = self.IP.rc.xmode,
143 mode = self.IP.rc.xmode,
144 call_pdb = self.IP.rc.pdb)
144 call_pdb = self.IP.rc.pdb)
145 self.restore_system_completer()
145 self.restore_system_completer()
146
146
147 def restore_system_completer(self):
147 def restore_system_completer(self):
148 """Restores the readline completer which was in place.
148 """Restores the readline completer which was in place.
149
149
150 This allows embedded IPython within IPython not to disrupt the
150 This allows embedded IPython within IPython not to disrupt the
151 parent's completion.
151 parent's completion.
152 """
152 """
153
153
154 try:
154 try:
155 self.IP.readline.set_completer(self.sys_ipcompleter_ori)
155 self.IP.readline.set_completer(self.sys_ipcompleter_ori)
156 sys.ipcompleter = self.sys_ipcompleter_ori
156 sys.ipcompleter = self.sys_ipcompleter_ori
157 except:
157 except:
158 pass
158 pass
159
159
160 def __call__(self,header='',local_ns=None,global_ns=None,dummy=None):
160 def __call__(self,header='',local_ns=None,global_ns=None,dummy=None):
161 """Activate the interactive interpreter.
161 """Activate the interactive interpreter.
162
162
163 __call__(self,header='',local_ns=None,global_ns,dummy=None) -> Start
163 __call__(self,header='',local_ns=None,global_ns,dummy=None) -> Start
164 the interpreter shell with the given local and global namespaces, and
164 the interpreter shell with the given local and global namespaces, and
165 optionally print a header string at startup.
165 optionally print a header string at startup.
166
166
167 The shell can be globally activated/deactivated using the
167 The shell can be globally activated/deactivated using the
168 set/get_dummy_mode methods. This allows you to turn off a shell used
168 set/get_dummy_mode methods. This allows you to turn off a shell used
169 for debugging globally.
169 for debugging globally.
170
170
171 However, *each* time you call the shell you can override the current
171 However, *each* time you call the shell you can override the current
172 state of dummy_mode with the optional keyword parameter 'dummy'. For
172 state of dummy_mode with the optional keyword parameter 'dummy'. For
173 example, if you set dummy mode on with IPShell.set_dummy_mode(1), you
173 example, if you set dummy mode on with IPShell.set_dummy_mode(1), you
174 can still have a specific call work by making it as IPShell(dummy=0).
174 can still have a specific call work by making it as IPShell(dummy=0).
175
175
176 The optional keyword parameter dummy controls whether the call
176 The optional keyword parameter dummy controls whether the call
177 actually does anything. """
177 actually does anything. """
178
178
179 # Allow the dummy parameter to override the global __dummy_mode
179 # Allow the dummy parameter to override the global __dummy_mode
180 if dummy or (dummy != 0 and self.__dummy_mode):
180 if dummy or (dummy != 0 and self.__dummy_mode):
181 return
181 return
182
182
183 # Set global subsystems (display,completions) to our values
183 # Set global subsystems (display,completions) to our values
184 sys.displayhook = self.sys_displayhook_embed
184 sys.displayhook = self.sys_displayhook_embed
185 if self.IP.has_readline:
185 if self.IP.has_readline:
186 self.IP.readline.set_completer(self.IP.Completer.complete)
186 self.IP.readline.set_completer(self.IP.Completer.complete)
187
187
188 if self.banner and header:
188 if self.banner and header:
189 format = '%s\n%s\n'
189 format = '%s\n%s\n'
190 else:
190 else:
191 format = '%s%s\n'
191 format = '%s%s\n'
192 banner = format % (self.banner,header)
192 banner = format % (self.banner,header)
193
193
194 # Call the embedding code with a stack depth of 1 so it can skip over
194 # Call the embedding code with a stack depth of 1 so it can skip over
195 # our call and get the original caller's namespaces.
195 # our call and get the original caller's namespaces.
196 self.IP.embed_mainloop(banner,local_ns,global_ns,stack_depth=1)
196 self.IP.embed_mainloop(banner,local_ns,global_ns,stack_depth=1)
197
197
198 if self.exit_msg:
198 if self.exit_msg:
199 print self.exit_msg
199 print self.exit_msg
200
200
201 # Restore global systems (display, completion)
201 # Restore global systems (display, completion)
202 sys.displayhook = self.sys_displayhook_ori
202 sys.displayhook = self.sys_displayhook_ori
203 self.restore_system_completer()
203 self.restore_system_completer()
204
204
205 def set_dummy_mode(self,dummy):
205 def set_dummy_mode(self,dummy):
206 """Sets the embeddable shell's dummy mode parameter.
206 """Sets the embeddable shell's dummy mode parameter.
207
207
208 set_dummy_mode(dummy): dummy = 0 or 1.
208 set_dummy_mode(dummy): dummy = 0 or 1.
209
209
210 This parameter is persistent and makes calls to the embeddable shell
210 This parameter is persistent and makes calls to the embeddable shell
211 silently return without performing any action. This allows you to
211 silently return without performing any action. This allows you to
212 globally activate or deactivate a shell you're using with a single call.
212 globally activate or deactivate a shell you're using with a single call.
213
213
214 If you need to manually"""
214 If you need to manually"""
215
215
216 if dummy not in [0,1,False,True]:
216 if dummy not in [0,1,False,True]:
217 raise ValueError,'dummy parameter must be boolean'
217 raise ValueError,'dummy parameter must be boolean'
218 self.__dummy_mode = dummy
218 self.__dummy_mode = dummy
219
219
220 def get_dummy_mode(self):
220 def get_dummy_mode(self):
221 """Return the current value of the dummy mode parameter.
221 """Return the current value of the dummy mode parameter.
222 """
222 """
223 return self.__dummy_mode
223 return self.__dummy_mode
224
224
225 def set_banner(self,banner):
225 def set_banner(self,banner):
226 """Sets the global banner.
226 """Sets the global banner.
227
227
228 This banner gets prepended to every header printed when the shell
228 This banner gets prepended to every header printed when the shell
229 instance is called."""
229 instance is called."""
230
230
231 self.banner = banner
231 self.banner = banner
232
232
233 def set_exit_msg(self,exit_msg):
233 def set_exit_msg(self,exit_msg):
234 """Sets the global exit_msg.
234 """Sets the global exit_msg.
235
235
236 This exit message gets printed upon exiting every time the embedded
236 This exit message gets printed upon exiting every time the embedded
237 shell is called. It is None by default. """
237 shell is called. It is None by default. """
238
238
239 self.exit_msg = exit_msg
239 self.exit_msg = exit_msg
240
240
241 #-----------------------------------------------------------------------------
241 #-----------------------------------------------------------------------------
242 def sigint_handler (signum,stack_frame):
242 def sigint_handler (signum,stack_frame):
243 """Sigint handler for threaded apps.
243 """Sigint handler for threaded apps.
244
244
245 This is a horrible hack to pass information about SIGINT _without_ using
245 This is a horrible hack to pass information about SIGINT _without_ using
246 exceptions, since I haven't been able to properly manage cross-thread
246 exceptions, since I haven't been able to properly manage cross-thread
247 exceptions in GTK/WX. In fact, I don't think it can be done (or at least
247 exceptions in GTK/WX. In fact, I don't think it can be done (or at least
248 that's my understanding from a c.l.py thread where this was discussed)."""
248 that's my understanding from a c.l.py thread where this was discussed)."""
249
249
250 global KBINT
250 global KBINT
251
251
252 print '\nKeyboardInterrupt - Press <Enter> to continue.',
252 print '\nKeyboardInterrupt - Press <Enter> to continue.',
253 Term.cout.flush()
253 Term.cout.flush()
254 # Set global flag so that runsource can know that Ctrl-C was hit
254 # Set global flag so that runsource can know that Ctrl-C was hit
255 KBINT = True
255 KBINT = True
256
256
257 class MTInteractiveShell(InteractiveShell):
257 class MTInteractiveShell(InteractiveShell):
258 """Simple multi-threaded shell."""
258 """Simple multi-threaded shell."""
259
259
260 # Threading strategy taken from:
260 # Threading strategy taken from:
261 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/65109, by Brian
261 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/65109, by Brian
262 # McErlean and John Finlay. Modified with corrections by Antoon Pardon,
262 # McErlean and John Finlay. Modified with corrections by Antoon Pardon,
263 # from the pygtk mailing list, to avoid lockups with system calls.
263 # from the pygtk mailing list, to avoid lockups with system calls.
264
264
265 # class attribute to indicate whether the class supports threads or not.
265 # class attribute to indicate whether the class supports threads or not.
266 # Subclasses with thread support should override this as needed.
266 # Subclasses with thread support should override this as needed.
267 isthreaded = True
267 isthreaded = True
268
268
269 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
269 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
270 user_ns=None,user_global_ns=None,banner2='',**kw):
270 user_ns=None,user_global_ns=None,banner2='',**kw):
271 """Similar to the normal InteractiveShell, but with threading control"""
271 """Similar to the normal InteractiveShell, but with threading control"""
272
272
273 InteractiveShell.__init__(self,name,usage,rc,user_ns,
273 InteractiveShell.__init__(self,name,usage,rc,user_ns,
274 user_global_ns,banner2)
274 user_global_ns,banner2)
275
275
276 # Locking control variable. We need to use a norma lock, not an RLock
276 # Locking control variable. We need to use a norma lock, not an RLock
277 # here. I'm not exactly sure why, it seems to me like it should be
277 # here. I'm not exactly sure why, it seems to me like it should be
278 # the opposite, but we deadlock with an RLock. Puzzled...
278 # the opposite, but we deadlock with an RLock. Puzzled...
279 self.thread_ready = threading.Condition(threading.Lock())
279 self.thread_ready = threading.Condition(threading.Lock())
280
280
281 # A queue to hold the code to be executed. A scalar variable is NOT
281 # A queue to hold the code to be executed. A scalar variable is NOT
282 # enough, because uses like macros cause reentrancy.
282 # enough, because uses like macros cause reentrancy.
283 self.code_queue = Queue.Queue()
283 self.code_queue = Queue.Queue()
284
284
285 # Stuff to do at closing time
285 # Stuff to do at closing time
286 self._kill = False
286 self._kill = False
287 on_kill = kw.get('on_kill')
287 on_kill = kw.get('on_kill')
288 if on_kill is None:
288 if on_kill is None:
289 on_kill = []
289 on_kill = []
290 # Check that all things to kill are callable:
290 # Check that all things to kill are callable:
291 for t in on_kill:
291 for t in on_kill:
292 if not callable(t):
292 if not callable(t):
293 raise TypeError,'on_kill must be a list of callables'
293 raise TypeError,'on_kill must be a list of callables'
294 self.on_kill = on_kill
294 self.on_kill = on_kill
295
295
296 def runsource(self, source, filename="<input>", symbol="single"):
296 def runsource(self, source, filename="<input>", symbol="single"):
297 """Compile and run some source in the interpreter.
297 """Compile and run some source in the interpreter.
298
298
299 Modified version of code.py's runsource(), to handle threading issues.
299 Modified version of code.py's runsource(), to handle threading issues.
300 See the original for full docstring details."""
300 See the original for full docstring details."""
301
301
302 global KBINT
302 global KBINT
303
303
304 # If Ctrl-C was typed, we reset the flag and return right away
304 # If Ctrl-C was typed, we reset the flag and return right away
305 if KBINT:
305 if KBINT:
306 KBINT = False
306 KBINT = False
307 return False
307 return False
308
308
309 try:
309 try:
310 code = self.compile(source, filename, symbol)
310 code = self.compile(source, filename, symbol)
311 except (OverflowError, SyntaxError, ValueError):
311 except (OverflowError, SyntaxError, ValueError):
312 # Case 1
312 # Case 1
313 self.showsyntaxerror(filename)
313 self.showsyntaxerror(filename)
314 return False
314 return False
315
315
316 if code is None:
316 if code is None:
317 # Case 2
317 # Case 2
318 return True
318 return True
319
319
320 # Case 3
320 # Case 3
321 # Store code in queue, so the execution thread can handle it.
321 # Store code in queue, so the execution thread can handle it.
322
322
323 # Note that with macros and other applications, we MAY re-enter this
323 # Note that with macros and other applications, we MAY re-enter this
324 # section, so we have to acquire the lock with non-blocking semantics,
324 # section, so we have to acquire the lock with non-blocking semantics,
325 # else we deadlock.
325 # else we deadlock.
326 got_lock = self.thread_ready.acquire(False)
326 got_lock = self.thread_ready.acquire(False)
327 self.code_queue.put(code)
327 self.code_queue.put(code)
328 if got_lock:
328 if got_lock:
329 self.thread_ready.wait() # Wait until processed in timeout interval
329 self.thread_ready.wait() # Wait until processed in timeout interval
330 self.thread_ready.release()
330 self.thread_ready.release()
331
331
332 return False
332 return False
333
333
334 def runcode(self):
334 def runcode(self):
335 """Execute a code object.
335 """Execute a code object.
336
336
337 Multithreaded wrapper around IPython's runcode()."""
337 Multithreaded wrapper around IPython's runcode()."""
338
338
339 # lock thread-protected stuff
339 # lock thread-protected stuff
340 self.thread_ready.acquire(False)
340 got_lock = self.thread_ready.acquire(False)
341
341
342 # Install sigint handler
342 # Install sigint handler
343 try:
343 try:
344 signal.signal(signal.SIGINT, sigint_handler)
344 signal.signal(signal.SIGINT, sigint_handler)
345 except SystemError:
345 except SystemError:
346 # This happens under Windows, which seems to have all sorts
346 # This happens under Windows, which seems to have all sorts
347 # of problems with signal handling. Oh well...
347 # of problems with signal handling. Oh well...
348 pass
348 pass
349
349
350 if self._kill:
350 if self._kill:
351 print >>Term.cout, 'Closing threads...',
351 print >>Term.cout, 'Closing threads...',
352 Term.cout.flush()
352 Term.cout.flush()
353 for tokill in self.on_kill:
353 for tokill in self.on_kill:
354 tokill()
354 tokill()
355 print >>Term.cout, 'Done.'
355 print >>Term.cout, 'Done.'
356
356
357 # Flush queue of pending code by calling the run methood of the parent
357 # Flush queue of pending code by calling the run methood of the parent
358 # class with all items which may be in the queue.
358 # class with all items which may be in the queue.
359 while 1:
359 while 1:
360 try:
360 try:
361 code_to_run = self.code_queue.get_nowait()
361 code_to_run = self.code_queue.get_nowait()
362 except Queue.Empty:
362 except Queue.Empty:
363 break
363 break
364 self.thread_ready.notify()
364 self.thread_ready.notify()
365 InteractiveShell.runcode(self,code_to_run)
365 InteractiveShell.runcode(self,code_to_run)
366
366
367 # We're done with thread-protected variables
367 # We're done with thread-protected variables
368 self.thread_ready.release()
368 if got_lock:
369 self.thread_ready.release()
369 # This MUST return true for gtk threading to work
370 # This MUST return true for gtk threading to work
370 return True
371 return True
371
372
372 def kill (self):
373 def kill (self):
373 """Kill the thread, returning when it has been shut down."""
374 """Kill the thread, returning when it has been shut down."""
374 self.thread_ready.acquire(False)
375 self.thread_ready.acquire(False)
375 self._kill = True
376 self._kill = True
376 self.thread_ready.release()
377 self.thread_ready.release()
377
378
378 class MatplotlibShellBase:
379 class MatplotlibShellBase:
379 """Mixin class to provide the necessary modifications to regular IPython
380 """Mixin class to provide the necessary modifications to regular IPython
380 shell classes for matplotlib support.
381 shell classes for matplotlib support.
381
382
382 Given Python's MRO, this should be used as the FIRST class in the
383 Given Python's MRO, this should be used as the FIRST class in the
383 inheritance hierarchy, so that it overrides the relevant methods."""
384 inheritance hierarchy, so that it overrides the relevant methods."""
384
385
385 def _matplotlib_config(self,name):
386 def _matplotlib_config(self,name):
386 """Return items needed to setup the user's shell with matplotlib"""
387 """Return items needed to setup the user's shell with matplotlib"""
387
388
388 # Initialize matplotlib to interactive mode always
389 # Initialize matplotlib to interactive mode always
389 import matplotlib
390 import matplotlib
390 from matplotlib import backends
391 from matplotlib import backends
391 matplotlib.interactive(True)
392 matplotlib.interactive(True)
392
393
393 def use(arg):
394 def use(arg):
394 """IPython wrapper for matplotlib's backend switcher.
395 """IPython wrapper for matplotlib's backend switcher.
395
396
396 In interactive use, we can not allow switching to a different
397 In interactive use, we can not allow switching to a different
397 interactive backend, since thread conflicts will most likely crash
398 interactive backend, since thread conflicts will most likely crash
398 the python interpreter. This routine does a safety check first,
399 the python interpreter. This routine does a safety check first,
399 and refuses to perform a dangerous switch. It still allows
400 and refuses to perform a dangerous switch. It still allows
400 switching to non-interactive backends."""
401 switching to non-interactive backends."""
401
402
402 if arg in backends.interactive_bk and arg != self.mpl_backend:
403 if arg in backends.interactive_bk and arg != self.mpl_backend:
403 m=('invalid matplotlib backend switch.\n'
404 m=('invalid matplotlib backend switch.\n'
404 'This script attempted to switch to the interactive '
405 'This script attempted to switch to the interactive '
405 'backend: `%s`\n'
406 'backend: `%s`\n'
406 'Your current choice of interactive backend is: `%s`\n\n'
407 'Your current choice of interactive backend is: `%s`\n\n'
407 'Switching interactive matplotlib backends at runtime\n'
408 'Switching interactive matplotlib backends at runtime\n'
408 'would crash the python interpreter, '
409 'would crash the python interpreter, '
409 'and IPython has blocked it.\n\n'
410 'and IPython has blocked it.\n\n'
410 'You need to either change your choice of matplotlib backend\n'
411 'You need to either change your choice of matplotlib backend\n'
411 'by editing your .matplotlibrc file, or run this script as a \n'
412 'by editing your .matplotlibrc file, or run this script as a \n'
412 'standalone file from the command line, not using IPython.\n' %
413 'standalone file from the command line, not using IPython.\n' %
413 (arg,self.mpl_backend) )
414 (arg,self.mpl_backend) )
414 raise RuntimeError, m
415 raise RuntimeError, m
415 else:
416 else:
416 self.mpl_use(arg)
417 self.mpl_use(arg)
417 self.mpl_use._called = True
418 self.mpl_use._called = True
418
419
419 self.matplotlib = matplotlib
420 self.matplotlib = matplotlib
420 self.mpl_backend = matplotlib.rcParams['backend']
421 self.mpl_backend = matplotlib.rcParams['backend']
421
422
422 # we also need to block switching of interactive backends by use()
423 # we also need to block switching of interactive backends by use()
423 self.mpl_use = matplotlib.use
424 self.mpl_use = matplotlib.use
424 self.mpl_use._called = False
425 self.mpl_use._called = False
425 # overwrite the original matplotlib.use with our wrapper
426 # overwrite the original matplotlib.use with our wrapper
426 matplotlib.use = use
427 matplotlib.use = use
427
428
428 # This must be imported last in the matplotlib series, after
429 # This must be imported last in the matplotlib series, after
429 # backend/interactivity choices have been made
430 # backend/interactivity choices have been made
430 try:
431 try:
431 import matplotlib.pylab as pylab
432 import matplotlib.pylab as pylab
432 self.pylab = pylab
433 self.pylab = pylab
433 self.pylab_name = 'pylab'
434 self.pylab_name = 'pylab'
434 except ImportError:
435 except ImportError:
435 import matplotlib.matlab as matlab
436 import matplotlib.matlab as matlab
436 self.pylab = matlab
437 self.pylab = matlab
437 self.pylab_name = 'matlab'
438 self.pylab_name = 'matlab'
438
439
439 self.pylab.show._needmain = False
440 self.pylab.show._needmain = False
440 # We need to detect at runtime whether show() is called by the user.
441 # We need to detect at runtime whether show() is called by the user.
441 # For this, we wrap it into a decorator which adds a 'called' flag.
442 # For this, we wrap it into a decorator which adds a 'called' flag.
442 self.pylab.draw_if_interactive = flag_calls(self.pylab.draw_if_interactive)
443 self.pylab.draw_if_interactive = flag_calls(self.pylab.draw_if_interactive)
443
444
444 # Build a user namespace initialized with matplotlib/matlab features.
445 # Build a user namespace initialized with matplotlib/matlab features.
445 user_ns = {'__name__':'__main__',
446 user_ns = {'__name__':'__main__',
446 '__builtins__' : __builtin__ }
447 '__builtins__' : __builtin__ }
447
448
448 # Be careful not to remove the final \n in the code string below, or
449 # Be careful not to remove the final \n in the code string below, or
449 # things will break badly with py22 (I think it's a python bug, 2.3 is
450 # things will break badly with py22 (I think it's a python bug, 2.3 is
450 # OK).
451 # OK).
451 pname = self.pylab_name # Python can't interpolate dotted var names
452 pname = self.pylab_name # Python can't interpolate dotted var names
452 exec ("import matplotlib\n"
453 exec ("import matplotlib\n"
453 "import matplotlib.%(pname)s as %(pname)s\n"
454 "import matplotlib.%(pname)s as %(pname)s\n"
454 "from matplotlib.%(pname)s import *\n" % locals()) in user_ns
455 "from matplotlib.%(pname)s import *\n" % locals()) in user_ns
455
456
456 # Build matplotlib info banner
457 # Build matplotlib info banner
457 b="""
458 b="""
458 Welcome to pylab, a matplotlib-based Python environment.
459 Welcome to pylab, a matplotlib-based Python environment.
459 For more information, type 'help(pylab)'.
460 For more information, type 'help(pylab)'.
460 """
461 """
461 return user_ns,b
462 return user_ns,b
462
463
463 def mplot_exec(self,fname,*where,**kw):
464 def mplot_exec(self,fname,*where,**kw):
464 """Execute a matplotlib script.
465 """Execute a matplotlib script.
465
466
466 This is a call to execfile(), but wrapped in safeties to properly
467 This is a call to execfile(), but wrapped in safeties to properly
467 handle interactive rendering and backend switching."""
468 handle interactive rendering and backend switching."""
468
469
469 #print '*** Matplotlib runner ***' # dbg
470 #print '*** Matplotlib runner ***' # dbg
470 # turn off rendering until end of script
471 # turn off rendering until end of script
471 isInteractive = self.matplotlib.rcParams['interactive']
472 isInteractive = self.matplotlib.rcParams['interactive']
472 self.matplotlib.interactive(False)
473 self.matplotlib.interactive(False)
473 self.safe_execfile(fname,*where,**kw)
474 self.safe_execfile(fname,*where,**kw)
474 self.matplotlib.interactive(isInteractive)
475 self.matplotlib.interactive(isInteractive)
475 # make rendering call now, if the user tried to do it
476 # make rendering call now, if the user tried to do it
476 if self.pylab.draw_if_interactive.called:
477 if self.pylab.draw_if_interactive.called:
477 self.pylab.draw()
478 self.pylab.draw()
478 self.pylab.draw_if_interactive.called = False
479 self.pylab.draw_if_interactive.called = False
479
480
480 # if a backend switch was performed, reverse it now
481 # if a backend switch was performed, reverse it now
481 if self.mpl_use._called:
482 if self.mpl_use._called:
482 self.matplotlib.rcParams['backend'] = self.mpl_backend
483 self.matplotlib.rcParams['backend'] = self.mpl_backend
483
484
484 def magic_run(self,parameter_s=''):
485 def magic_run(self,parameter_s=''):
485 Magic.magic_run(self,parameter_s,runner=self.mplot_exec)
486 Magic.magic_run(self,parameter_s,runner=self.mplot_exec)
486
487
487 # Fix the docstring so users see the original as well
488 # Fix the docstring so users see the original as well
488 magic_run.__doc__ = "%s\n%s" % (Magic.magic_run.__doc__,
489 magic_run.__doc__ = "%s\n%s" % (Magic.magic_run.__doc__,
489 "\n *** Modified %run for Matplotlib,"
490 "\n *** Modified %run for Matplotlib,"
490 " with proper interactive handling ***")
491 " with proper interactive handling ***")
491
492
492 # Now we provide 2 versions of a matplotlib-aware IPython base shells, single
493 # Now we provide 2 versions of a matplotlib-aware IPython base shells, single
493 # and multithreaded. Note that these are meant for internal use, the IPShell*
494 # and multithreaded. Note that these are meant for internal use, the IPShell*
494 # classes below are the ones meant for public consumption.
495 # classes below are the ones meant for public consumption.
495
496
496 class MatplotlibShell(MatplotlibShellBase,InteractiveShell):
497 class MatplotlibShell(MatplotlibShellBase,InteractiveShell):
497 """Single-threaded shell with matplotlib support."""
498 """Single-threaded shell with matplotlib support."""
498
499
499 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
500 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
500 user_ns=None,user_global_ns=None,**kw):
501 user_ns=None,user_global_ns=None,**kw):
501 user_ns,b2 = self._matplotlib_config(name)
502 user_ns,b2 = self._matplotlib_config(name)
502 InteractiveShell.__init__(self,name,usage,rc,user_ns,user_global_ns,
503 InteractiveShell.__init__(self,name,usage,rc,user_ns,user_global_ns,
503 banner2=b2,**kw)
504 banner2=b2,**kw)
504
505
505 class MatplotlibMTShell(MatplotlibShellBase,MTInteractiveShell):
506 class MatplotlibMTShell(MatplotlibShellBase,MTInteractiveShell):
506 """Multi-threaded shell with matplotlib support."""
507 """Multi-threaded shell with matplotlib support."""
507
508
508 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
509 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
509 user_ns=None,user_global_ns=None, **kw):
510 user_ns=None,user_global_ns=None, **kw):
510 user_ns,b2 = self._matplotlib_config(name)
511 user_ns,b2 = self._matplotlib_config(name)
511 MTInteractiveShell.__init__(self,name,usage,rc,user_ns,user_global_ns,
512 MTInteractiveShell.__init__(self,name,usage,rc,user_ns,user_global_ns,
512 banner2=b2,**kw)
513 banner2=b2,**kw)
513
514
514 #-----------------------------------------------------------------------------
515 #-----------------------------------------------------------------------------
515 # Utility functions for the different GUI enabled IPShell* classes.
516 # Utility functions for the different GUI enabled IPShell* classes.
516
517
517 def get_tk():
518 def get_tk():
518 """Tries to import Tkinter and returns a withdrawn Tkinter root
519 """Tries to import Tkinter and returns a withdrawn Tkinter root
519 window. If Tkinter is already imported or not available, this
520 window. If Tkinter is already imported or not available, this
520 returns None. This function calls `hijack_tk` underneath.
521 returns None. This function calls `hijack_tk` underneath.
521 """
522 """
522 if not USE_TK or sys.modules.has_key('Tkinter'):
523 if not USE_TK or sys.modules.has_key('Tkinter'):
523 return None
524 return None
524 else:
525 else:
525 try:
526 try:
526 import Tkinter
527 import Tkinter
527 except ImportError:
528 except ImportError:
528 return None
529 return None
529 else:
530 else:
530 hijack_tk()
531 hijack_tk()
531 r = Tkinter.Tk()
532 r = Tkinter.Tk()
532 r.withdraw()
533 r.withdraw()
533 return r
534 return r
534
535
535 def hijack_tk():
536 def hijack_tk():
536 """Modifies Tkinter's mainloop with a dummy so when a module calls
537 """Modifies Tkinter's mainloop with a dummy so when a module calls
537 mainloop, it does not block.
538 mainloop, it does not block.
538
539
539 """
540 """
540 def misc_mainloop(self, n=0):
541 def misc_mainloop(self, n=0):
541 pass
542 pass
542 def tkinter_mainloop(n=0):
543 def tkinter_mainloop(n=0):
543 pass
544 pass
544
545
545 import Tkinter
546 import Tkinter
546 Tkinter.Misc.mainloop = misc_mainloop
547 Tkinter.Misc.mainloop = misc_mainloop
547 Tkinter.mainloop = tkinter_mainloop
548 Tkinter.mainloop = tkinter_mainloop
548
549
549 def update_tk(tk):
550 def update_tk(tk):
550 """Updates the Tkinter event loop. This is typically called from
551 """Updates the Tkinter event loop. This is typically called from
551 the respective WX or GTK mainloops.
552 the respective WX or GTK mainloops.
552 """
553 """
553 if tk:
554 if tk:
554 tk.update()
555 tk.update()
555
556
556 def hijack_wx():
557 def hijack_wx():
557 """Modifies wxPython's MainLoop with a dummy so user code does not
558 """Modifies wxPython's MainLoop with a dummy so user code does not
558 block IPython. The hijacked mainloop function is returned.
559 block IPython. The hijacked mainloop function is returned.
559 """
560 """
560 def dummy_mainloop(*args, **kw):
561 def dummy_mainloop(*args, **kw):
561 pass
562 pass
562 import wxPython
563 import wxPython
563 ver = wxPython.__version__
564 ver = wxPython.__version__
564 orig_mainloop = None
565 orig_mainloop = None
565 if ver[:3] >= '2.5':
566 if ver[:3] >= '2.5':
566 import wx
567 import wx
567 if hasattr(wx, '_core_'): core = getattr(wx, '_core_')
568 if hasattr(wx, '_core_'): core = getattr(wx, '_core_')
568 elif hasattr(wx, '_core'): core = getattr(wx, '_core')
569 elif hasattr(wx, '_core'): core = getattr(wx, '_core')
569 else: raise AttributeError('Could not find wx core module')
570 else: raise AttributeError('Could not find wx core module')
570 orig_mainloop = core.PyApp_MainLoop
571 orig_mainloop = core.PyApp_MainLoop
571 core.PyApp_MainLoop = dummy_mainloop
572 core.PyApp_MainLoop = dummy_mainloop
572 elif ver[:3] == '2.4':
573 elif ver[:3] == '2.4':
573 orig_mainloop = wxPython.wxc.wxPyApp_MainLoop
574 orig_mainloop = wxPython.wxc.wxPyApp_MainLoop
574 wxPython.wxc.wxPyApp_MainLoop = dummy_mainloop
575 wxPython.wxc.wxPyApp_MainLoop = dummy_mainloop
575 else:
576 else:
576 warn("Unable to find either wxPython version 2.4 or >= 2.5.")
577 warn("Unable to find either wxPython version 2.4 or >= 2.5.")
577 return orig_mainloop
578 return orig_mainloop
578
579
579 def hijack_gtk():
580 def hijack_gtk():
580 """Modifies pyGTK's mainloop with a dummy so user code does not
581 """Modifies pyGTK's mainloop with a dummy so user code does not
581 block IPython. This function returns the original `gtk.mainloop`
582 block IPython. This function returns the original `gtk.mainloop`
582 function that has been hijacked.
583 function that has been hijacked.
583 """
584 """
584 def dummy_mainloop(*args, **kw):
585 def dummy_mainloop(*args, **kw):
585 pass
586 pass
586 import gtk
587 import gtk
587 if gtk.pygtk_version >= (2,4,0): orig_mainloop = gtk.main
588 if gtk.pygtk_version >= (2,4,0): orig_mainloop = gtk.main
588 else: orig_mainloop = gtk.mainloop
589 else: orig_mainloop = gtk.mainloop
589 gtk.mainloop = dummy_mainloop
590 gtk.mainloop = dummy_mainloop
590 gtk.main = dummy_mainloop
591 gtk.main = dummy_mainloop
591 return orig_mainloop
592 return orig_mainloop
592
593
593 #-----------------------------------------------------------------------------
594 #-----------------------------------------------------------------------------
594 # The IPShell* classes below are the ones meant to be run by external code as
595 # The IPShell* classes below are the ones meant to be run by external code as
595 # IPython instances. Note that unless a specific threading strategy is
596 # IPython instances. Note that unless a specific threading strategy is
596 # desired, the factory function start() below should be used instead (it
597 # desired, the factory function start() below should be used instead (it
597 # selects the proper threaded class).
598 # selects the proper threaded class).
598
599
599 class IPShellGTK(threading.Thread):
600 class IPShellGTK(threading.Thread):
600 """Run a gtk mainloop() in a separate thread.
601 """Run a gtk mainloop() in a separate thread.
601
602
602 Python commands can be passed to the thread where they will be executed.
603 Python commands can be passed to the thread where they will be executed.
603 This is implemented by periodically checking for passed code using a
604 This is implemented by periodically checking for passed code using a
604 GTK timeout callback."""
605 GTK timeout callback."""
605
606
606 TIMEOUT = 100 # Millisecond interval between timeouts.
607 TIMEOUT = 100 # Millisecond interval between timeouts.
607
608
608 def __init__(self,argv=None,user_ns=None,user_global_ns=None,
609 def __init__(self,argv=None,user_ns=None,user_global_ns=None,
609 debug=1,shell_class=MTInteractiveShell):
610 debug=1,shell_class=MTInteractiveShell):
610
611
611 import gtk
612 import gtk
612
613
613 self.gtk = gtk
614 self.gtk = gtk
614 self.gtk_mainloop = hijack_gtk()
615 self.gtk_mainloop = hijack_gtk()
615
616
616 # Allows us to use both Tk and GTK.
617 # Allows us to use both Tk and GTK.
617 self.tk = get_tk()
618 self.tk = get_tk()
618
619
619 if gtk.pygtk_version >= (2,4,0): mainquit = self.gtk.main_quit
620 if gtk.pygtk_version >= (2,4,0): mainquit = self.gtk.main_quit
620 else: mainquit = self.gtk.mainquit