##// END OF EJS Templates
Moving find_exe -> platutils.find_cmd and making is cross platform....
Brian Granger -
Show More
@@ -1,2866 +1,2870
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.4 or newer.
5 Requires Python 2.4 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
9
10 #*****************************************************************************
10 #*****************************************************************************
11 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
11 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
12 # Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
12 # Copyright (C) 2001-2006 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 # Note: this code originally subclassed code.InteractiveConsole from the
17 # Note: this code originally subclassed code.InteractiveConsole from the
18 # Python standard library. Over time, all of that class has been copied
18 # Python standard library. Over time, all of that class has been copied
19 # verbatim here for modifications which could not be accomplished by
19 # verbatim here for modifications which could not be accomplished by
20 # subclassing. At this point, there are no dependencies at all on the code
20 # subclassing. At this point, there are no dependencies at all on the code
21 # module anymore (it is not even imported). The Python License (sec. 2)
21 # module anymore (it is not even imported). The Python License (sec. 2)
22 # allows for this, but it's always nice to acknowledge credit where credit is
22 # allows for this, but it's always nice to acknowledge credit where credit is
23 # due.
23 # due.
24 #*****************************************************************************
24 #*****************************************************************************
25
25
26 #****************************************************************************
26 #****************************************************************************
27 # Modules and globals
27 # Modules and globals
28
28
29 # Python standard modules
29 # Python standard modules
30 import __main__
30 import __main__
31 import __builtin__
31 import __builtin__
32 import StringIO
32 import StringIO
33 import bdb
33 import bdb
34 import cPickle as pickle
34 import cPickle as pickle
35 import codeop
35 import codeop
36 import exceptions
36 import exceptions
37 import glob
37 import glob
38 import inspect
38 import inspect
39 import keyword
39 import keyword
40 import new
40 import new
41 import os
41 import os
42 import pydoc
42 import pydoc
43 import re
43 import re
44 import shutil
44 import shutil
45 import string
45 import string
46 import sys
46 import sys
47 import tempfile
47 import tempfile
48 import traceback
48 import traceback
49 import types
49 import types
50 from pprint import pprint, pformat
50 from pprint import pprint, pformat
51
51
52 # IPython's own modules
52 # IPython's own modules
53 #import IPython
53 #import IPython
54 from IPython import Debugger,OInspect,PyColorize,ultraTB
54 from IPython import Debugger,OInspect,PyColorize,ultraTB
55 from IPython.ColorANSI import ColorScheme,ColorSchemeTable # too long names
55 from IPython.ColorANSI import ColorScheme,ColorSchemeTable # too long names
56 from IPython.Extensions import pickleshare
56 from IPython.Extensions import pickleshare
57 from IPython.FakeModule import FakeModule, init_fakemod_dict
57 from IPython.FakeModule import FakeModule, init_fakemod_dict
58 from IPython.Itpl import Itpl,itpl,printpl,ItplNS,itplns
58 from IPython.Itpl import Itpl,itpl,printpl,ItplNS,itplns
59 from IPython.Logger import Logger
59 from IPython.Logger import Logger
60 from IPython.Magic import Magic
60 from IPython.Magic import Magic
61 from IPython.Prompts import CachedOutput
61 from IPython.Prompts import CachedOutput
62 from IPython.ipstruct import Struct
62 from IPython.ipstruct import Struct
63 from IPython.background_jobs import BackgroundJobManager
63 from IPython.background_jobs import BackgroundJobManager
64 from IPython.usage import cmd_line_usage,interactive_usage
64 from IPython.usage import cmd_line_usage,interactive_usage
65 from IPython.genutils import *
65 from IPython.genutils import *
66 from IPython.strdispatch import StrDispatch
66 from IPython.strdispatch import StrDispatch
67 import IPython.ipapi
67 import IPython.ipapi
68 import IPython.history
68 import IPython.history
69 import IPython.prefilter as prefilter
69 import IPython.prefilter as prefilter
70 import IPython.shadowns
70 import IPython.shadowns
71 # Globals
71 # Globals
72
72
73 # store the builtin raw_input globally, and use this always, in case user code
73 # store the builtin raw_input globally, and use this always, in case user code
74 # overwrites it (like wx.py.PyShell does)
74 # overwrites it (like wx.py.PyShell does)
75 raw_input_original = raw_input
75 raw_input_original = raw_input
76
76
77 # compiled regexps for autoindent management
77 # compiled regexps for autoindent management
78 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
78 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
79
79
80
80
81 #****************************************************************************
81 #****************************************************************************
82 # Some utility function definitions
82 # Some utility function definitions
83
83
84 ini_spaces_re = re.compile(r'^(\s+)')
84 ini_spaces_re = re.compile(r'^(\s+)')
85
85
86 def num_ini_spaces(strng):
86 def num_ini_spaces(strng):
87 """Return the number of initial spaces in a string"""
87 """Return the number of initial spaces in a string"""
88
88
89 ini_spaces = ini_spaces_re.match(strng)
89 ini_spaces = ini_spaces_re.match(strng)
90 if ini_spaces:
90 if ini_spaces:
91 return ini_spaces.end()
91 return ini_spaces.end()
92 else:
92 else:
93 return 0
93 return 0
94
94
95 def softspace(file, newvalue):
95 def softspace(file, newvalue):
96 """Copied from code.py, to remove the dependency"""
96 """Copied from code.py, to remove the dependency"""
97
97
98 oldvalue = 0
98 oldvalue = 0
99 try:
99 try:
100 oldvalue = file.softspace
100 oldvalue = file.softspace
101 except AttributeError:
101 except AttributeError:
102 pass
102 pass
103 try:
103 try:
104 file.softspace = newvalue
104 file.softspace = newvalue
105 except (AttributeError, TypeError):
105 except (AttributeError, TypeError):
106 # "attribute-less object" or "read-only attributes"
106 # "attribute-less object" or "read-only attributes"
107 pass
107 pass
108 return oldvalue
108 return oldvalue
109
109
110
110
111 def user_setup(ipythondir,rc_suffix,mode='install',interactive=True):
111 def user_setup(ipythondir,rc_suffix,mode='install',interactive=True):
112 """Install or upgrade the user configuration directory.
112 """Install or upgrade the user configuration directory.
113
113
114 Can be called when running for the first time or to upgrade the user's
114 Can be called when running for the first time or to upgrade the user's
115 .ipython/ directory.
115 .ipython/ directory.
116
116
117 Parameters
117 Parameters
118 ----------
118 ----------
119 ipythondir : path
119 ipythondir : path
120 The directory to be used for installation/upgrade. In 'install' mode,
120 The directory to be used for installation/upgrade. In 'install' mode,
121 if this path already exists, the function exits immediately.
121 if this path already exists, the function exits immediately.
122
122
123 rc_suffix : str
123 rc_suffix : str
124 Extension for the config files. On *nix platforms it is typically the
124 Extension for the config files. On *nix platforms it is typically the
125 empty string, while Windows normally uses '.ini'.
125 empty string, while Windows normally uses '.ini'.
126
126
127 mode : str, optional
127 mode : str, optional
128 Valid modes are 'install' and 'upgrade'.
128 Valid modes are 'install' and 'upgrade'.
129
129
130 interactive : bool, optional
130 interactive : bool, optional
131 If False, do not wait for user input on any errors. Normally after
131 If False, do not wait for user input on any errors. Normally after
132 printing its status information, this function waits for the user to
132 printing its status information, this function waits for the user to
133 hit Return before proceeding. This is because the default use case is
133 hit Return before proceeding. This is because the default use case is
134 when first installing the IPython configuration, so we want the user to
134 when first installing the IPython configuration, so we want the user to
135 acknowledge the initial message, which contains some useful
135 acknowledge the initial message, which contains some useful
136 information.
136 information.
137 """
137 """
138
138
139 # For automatic use, deactivate all i/o
139 # For automatic use, deactivate all i/o
140 if interactive:
140 if interactive:
141 def wait():
141 def wait():
142 try:
142 try:
143 raw_input("Please press <RETURN> to start IPython.")
143 raw_input("Please press <RETURN> to start IPython.")
144 except EOFError:
144 except EOFError:
145 print >> Term.cout
145 print >> Term.cout
146 print '*'*70
146 print '*'*70
147
147
148 def printf(s):
148 def printf(s):
149 print s
149 print s
150 else:
150 else:
151 wait = lambda : None
151 wait = lambda : None
152 printf = lambda s : None
152 printf = lambda s : None
153
153
154 # Install mode should be re-entrant: if the install dir already exists,
154 # Install mode should be re-entrant: if the install dir already exists,
155 # bail out cleanly
155 # bail out cleanly.
156 # XXX. This is too hasty to return. We need to check to make sure that
157 # all the expected config files and directories are actually there. We
158 # currently have a failure mode if someone deletes a needed config file
159 # but still has the ipythondir.
156 if mode == 'install' and os.path.isdir(ipythondir):
160 if mode == 'install' and os.path.isdir(ipythondir):
157 return
161 return
158
162
159 cwd = os.getcwd() # remember where we started
163 cwd = os.getcwd() # remember where we started
160 glb = glob.glob
164 glb = glob.glob
161
165
162 printf('*'*70)
166 printf('*'*70)
163 if mode == 'install':
167 if mode == 'install':
164 printf(
168 printf(
165 """Welcome to IPython. I will try to create a personal configuration directory
169 """Welcome to IPython. I will try to create a personal configuration directory
166 where you can customize many aspects of IPython's functionality in:\n""")
170 where you can customize many aspects of IPython's functionality in:\n""")
167 else:
171 else:
168 printf('I am going to upgrade your configuration in:')
172 printf('I am going to upgrade your configuration in:')
169
173
170 printf(ipythondir)
174 printf(ipythondir)
171
175
172 rcdirend = os.path.join('IPython','UserConfig')
176 rcdirend = os.path.join('IPython','UserConfig')
173 cfg = lambda d: os.path.join(d,rcdirend)
177 cfg = lambda d: os.path.join(d,rcdirend)
174 try:
178 try:
175 rcdir = filter(os.path.isdir,map(cfg,sys.path))[0]
179 rcdir = filter(os.path.isdir,map(cfg,sys.path))[0]
176 printf("Initializing from configuration: %s" % rcdir)
180 printf("Initializing from configuration: %s" % rcdir)
177 except IndexError:
181 except IndexError:
178 warning = """
182 warning = """
179 Installation error. IPython's directory was not found.
183 Installation error. IPython's directory was not found.
180
184
181 Check the following:
185 Check the following:
182
186
183 The ipython/IPython directory should be in a directory belonging to your
187 The ipython/IPython directory should be in a directory belonging to your
184 PYTHONPATH environment variable (that is, it should be in a directory
188 PYTHONPATH environment variable (that is, it should be in a directory
185 belonging to sys.path). You can copy it explicitly there or just link to it.
189 belonging to sys.path). You can copy it explicitly there or just link to it.
186
190
187 IPython will create a minimal default configuration for you.
191 IPython will create a minimal default configuration for you.
188
192
189 """
193 """
190 warn(warning)
194 warn(warning)
191 wait()
195 wait()
192
196
193 if sys.platform =='win32':
197 if sys.platform =='win32':
194 inif = 'ipythonrc.ini'
198 inif = 'ipythonrc.ini'
195 else:
199 else:
196 inif = 'ipythonrc'
200 inif = 'ipythonrc'
197 minimal_setup = {'ipy_user_conf.py' : 'import ipy_defaults',
201 minimal_setup = {'ipy_user_conf.py' : 'import ipy_defaults',
198 inif : '# intentionally left blank' }
202 inif : '# intentionally left blank' }
199 os.makedirs(ipythondir, mode = 0777)
203 os.makedirs(ipythondir, mode = 0777)
200 for f, cont in minimal_setup.items():
204 for f, cont in minimal_setup.items():
201 # In 2.5, this can be more cleanly done using 'with'
205 # In 2.5, this can be more cleanly done using 'with'
202 fobj = file(ipythondir + '/' + f,'w')
206 fobj = file(ipythondir + '/' + f,'w')
203 fobj.write(cont)
207 fobj.write(cont)
204 fobj.close()
208 fobj.close()
205
209
206 return
210 return
207
211
208 if mode == 'install':
212 if mode == 'install':
209 try:
213 try:
210 shutil.copytree(rcdir,ipythondir)
214 shutil.copytree(rcdir,ipythondir)
211 os.chdir(ipythondir)
215 os.chdir(ipythondir)
212 rc_files = glb("ipythonrc*")
216 rc_files = glb("ipythonrc*")
213 for rc_file in rc_files:
217 for rc_file in rc_files:
214 os.rename(rc_file,rc_file+rc_suffix)
218 os.rename(rc_file,rc_file+rc_suffix)
215 except:
219 except:
216 warning = """
220 warning = """
217
221
218 There was a problem with the installation:
222 There was a problem with the installation:
219 %s
223 %s
220 Try to correct it or contact the developers if you think it's a bug.
224 Try to correct it or contact the developers if you think it's a bug.
221 IPython will proceed with builtin defaults.""" % sys.exc_info()[1]
225 IPython will proceed with builtin defaults.""" % sys.exc_info()[1]
222 warn(warning)
226 warn(warning)
223 wait()
227 wait()
224 return
228 return
225
229
226 elif mode == 'upgrade':
230 elif mode == 'upgrade':
227 try:
231 try:
228 os.chdir(ipythondir)
232 os.chdir(ipythondir)
229 except:
233 except:
230 printf("""
234 printf("""
231 Can not upgrade: changing to directory %s failed. Details:
235 Can not upgrade: changing to directory %s failed. Details:
232 %s
236 %s
233 """ % (ipythondir,sys.exc_info()[1]) )
237 """ % (ipythondir,sys.exc_info()[1]) )
234 wait()
238 wait()
235 return
239 return
236 else:
240 else:
237 sources = glb(os.path.join(rcdir,'[A-Za-z]*'))
241 sources = glb(os.path.join(rcdir,'[A-Za-z]*'))
238 for new_full_path in sources:
242 for new_full_path in sources:
239 new_filename = os.path.basename(new_full_path)
243 new_filename = os.path.basename(new_full_path)
240 if new_filename.startswith('ipythonrc'):
244 if new_filename.startswith('ipythonrc'):
241 new_filename = new_filename + rc_suffix
245 new_filename = new_filename + rc_suffix
242 # The config directory should only contain files, skip any
246 # The config directory should only contain files, skip any
243 # directories which may be there (like CVS)
247 # directories which may be there (like CVS)
244 if os.path.isdir(new_full_path):
248 if os.path.isdir(new_full_path):
245 continue
249 continue
246 if os.path.exists(new_filename):
250 if os.path.exists(new_filename):
247 old_file = new_filename+'.old'
251 old_file = new_filename+'.old'
248 if os.path.exists(old_file):
252 if os.path.exists(old_file):
249 os.remove(old_file)
253 os.remove(old_file)
250 os.rename(new_filename,old_file)
254 os.rename(new_filename,old_file)
251 shutil.copy(new_full_path,new_filename)
255 shutil.copy(new_full_path,new_filename)
252 else:
256 else:
253 raise ValueError('unrecognized mode for install: %r' % mode)
257 raise ValueError('unrecognized mode for install: %r' % mode)
254
258
255 # Fix line-endings to those native to each platform in the config
259 # Fix line-endings to those native to each platform in the config
256 # directory.
260 # directory.
257 try:
261 try:
258 os.chdir(ipythondir)
262 os.chdir(ipythondir)
259 except:
263 except:
260 printf("""
264 printf("""
261 Problem: changing to directory %s failed.
265 Problem: changing to directory %s failed.
262 Details:
266 Details:
263 %s
267 %s
264
268
265 Some configuration files may have incorrect line endings. This should not
269 Some configuration files may have incorrect line endings. This should not
266 cause any problems during execution. """ % (ipythondir,sys.exc_info()[1]) )
270 cause any problems during execution. """ % (ipythondir,sys.exc_info()[1]) )
267 wait()
271 wait()
268 else:
272 else:
269 for fname in glb('ipythonrc*'):
273 for fname in glb('ipythonrc*'):
270 try:
274 try:
271 native_line_ends(fname,backup=0)
275 native_line_ends(fname,backup=0)
272 except IOError:
276 except IOError:
273 pass
277 pass
274
278
275 if mode == 'install':
279 if mode == 'install':
276 printf("""
280 printf("""
277 Successful installation!
281 Successful installation!
278
282
279 Please read the sections 'Initial Configuration' and 'Quick Tips' in the
283 Please read the sections 'Initial Configuration' and 'Quick Tips' in the
280 IPython manual (there are both HTML and PDF versions supplied with the
284 IPython manual (there are both HTML and PDF versions supplied with the
281 distribution) to make sure that your system environment is properly configured
285 distribution) to make sure that your system environment is properly configured
282 to take advantage of IPython's features.
286 to take advantage of IPython's features.
283
287
284 Important note: the configuration system has changed! The old system is
288 Important note: the configuration system has changed! The old system is
285 still in place, but its setting may be partly overridden by the settings in
289 still in place, but its setting may be partly overridden by the settings in
286 "~/.ipython/ipy_user_conf.py" config file. Please take a look at the file
290 "~/.ipython/ipy_user_conf.py" config file. Please take a look at the file
287 if some of the new settings bother you.
291 if some of the new settings bother you.
288
292
289 """)
293 """)
290 else:
294 else:
291 printf("""
295 printf("""
292 Successful upgrade!
296 Successful upgrade!
293
297
294 All files in your directory:
298 All files in your directory:
295 %(ipythondir)s
299 %(ipythondir)s
296 which would have been overwritten by the upgrade were backed up with a .old
300 which would have been overwritten by the upgrade were backed up with a .old
297 extension. If you had made particular customizations in those files you may
301 extension. If you had made particular customizations in those files you may
298 want to merge them back into the new files.""" % locals() )
302 want to merge them back into the new files.""" % locals() )
299 wait()
303 wait()
300 os.chdir(cwd)
304 os.chdir(cwd)
301
305
302 #****************************************************************************
306 #****************************************************************************
303 # Local use exceptions
307 # Local use exceptions
304 class SpaceInInput(exceptions.Exception): pass
308 class SpaceInInput(exceptions.Exception): pass
305
309
306
310
307 #****************************************************************************
311 #****************************************************************************
308 # Local use classes
312 # Local use classes
309 class Bunch: pass
313 class Bunch: pass
310
314
311 class Undefined: pass
315 class Undefined: pass
312
316
313 class Quitter(object):
317 class Quitter(object):
314 """Simple class to handle exit, similar to Python 2.5's.
318 """Simple class to handle exit, similar to Python 2.5's.
315
319
316 It handles exiting in an ipython-safe manner, which the one in Python 2.5
320 It handles exiting in an ipython-safe manner, which the one in Python 2.5
317 doesn't do (obviously, since it doesn't know about ipython)."""
321 doesn't do (obviously, since it doesn't know about ipython)."""
318
322
319 def __init__(self,shell,name):
323 def __init__(self,shell,name):
320 self.shell = shell
324 self.shell = shell
321 self.name = name
325 self.name = name
322
326
323 def __repr__(self):
327 def __repr__(self):
324 return 'Type %s() to exit.' % self.name
328 return 'Type %s() to exit.' % self.name
325 __str__ = __repr__
329 __str__ = __repr__
326
330
327 def __call__(self):
331 def __call__(self):
328 self.shell.exit()
332 self.shell.exit()
329
333
330 class InputList(list):
334 class InputList(list):
331 """Class to store user input.
335 """Class to store user input.
332
336
333 It's basically a list, but slices return a string instead of a list, thus
337 It's basically a list, but slices return a string instead of a list, thus
334 allowing things like (assuming 'In' is an instance):
338 allowing things like (assuming 'In' is an instance):
335
339
336 exec In[4:7]
340 exec In[4:7]
337
341
338 or
342 or
339
343
340 exec In[5:9] + In[14] + In[21:25]"""
344 exec In[5:9] + In[14] + In[21:25]"""
341
345
342 def __getslice__(self,i,j):
346 def __getslice__(self,i,j):
343 return ''.join(list.__getslice__(self,i,j))
347 return ''.join(list.__getslice__(self,i,j))
344
348
345 class SyntaxTB(ultraTB.ListTB):
349 class SyntaxTB(ultraTB.ListTB):
346 """Extension which holds some state: the last exception value"""
350 """Extension which holds some state: the last exception value"""
347
351
348 def __init__(self,color_scheme = 'NoColor'):
352 def __init__(self,color_scheme = 'NoColor'):
349 ultraTB.ListTB.__init__(self,color_scheme)
353 ultraTB.ListTB.__init__(self,color_scheme)
350 self.last_syntax_error = None
354 self.last_syntax_error = None
351
355
352 def __call__(self, etype, value, elist):
356 def __call__(self, etype, value, elist):
353 self.last_syntax_error = value
357 self.last_syntax_error = value
354 ultraTB.ListTB.__call__(self,etype,value,elist)
358 ultraTB.ListTB.__call__(self,etype,value,elist)
355
359
356 def clear_err_state(self):
360 def clear_err_state(self):
357 """Return the current error state and clear it"""
361 """Return the current error state and clear it"""
358 e = self.last_syntax_error
362 e = self.last_syntax_error
359 self.last_syntax_error = None
363 self.last_syntax_error = None
360 return e
364 return e
361
365
362 #****************************************************************************
366 #****************************************************************************
363 # Main IPython class
367 # Main IPython class
364
368
365 # FIXME: the Magic class is a mixin for now, and will unfortunately remain so
369 # FIXME: the Magic class is a mixin for now, and will unfortunately remain so
366 # until a full rewrite is made. I've cleaned all cross-class uses of
370 # until a full rewrite is made. I've cleaned all cross-class uses of
367 # attributes and methods, but too much user code out there relies on the
371 # attributes and methods, but too much user code out there relies on the
368 # equlity %foo == __IP.magic_foo, so I can't actually remove the mixin usage.
372 # equlity %foo == __IP.magic_foo, so I can't actually remove the mixin usage.
369 #
373 #
370 # But at least now, all the pieces have been separated and we could, in
374 # But at least now, all the pieces have been separated and we could, in
371 # principle, stop using the mixin. This will ease the transition to the
375 # principle, stop using the mixin. This will ease the transition to the
372 # chainsaw branch.
376 # chainsaw branch.
373
377
374 # For reference, the following is the list of 'self.foo' uses in the Magic
378 # For reference, the following is the list of 'self.foo' uses in the Magic
375 # class as of 2005-12-28. These are names we CAN'T use in the main ipython
379 # class as of 2005-12-28. These are names we CAN'T use in the main ipython
376 # class, to prevent clashes.
380 # class, to prevent clashes.
377
381
378 # ['self.__class__', 'self.__dict__', 'self._inspect', 'self._ofind',
382 # ['self.__class__', 'self.__dict__', 'self._inspect', 'self._ofind',
379 # 'self.arg_err', 'self.extract_input', 'self.format_', 'self.lsmagic',
383 # 'self.arg_err', 'self.extract_input', 'self.format_', 'self.lsmagic',
380 # 'self.magic_', 'self.options_table', 'self.parse', 'self.shell',
384 # 'self.magic_', 'self.options_table', 'self.parse', 'self.shell',
381 # 'self.value']
385 # 'self.value']
382
386
383 class InteractiveShell(object,Magic):
387 class InteractiveShell(object,Magic):
384 """An enhanced console for Python."""
388 """An enhanced console for Python."""
385
389
386 # class attribute to indicate whether the class supports threads or not.
390 # class attribute to indicate whether the class supports threads or not.
387 # Subclasses with thread support should override this as needed.
391 # Subclasses with thread support should override this as needed.
388 isthreaded = False
392 isthreaded = False
389
393
390 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
394 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
391 user_ns=None,user_global_ns=None,banner2='',
395 user_ns=None,user_global_ns=None,banner2='',
392 custom_exceptions=((),None),embedded=False):
396 custom_exceptions=((),None),embedded=False):
393
397
394 # log system
398 # log system
395 self.logger = Logger(self,logfname='ipython_log.py',logmode='rotate')
399 self.logger = Logger(self,logfname='ipython_log.py',logmode='rotate')
396
400
397 # Job manager (for jobs run as background threads)
401 # Job manager (for jobs run as background threads)
398 self.jobs = BackgroundJobManager()
402 self.jobs = BackgroundJobManager()
399
403
400 # Store the actual shell's name
404 # Store the actual shell's name
401 self.name = name
405 self.name = name
402 self.more = False
406 self.more = False
403
407
404 # We need to know whether the instance is meant for embedding, since
408 # We need to know whether the instance is meant for embedding, since
405 # global/local namespaces need to be handled differently in that case
409 # global/local namespaces need to be handled differently in that case
406 self.embedded = embedded
410 self.embedded = embedded
407 if embedded:
411 if embedded:
408 # Control variable so users can, from within the embedded instance,
412 # Control variable so users can, from within the embedded instance,
409 # permanently deactivate it.
413 # permanently deactivate it.
410 self.embedded_active = True
414 self.embedded_active = True
411
415
412 # command compiler
416 # command compiler
413 self.compile = codeop.CommandCompiler()
417 self.compile = codeop.CommandCompiler()
414
418
415 # User input buffer
419 # User input buffer
416 self.buffer = []
420 self.buffer = []
417
421
418 # Default name given in compilation of code
422 # Default name given in compilation of code
419 self.filename = '<ipython console>'
423 self.filename = '<ipython console>'
420
424
421 # Install our own quitter instead of the builtins. For python2.3-2.4,
425 # Install our own quitter instead of the builtins. For python2.3-2.4,
422 # this brings in behavior like 2.5, and for 2.5 it's identical.
426 # this brings in behavior like 2.5, and for 2.5 it's identical.
423 __builtin__.exit = Quitter(self,'exit')
427 __builtin__.exit = Quitter(self,'exit')
424 __builtin__.quit = Quitter(self,'quit')
428 __builtin__.quit = Quitter(self,'quit')
425
429
426 # Make an empty namespace, which extension writers can rely on both
430 # Make an empty namespace, which extension writers can rely on both
427 # existing and NEVER being used by ipython itself. This gives them a
431 # existing and NEVER being used by ipython itself. This gives them a
428 # convenient location for storing additional information and state
432 # convenient location for storing additional information and state
429 # their extensions may require, without fear of collisions with other
433 # their extensions may require, without fear of collisions with other
430 # ipython names that may develop later.
434 # ipython names that may develop later.
431 self.meta = Struct()
435 self.meta = Struct()
432
436
433 # Create the namespace where the user will operate. user_ns is
437 # Create the namespace where the user will operate. user_ns is
434 # normally the only one used, and it is passed to the exec calls as
438 # normally the only one used, and it is passed to the exec calls as
435 # the locals argument. But we do carry a user_global_ns namespace
439 # the locals argument. But we do carry a user_global_ns namespace
436 # given as the exec 'globals' argument, This is useful in embedding
440 # given as the exec 'globals' argument, This is useful in embedding
437 # situations where the ipython shell opens in a context where the
441 # situations where the ipython shell opens in a context where the
438 # distinction between locals and globals is meaningful. For
442 # distinction between locals and globals is meaningful. For
439 # non-embedded contexts, it is just the same object as the user_ns dict.
443 # non-embedded contexts, it is just the same object as the user_ns dict.
440
444
441 # FIXME. For some strange reason, __builtins__ is showing up at user
445 # FIXME. For some strange reason, __builtins__ is showing up at user
442 # level as a dict instead of a module. This is a manual fix, but I
446 # level as a dict instead of a module. This is a manual fix, but I
443 # should really track down where the problem is coming from. Alex
447 # should really track down where the problem is coming from. Alex
444 # Schmolck reported this problem first.
448 # Schmolck reported this problem first.
445
449
446 # A useful post by Alex Martelli on this topic:
450 # A useful post by Alex Martelli on this topic:
447 # Re: inconsistent value from __builtins__
451 # Re: inconsistent value from __builtins__
448 # Von: Alex Martelli <aleaxit@yahoo.com>
452 # Von: Alex Martelli <aleaxit@yahoo.com>
449 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
453 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
450 # Gruppen: comp.lang.python
454 # Gruppen: comp.lang.python
451
455
452 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
456 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
453 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
457 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
454 # > <type 'dict'>
458 # > <type 'dict'>
455 # > >>> print type(__builtins__)
459 # > >>> print type(__builtins__)
456 # > <type 'module'>
460 # > <type 'module'>
457 # > Is this difference in return value intentional?
461 # > Is this difference in return value intentional?
458
462
459 # Well, it's documented that '__builtins__' can be either a dictionary
463 # Well, it's documented that '__builtins__' can be either a dictionary
460 # or a module, and it's been that way for a long time. Whether it's
464 # or a module, and it's been that way for a long time. Whether it's
461 # intentional (or sensible), I don't know. In any case, the idea is
465 # intentional (or sensible), I don't know. In any case, the idea is
462 # that if you need to access the built-in namespace directly, you
466 # that if you need to access the built-in namespace directly, you
463 # should start with "import __builtin__" (note, no 's') which will
467 # should start with "import __builtin__" (note, no 's') which will
464 # definitely give you a module. Yeah, it's somewhat confusing:-(.
468 # definitely give you a module. Yeah, it's somewhat confusing:-(.
465
469
466 # These routines return properly built dicts as needed by the rest of
470 # These routines return properly built dicts as needed by the rest of
467 # the code, and can also be used by extension writers to generate
471 # the code, and can also be used by extension writers to generate
468 # properly initialized namespaces.
472 # properly initialized namespaces.
469 user_ns, user_global_ns = IPython.ipapi.make_user_namespaces(user_ns,
473 user_ns, user_global_ns = IPython.ipapi.make_user_namespaces(user_ns,
470 user_global_ns)
474 user_global_ns)
471
475
472 # Assign namespaces
476 # Assign namespaces
473 # This is the namespace where all normal user variables live
477 # This is the namespace where all normal user variables live
474 self.user_ns = user_ns
478 self.user_ns = user_ns
475 self.user_global_ns = user_global_ns
479 self.user_global_ns = user_global_ns
476
480
477 # An auxiliary namespace that checks what parts of the user_ns were
481 # An auxiliary namespace that checks what parts of the user_ns were
478 # loaded at startup, so we can list later only variables defined in
482 # loaded at startup, so we can list later only variables defined in
479 # actual interactive use. Since it is always a subset of user_ns, it
483 # actual interactive use. Since it is always a subset of user_ns, it
480 # doesn't need to be seaparately tracked in the ns_table
484 # doesn't need to be seaparately tracked in the ns_table
481 self.user_config_ns = {}
485 self.user_config_ns = {}
482
486
483 # A namespace to keep track of internal data structures to prevent
487 # A namespace to keep track of internal data structures to prevent
484 # them from cluttering user-visible stuff. Will be updated later
488 # them from cluttering user-visible stuff. Will be updated later
485 self.internal_ns = {}
489 self.internal_ns = {}
486
490
487 # Namespace of system aliases. Each entry in the alias
491 # Namespace of system aliases. Each entry in the alias
488 # table must be a 2-tuple of the form (N,name), where N is the number
492 # table must be a 2-tuple of the form (N,name), where N is the number
489 # of positional arguments of the alias.
493 # of positional arguments of the alias.
490 self.alias_table = {}
494 self.alias_table = {}
491
495
492 # Now that FakeModule produces a real module, we've run into a nasty
496 # Now that FakeModule produces a real module, we've run into a nasty
493 # problem: after script execution (via %run), the module where the user
497 # problem: after script execution (via %run), the module where the user
494 # code ran is deleted. Now that this object is a true module (needed
498 # code ran is deleted. Now that this object is a true module (needed
495 # so docetst and other tools work correctly), the Python module
499 # so docetst and other tools work correctly), the Python module
496 # teardown mechanism runs over it, and sets to None every variable
500 # teardown mechanism runs over it, and sets to None every variable
497 # present in that module. Top-level references to objects from the
501 # present in that module. Top-level references to objects from the
498 # script survive, because the user_ns is updated with them. However,
502 # script survive, because the user_ns is updated with them. However,
499 # calling functions defined in the script that use other things from
503 # calling functions defined in the script that use other things from
500 # the script will fail, because the function's closure had references
504 # the script will fail, because the function's closure had references
501 # to the original objects, which are now all None. So we must protect
505 # to the original objects, which are now all None. So we must protect
502 # these modules from deletion by keeping a cache.
506 # these modules from deletion by keeping a cache.
503 #
507 #
504 # To avoid keeping stale modules around (we only need the one from the
508 # To avoid keeping stale modules around (we only need the one from the
505 # last run), we use a dict keyed with the full path to the script, so
509 # last run), we use a dict keyed with the full path to the script, so
506 # only the last version of the module is held in the cache. Note,
510 # only the last version of the module is held in the cache. Note,
507 # however, that we must cache the module *namespace contents* (their
511 # however, that we must cache the module *namespace contents* (their
508 # __dict__). Because if we try to cache the actual modules, old ones
512 # __dict__). Because if we try to cache the actual modules, old ones
509 # (uncached) could be destroyed while still holding references (such as
513 # (uncached) could be destroyed while still holding references (such as
510 # those held by GUI objects that tend to be long-lived)>
514 # those held by GUI objects that tend to be long-lived)>
511 #
515 #
512 # The %reset command will flush this cache. See the cache_main_mod()
516 # The %reset command will flush this cache. See the cache_main_mod()
513 # and clear_main_mod_cache() methods for details on use.
517 # and clear_main_mod_cache() methods for details on use.
514
518
515 # This is the cache used for 'main' namespaces
519 # This is the cache used for 'main' namespaces
516 self._main_ns_cache = {}
520 self._main_ns_cache = {}
517 # And this is the single instance of FakeModule whose __dict__ we keep
521 # And this is the single instance of FakeModule whose __dict__ we keep
518 # copying and clearing for reuse on each %run
522 # copying and clearing for reuse on each %run
519 self._user_main_module = FakeModule()
523 self._user_main_module = FakeModule()
520
524
521 # A table holding all the namespaces IPython deals with, so that
525 # A table holding all the namespaces IPython deals with, so that
522 # introspection facilities can search easily.
526 # introspection facilities can search easily.
523 self.ns_table = {'user':user_ns,
527 self.ns_table = {'user':user_ns,
524 'user_global':user_global_ns,
528 'user_global':user_global_ns,
525 'alias':self.alias_table,
529 'alias':self.alias_table,
526 'internal':self.internal_ns,
530 'internal':self.internal_ns,
527 'builtin':__builtin__.__dict__
531 'builtin':__builtin__.__dict__
528 }
532 }
529
533
530 # Similarly, track all namespaces where references can be held and that
534 # Similarly, track all namespaces where references can be held and that
531 # we can safely clear (so it can NOT include builtin). This one can be
535 # we can safely clear (so it can NOT include builtin). This one can be
532 # a simple list.
536 # a simple list.
533 self.ns_refs_table = [ user_ns, user_global_ns, self.user_config_ns,
537 self.ns_refs_table = [ user_ns, user_global_ns, self.user_config_ns,
534 self.alias_table, self.internal_ns,
538 self.alias_table, self.internal_ns,
535 self._main_ns_cache ]
539 self._main_ns_cache ]
536
540
537 # We need to insert into sys.modules something that looks like a
541 # We need to insert into sys.modules something that looks like a
538 # module but which accesses the IPython namespace, for shelve and
542 # module but which accesses the IPython namespace, for shelve and
539 # pickle to work interactively. Normally they rely on getting
543 # pickle to work interactively. Normally they rely on getting
540 # everything out of __main__, but for embedding purposes each IPython
544 # everything out of __main__, but for embedding purposes each IPython
541 # instance has its own private namespace, so we can't go shoving
545 # instance has its own private namespace, so we can't go shoving
542 # everything into __main__.
546 # everything into __main__.
543
547
544 # note, however, that we should only do this for non-embedded
548 # note, however, that we should only do this for non-embedded
545 # ipythons, which really mimic the __main__.__dict__ with their own
549 # ipythons, which really mimic the __main__.__dict__ with their own
546 # namespace. Embedded instances, on the other hand, should not do
550 # namespace. Embedded instances, on the other hand, should not do
547 # this because they need to manage the user local/global namespaces
551 # this because they need to manage the user local/global namespaces
548 # only, but they live within a 'normal' __main__ (meaning, they
552 # only, but they live within a 'normal' __main__ (meaning, they
549 # shouldn't overtake the execution environment of the script they're
553 # shouldn't overtake the execution environment of the script they're
550 # embedded in).
554 # embedded in).
551
555
552 if not embedded:
556 if not embedded:
553 try:
557 try:
554 main_name = self.user_ns['__name__']
558 main_name = self.user_ns['__name__']
555 except KeyError:
559 except KeyError:
556 raise KeyError,'user_ns dictionary MUST have a "__name__" key'
560 raise KeyError,'user_ns dictionary MUST have a "__name__" key'
557 else:
561 else:
558 #print "pickle hack in place" # dbg
562 #print "pickle hack in place" # dbg
559 #print 'main_name:',main_name # dbg
563 #print 'main_name:',main_name # dbg
560 sys.modules[main_name] = FakeModule(self.user_ns)
564 sys.modules[main_name] = FakeModule(self.user_ns)
561
565
562 # List of input with multi-line handling.
566 # List of input with multi-line handling.
563 self.input_hist = InputList()
567 self.input_hist = InputList()
564 # This one will hold the 'raw' input history, without any
568 # This one will hold the 'raw' input history, without any
565 # pre-processing. This will allow users to retrieve the input just as
569 # pre-processing. This will allow users to retrieve the input just as
566 # it was exactly typed in by the user, with %hist -r.
570 # it was exactly typed in by the user, with %hist -r.
567 self.input_hist_raw = InputList()
571 self.input_hist_raw = InputList()
568
572
569 # list of visited directories
573 # list of visited directories
570 try:
574 try:
571 self.dir_hist = [os.getcwd()]
575 self.dir_hist = [os.getcwd()]
572 except OSError:
576 except OSError:
573 self.dir_hist = []
577 self.dir_hist = []
574
578
575 # dict of output history
579 # dict of output history
576 self.output_hist = {}
580 self.output_hist = {}
577
581
578 # Get system encoding at startup time. Certain terminals (like Emacs
582 # Get system encoding at startup time. Certain terminals (like Emacs
579 # under Win32 have it set to None, and we need to have a known valid
583 # under Win32 have it set to None, and we need to have a known valid
580 # encoding to use in the raw_input() method
584 # encoding to use in the raw_input() method
581 try:
585 try:
582 self.stdin_encoding = sys.stdin.encoding or 'ascii'
586 self.stdin_encoding = sys.stdin.encoding or 'ascii'
583 except AttributeError:
587 except AttributeError:
584 self.stdin_encoding = 'ascii'
588 self.stdin_encoding = 'ascii'
585
589
586 # dict of things NOT to alias (keywords, builtins and some magics)
590 # dict of things NOT to alias (keywords, builtins and some magics)
587 no_alias = {}
591 no_alias = {}
588 no_alias_magics = ['cd','popd','pushd','dhist','alias','unalias']
592 no_alias_magics = ['cd','popd','pushd','dhist','alias','unalias']
589 for key in keyword.kwlist + no_alias_magics:
593 for key in keyword.kwlist + no_alias_magics:
590 no_alias[key] = 1
594 no_alias[key] = 1
591 no_alias.update(__builtin__.__dict__)
595 no_alias.update(__builtin__.__dict__)
592 self.no_alias = no_alias
596 self.no_alias = no_alias
593
597
594 # Object variable to store code object waiting execution. This is
598 # Object variable to store code object waiting execution. This is
595 # used mainly by the multithreaded shells, but it can come in handy in
599 # used mainly by the multithreaded shells, but it can come in handy in
596 # other situations. No need to use a Queue here, since it's a single
600 # other situations. No need to use a Queue here, since it's a single
597 # item which gets cleared once run.
601 # item which gets cleared once run.
598 self.code_to_run = None
602 self.code_to_run = None
599
603
600 # escapes for automatic behavior on the command line
604 # escapes for automatic behavior on the command line
601 self.ESC_SHELL = '!'
605 self.ESC_SHELL = '!'
602 self.ESC_SH_CAP = '!!'
606 self.ESC_SH_CAP = '!!'
603 self.ESC_HELP = '?'
607 self.ESC_HELP = '?'
604 self.ESC_MAGIC = '%'
608 self.ESC_MAGIC = '%'
605 self.ESC_QUOTE = ','
609 self.ESC_QUOTE = ','
606 self.ESC_QUOTE2 = ';'
610 self.ESC_QUOTE2 = ';'
607 self.ESC_PAREN = '/'
611 self.ESC_PAREN = '/'
608
612
609 # And their associated handlers
613 # And their associated handlers
610 self.esc_handlers = {self.ESC_PAREN : self.handle_auto,
614 self.esc_handlers = {self.ESC_PAREN : self.handle_auto,
611 self.ESC_QUOTE : self.handle_auto,
615 self.ESC_QUOTE : self.handle_auto,
612 self.ESC_QUOTE2 : self.handle_auto,
616 self.ESC_QUOTE2 : self.handle_auto,
613 self.ESC_MAGIC : self.handle_magic,
617 self.ESC_MAGIC : self.handle_magic,
614 self.ESC_HELP : self.handle_help,
618 self.ESC_HELP : self.handle_help,
615 self.ESC_SHELL : self.handle_shell_escape,
619 self.ESC_SHELL : self.handle_shell_escape,
616 self.ESC_SH_CAP : self.handle_shell_escape,
620 self.ESC_SH_CAP : self.handle_shell_escape,
617 }
621 }
618
622
619 # class initializations
623 # class initializations
620 Magic.__init__(self,self)
624 Magic.__init__(self,self)
621
625
622 # Python source parser/formatter for syntax highlighting
626 # Python source parser/formatter for syntax highlighting
623 pyformat = PyColorize.Parser().format
627 pyformat = PyColorize.Parser().format
624 self.pycolorize = lambda src: pyformat(src,'str',self.rc['colors'])
628 self.pycolorize = lambda src: pyformat(src,'str',self.rc['colors'])
625
629
626 # hooks holds pointers used for user-side customizations
630 # hooks holds pointers used for user-side customizations
627 self.hooks = Struct()
631 self.hooks = Struct()
628
632
629 self.strdispatchers = {}
633 self.strdispatchers = {}
630
634
631 # Set all default hooks, defined in the IPython.hooks module.
635 # Set all default hooks, defined in the IPython.hooks module.
632 hooks = IPython.hooks
636 hooks = IPython.hooks
633 for hook_name in hooks.__all__:
637 for hook_name in hooks.__all__:
634 # default hooks have priority 100, i.e. low; user hooks should have
638 # default hooks have priority 100, i.e. low; user hooks should have
635 # 0-100 priority
639 # 0-100 priority
636 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
640 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
637 #print "bound hook",hook_name
641 #print "bound hook",hook_name
638
642
639 # Flag to mark unconditional exit
643 # Flag to mark unconditional exit
640 self.exit_now = False
644 self.exit_now = False
641
645
642 self.usage_min = """\
646 self.usage_min = """\
643 An enhanced console for Python.
647 An enhanced console for Python.
644 Some of its features are:
648 Some of its features are:
645 - Readline support if the readline library is present.
649 - Readline support if the readline library is present.
646 - Tab completion in the local namespace.
650 - Tab completion in the local namespace.
647 - Logging of input, see command-line options.
651 - Logging of input, see command-line options.
648 - System shell escape via ! , eg !ls.
652 - System shell escape via ! , eg !ls.
649 - Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)
653 - Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)
650 - Keeps track of locally defined variables via %who, %whos.
654 - Keeps track of locally defined variables via %who, %whos.
651 - Show object information with a ? eg ?x or x? (use ?? for more info).
655 - Show object information with a ? eg ?x or x? (use ?? for more info).
652 """
656 """
653 if usage: self.usage = usage
657 if usage: self.usage = usage
654 else: self.usage = self.usage_min
658 else: self.usage = self.usage_min
655
659
656 # Storage
660 # Storage
657 self.rc = rc # This will hold all configuration information
661 self.rc = rc # This will hold all configuration information
658 self.pager = 'less'
662 self.pager = 'less'
659 # temporary files used for various purposes. Deleted at exit.
663 # temporary files used for various purposes. Deleted at exit.
660 self.tempfiles = []
664 self.tempfiles = []
661
665
662 # Keep track of readline usage (later set by init_readline)
666 # Keep track of readline usage (later set by init_readline)
663 self.has_readline = False
667 self.has_readline = False
664
668
665 # template for logfile headers. It gets resolved at runtime by the
669 # template for logfile headers. It gets resolved at runtime by the
666 # logstart method.
670 # logstart method.
667 self.loghead_tpl = \
671 self.loghead_tpl = \
668 """#log# Automatic Logger file. *** THIS MUST BE THE FIRST LINE ***
672 """#log# Automatic Logger file. *** THIS MUST BE THE FIRST LINE ***
669 #log# DO NOT CHANGE THIS LINE OR THE TWO BELOW
673 #log# DO NOT CHANGE THIS LINE OR THE TWO BELOW
670 #log# opts = %s
674 #log# opts = %s
671 #log# args = %s
675 #log# args = %s
672 #log# It is safe to make manual edits below here.
676 #log# It is safe to make manual edits below here.
673 #log#-----------------------------------------------------------------------
677 #log#-----------------------------------------------------------------------
674 """
678 """
675 # for pushd/popd management
679 # for pushd/popd management
676 try:
680 try:
677 self.home_dir = get_home_dir()
681 self.home_dir = get_home_dir()
678 except HomeDirError,msg:
682 except HomeDirError,msg:
679 fatal(msg)
683 fatal(msg)
680
684
681 self.dir_stack = []
685 self.dir_stack = []
682
686
683 # Functions to call the underlying shell.
687 # Functions to call the underlying shell.
684
688
685 # The first is similar to os.system, but it doesn't return a value,
689 # The first is similar to os.system, but it doesn't return a value,
686 # and it allows interpolation of variables in the user's namespace.
690 # and it allows interpolation of variables in the user's namespace.
687 self.system = lambda cmd: \
691 self.system = lambda cmd: \
688 self.hooks.shell_hook(self.var_expand(cmd,depth=2))
692 self.hooks.shell_hook(self.var_expand(cmd,depth=2))
689
693
690 # These are for getoutput and getoutputerror:
694 # These are for getoutput and getoutputerror:
691 self.getoutput = lambda cmd: \
695 self.getoutput = lambda cmd: \
692 getoutput(self.var_expand(cmd,depth=2),
696 getoutput(self.var_expand(cmd,depth=2),
693 header=self.rc.system_header,
697 header=self.rc.system_header,
694 verbose=self.rc.system_verbose)
698 verbose=self.rc.system_verbose)
695
699
696 self.getoutputerror = lambda cmd: \
700 self.getoutputerror = lambda cmd: \
697 getoutputerror(self.var_expand(cmd,depth=2),
701 getoutputerror(self.var_expand(cmd,depth=2),
698 header=self.rc.system_header,
702 header=self.rc.system_header,
699 verbose=self.rc.system_verbose)
703 verbose=self.rc.system_verbose)
700
704
701
705
702 # keep track of where we started running (mainly for crash post-mortem)
706 # keep track of where we started running (mainly for crash post-mortem)
703 self.starting_dir = os.getcwd()
707 self.starting_dir = os.getcwd()
704
708
705 # Various switches which can be set
709 # Various switches which can be set
706 self.CACHELENGTH = 5000 # this is cheap, it's just text
710 self.CACHELENGTH = 5000 # this is cheap, it's just text
707 self.BANNER = "Python %(version)s on %(platform)s\n" % sys.__dict__
711 self.BANNER = "Python %(version)s on %(platform)s\n" % sys.__dict__
708 self.banner2 = banner2
712 self.banner2 = banner2
709
713
710 # TraceBack handlers:
714 # TraceBack handlers:
711
715
712 # Syntax error handler.
716 # Syntax error handler.
713 self.SyntaxTB = SyntaxTB(color_scheme='NoColor')
717 self.SyntaxTB = SyntaxTB(color_scheme='NoColor')
714
718
715 # The interactive one is initialized with an offset, meaning we always
719 # The interactive one is initialized with an offset, meaning we always
716 # want to remove the topmost item in the traceback, which is our own
720 # want to remove the topmost item in the traceback, which is our own
717 # internal code. Valid modes: ['Plain','Context','Verbose']
721 # internal code. Valid modes: ['Plain','Context','Verbose']
718 self.InteractiveTB = ultraTB.AutoFormattedTB(mode = 'Plain',
722 self.InteractiveTB = ultraTB.AutoFormattedTB(mode = 'Plain',
719 color_scheme='NoColor',
723 color_scheme='NoColor',
720 tb_offset = 1)
724 tb_offset = 1)
721
725
722 # IPython itself shouldn't crash. This will produce a detailed
726 # IPython itself shouldn't crash. This will produce a detailed
723 # post-mortem if it does. But we only install the crash handler for
727 # post-mortem if it does. But we only install the crash handler for
724 # non-threaded shells, the threaded ones use a normal verbose reporter
728 # non-threaded shells, the threaded ones use a normal verbose reporter
725 # and lose the crash handler. This is because exceptions in the main
729 # and lose the crash handler. This is because exceptions in the main
726 # thread (such as in GUI code) propagate directly to sys.excepthook,
730 # thread (such as in GUI code) propagate directly to sys.excepthook,
727 # and there's no point in printing crash dumps for every user exception.
731 # and there's no point in printing crash dumps for every user exception.
728 if self.isthreaded:
732 if self.isthreaded:
729 ipCrashHandler = ultraTB.FormattedTB()
733 ipCrashHandler = ultraTB.FormattedTB()
730 else:
734 else:
731 from IPython import CrashHandler
735 from IPython import CrashHandler
732 ipCrashHandler = CrashHandler.IPythonCrashHandler(self)
736 ipCrashHandler = CrashHandler.IPythonCrashHandler(self)
733 self.set_crash_handler(ipCrashHandler)
737 self.set_crash_handler(ipCrashHandler)
734
738
735 # and add any custom exception handlers the user may have specified
739 # and add any custom exception handlers the user may have specified
736 self.set_custom_exc(*custom_exceptions)
740 self.set_custom_exc(*custom_exceptions)
737
741
738 # indentation management
742 # indentation management
739 self.autoindent = False
743 self.autoindent = False
740 self.indent_current_nsp = 0
744 self.indent_current_nsp = 0
741
745
742 # Make some aliases automatically
746 # Make some aliases automatically
743 # Prepare list of shell aliases to auto-define
747 # Prepare list of shell aliases to auto-define
744 if os.name == 'posix':
748 if os.name == 'posix':
745 auto_alias = ('mkdir mkdir', 'rmdir rmdir',
749 auto_alias = ('mkdir mkdir', 'rmdir rmdir',
746 'mv mv -i','rm rm -i','cp cp -i',
750 'mv mv -i','rm rm -i','cp cp -i',
747 'cat cat','less less','clear clear',
751 'cat cat','less less','clear clear',
748 # a better ls
752 # a better ls
749 'ls ls -F',
753 'ls ls -F',
750 # long ls
754 # long ls
751 'll ls -lF')
755 'll ls -lF')
752 # Extra ls aliases with color, which need special treatment on BSD
756 # Extra ls aliases with color, which need special treatment on BSD
753 # variants
757 # variants
754 ls_extra = ( # color ls
758 ls_extra = ( # color ls
755 'lc ls -F -o --color',
759 'lc ls -F -o --color',
756 # ls normal files only
760 # ls normal files only
757 'lf ls -F -o --color %l | grep ^-',
761 'lf ls -F -o --color %l | grep ^-',
758 # ls symbolic links
762 # ls symbolic links
759 'lk ls -F -o --color %l | grep ^l',
763 'lk ls -F -o --color %l | grep ^l',
760 # directories or links to directories,
764 # directories or links to directories,
761 'ldir ls -F -o --color %l | grep /$',
765 'ldir ls -F -o --color %l | grep /$',
762 # things which are executable
766 # things which are executable
763 'lx ls -F -o --color %l | grep ^-..x',
767 'lx ls -F -o --color %l | grep ^-..x',
764 )
768 )
765 # The BSDs don't ship GNU ls, so they don't understand the
769 # The BSDs don't ship GNU ls, so they don't understand the
766 # --color switch out of the box
770 # --color switch out of the box
767 if 'bsd' in sys.platform:
771 if 'bsd' in sys.platform:
768 ls_extra = ( # ls normal files only
772 ls_extra = ( # ls normal files only
769 'lf ls -lF | grep ^-',
773 'lf ls -lF | grep ^-',
770 # ls symbolic links
774 # ls symbolic links
771 'lk ls -lF | grep ^l',
775 'lk ls -lF | grep ^l',
772 # directories or links to directories,
776 # directories or links to directories,
773 'ldir ls -lF | grep /$',
777 'ldir ls -lF | grep /$',
774 # things which are executable
778 # things which are executable
775 'lx ls -lF | grep ^-..x',
779 'lx ls -lF | grep ^-..x',
776 )
780 )
777 auto_alias = auto_alias + ls_extra
781 auto_alias = auto_alias + ls_extra
778 elif os.name in ['nt','dos']:
782 elif os.name in ['nt','dos']:
779 auto_alias = ('ls dir /on',
783 auto_alias = ('ls dir /on',
780 'ddir dir /ad /on', 'ldir dir /ad /on',
784 'ddir dir /ad /on', 'ldir dir /ad /on',
781 'mkdir mkdir','rmdir rmdir','echo echo',
785 'mkdir mkdir','rmdir rmdir','echo echo',
782 'ren ren','cls cls','copy copy')
786 'ren ren','cls cls','copy copy')
783 else:
787 else:
784 auto_alias = ()
788 auto_alias = ()
785 self.auto_alias = [s.split(None,1) for s in auto_alias]
789 self.auto_alias = [s.split(None,1) for s in auto_alias]
786
790
787 # Produce a public API instance
791 # Produce a public API instance
788 self.api = IPython.ipapi.IPApi(self)
792 self.api = IPython.ipapi.IPApi(self)
789
793
790 # Initialize all user-visible namespaces
794 # Initialize all user-visible namespaces
791 self.init_namespaces()
795 self.init_namespaces()
792
796
793 # Call the actual (public) initializer
797 # Call the actual (public) initializer
794 self.init_auto_alias()
798 self.init_auto_alias()
795
799
796 # track which builtins we add, so we can clean up later
800 # track which builtins we add, so we can clean up later
797 self.builtins_added = {}
801 self.builtins_added = {}
798 # This method will add the necessary builtins for operation, but
802 # This method will add the necessary builtins for operation, but
799 # tracking what it did via the builtins_added dict.
803 # tracking what it did via the builtins_added dict.
800
804
801 #TODO: remove this, redundant
805 #TODO: remove this, redundant
802 self.add_builtins()
806 self.add_builtins()
803 # end __init__
807 # end __init__
804
808
805 def var_expand(self,cmd,depth=0):
809 def var_expand(self,cmd,depth=0):
806 """Expand python variables in a string.
810 """Expand python variables in a string.
807
811
808 The depth argument indicates how many frames above the caller should
812 The depth argument indicates how many frames above the caller should
809 be walked to look for the local namespace where to expand variables.
813 be walked to look for the local namespace where to expand variables.
810
814
811 The global namespace for expansion is always the user's interactive
815 The global namespace for expansion is always the user's interactive
812 namespace.
816 namespace.
813 """
817 """
814
818
815 return str(ItplNS(cmd,
819 return str(ItplNS(cmd,
816 self.user_ns, # globals
820 self.user_ns, # globals
817 # Skip our own frame in searching for locals:
821 # Skip our own frame in searching for locals:
818 sys._getframe(depth+1).f_locals # locals
822 sys._getframe(depth+1).f_locals # locals
819 ))
823 ))
820
824
821 def pre_config_initialization(self):
825 def pre_config_initialization(self):
822 """Pre-configuration init method
826 """Pre-configuration init method
823
827
824 This is called before the configuration files are processed to
828 This is called before the configuration files are processed to
825 prepare the services the config files might need.
829 prepare the services the config files might need.
826
830
827 self.rc already has reasonable default values at this point.
831 self.rc already has reasonable default values at this point.
828 """
832 """
829 rc = self.rc
833 rc = self.rc
830 try:
834 try:
831 self.db = pickleshare.PickleShareDB(rc.ipythondir + "/db")
835 self.db = pickleshare.PickleShareDB(rc.ipythondir + "/db")
832 except exceptions.UnicodeDecodeError:
836 except exceptions.UnicodeDecodeError:
833 print "Your ipythondir can't be decoded to unicode!"
837 print "Your ipythondir can't be decoded to unicode!"
834 print "Please set HOME environment variable to something that"
838 print "Please set HOME environment variable to something that"
835 print r"only has ASCII characters, e.g. c:\home"
839 print r"only has ASCII characters, e.g. c:\home"
836 print "Now it is",rc.ipythondir
840 print "Now it is",rc.ipythondir
837 sys.exit()
841 sys.exit()
838 self.shadowhist = IPython.history.ShadowHist(self.db)
842 self.shadowhist = IPython.history.ShadowHist(self.db)
839
843
840 def post_config_initialization(self):
844 def post_config_initialization(self):
841 """Post configuration init method
845 """Post configuration init method
842
846
843 This is called after the configuration files have been processed to
847 This is called after the configuration files have been processed to
844 'finalize' the initialization."""
848 'finalize' the initialization."""
845
849
846 rc = self.rc
850 rc = self.rc
847
851
848 # Object inspector
852 # Object inspector
849 self.inspector = OInspect.Inspector(OInspect.InspectColors,
853 self.inspector = OInspect.Inspector(OInspect.InspectColors,
850 PyColorize.ANSICodeColors,
854 PyColorize.ANSICodeColors,
851 'NoColor',
855 'NoColor',
852 rc.object_info_string_level)
856 rc.object_info_string_level)
853
857
854 self.rl_next_input = None
858 self.rl_next_input = None
855 self.rl_do_indent = False
859 self.rl_do_indent = False
856 # Load readline proper
860 # Load readline proper
857 if rc.readline:
861 if rc.readline:
858 self.init_readline()
862 self.init_readline()
859
863
860 # local shortcut, this is used a LOT
864 # local shortcut, this is used a LOT
861 self.log = self.logger.log
865 self.log = self.logger.log
862
866
863 # Initialize cache, set in/out prompts and printing system
867 # Initialize cache, set in/out prompts and printing system
864 self.outputcache = CachedOutput(self,
868 self.outputcache = CachedOutput(self,
865 rc.cache_size,
869 rc.cache_size,
866 rc.pprint,
870 rc.pprint,
867 input_sep = rc.separate_in,
871 input_sep = rc.separate_in,
868 output_sep = rc.separate_out,
872 output_sep = rc.separate_out,
869 output_sep2 = rc.separate_out2,
873 output_sep2 = rc.separate_out2,
870 ps1 = rc.prompt_in1,
874 ps1 = rc.prompt_in1,
871 ps2 = rc.prompt_in2,
875 ps2 = rc.prompt_in2,
872 ps_out = rc.prompt_out,
876 ps_out = rc.prompt_out,
873 pad_left = rc.prompts_pad_left)
877 pad_left = rc.prompts_pad_left)
874
878
875 # user may have over-ridden the default print hook:
879 # user may have over-ridden the default print hook:
876 try:
880 try:
877 self.outputcache.__class__.display = self.hooks.display
881 self.outputcache.__class__.display = self.hooks.display
878 except AttributeError:
882 except AttributeError:
879 pass
883 pass
880
884
881 # I don't like assigning globally to sys, because it means when
885 # I don't like assigning globally to sys, because it means when
882 # embedding instances, each embedded instance overrides the previous
886 # embedding instances, each embedded instance overrides the previous
883 # choice. But sys.displayhook seems to be called internally by exec,
887 # choice. But sys.displayhook seems to be called internally by exec,
884 # so I don't see a way around it. We first save the original and then
888 # so I don't see a way around it. We first save the original and then
885 # overwrite it.
889 # overwrite it.
886 self.sys_displayhook = sys.displayhook
890 self.sys_displayhook = sys.displayhook
887 sys.displayhook = self.outputcache
891 sys.displayhook = self.outputcache
888
892
889 # Do a proper resetting of doctest, including the necessary displayhook
893 # Do a proper resetting of doctest, including the necessary displayhook
890 # monkeypatching
894 # monkeypatching
891 try:
895 try:
892 doctest_reload()
896 doctest_reload()
893 except ImportError:
897 except ImportError:
894 warn("doctest module does not exist.")
898 warn("doctest module does not exist.")
895
899
896 # Set user colors (don't do it in the constructor above so that it
900 # Set user colors (don't do it in the constructor above so that it
897 # doesn't crash if colors option is invalid)
901 # doesn't crash if colors option is invalid)
898 self.magic_colors(rc.colors)
902 self.magic_colors(rc.colors)
899
903
900 # Set calling of pdb on exceptions
904 # Set calling of pdb on exceptions
901 self.call_pdb = rc.pdb
905 self.call_pdb = rc.pdb
902
906
903 # Load user aliases
907 # Load user aliases
904 for alias in rc.alias:
908 for alias in rc.alias:
905 self.magic_alias(alias)
909 self.magic_alias(alias)
906
910
907 self.hooks.late_startup_hook()
911 self.hooks.late_startup_hook()
908
912
909 for cmd in self.rc.autoexec:
913 for cmd in self.rc.autoexec:
910 #print "autoexec>",cmd #dbg
914 #print "autoexec>",cmd #dbg
911 self.api.runlines(cmd)
915 self.api.runlines(cmd)
912
916
913 batchrun = False
917 batchrun = False
914 for batchfile in [path(arg) for arg in self.rc.args
918 for batchfile in [path(arg) for arg in self.rc.args
915 if arg.lower().endswith('.ipy')]:
919 if arg.lower().endswith('.ipy')]:
916 if not batchfile.isfile():
920 if not batchfile.isfile():
917 print "No such batch file:", batchfile
921 print "No such batch file:", batchfile
918 continue
922 continue
919 self.api.runlines(batchfile.text())
923 self.api.runlines(batchfile.text())
920 batchrun = True
924 batchrun = True
921 # without -i option, exit after running the batch file
925 # without -i option, exit after running the batch file
922 if batchrun and not self.rc.interact:
926 if batchrun and not self.rc.interact:
923 self.ask_exit()
927 self.ask_exit()
924
928
925 def init_namespaces(self):
929 def init_namespaces(self):
926 """Initialize all user-visible namespaces to their minimum defaults.
930 """Initialize all user-visible namespaces to their minimum defaults.
927
931
928 Certain history lists are also initialized here, as they effectively
932 Certain history lists are also initialized here, as they effectively
929 act as user namespaces.
933 act as user namespaces.
930
934
931 Note
935 Note
932 ----
936 ----
933 All data structures here are only filled in, they are NOT reset by this
937 All data structures here are only filled in, they are NOT reset by this
934 method. If they were not empty before, data will simply be added to
938 method. If they were not empty before, data will simply be added to
935 therm.
939 therm.
936 """
940 """
937 # The user namespace MUST have a pointer to the shell itself.
941 # The user namespace MUST have a pointer to the shell itself.
938 self.user_ns[self.name] = self
942 self.user_ns[self.name] = self
939
943
940 # Store the public api instance
944 # Store the public api instance
941 self.user_ns['_ip'] = self.api
945 self.user_ns['_ip'] = self.api
942
946
943 # make global variables for user access to the histories
947 # make global variables for user access to the histories
944 self.user_ns['_ih'] = self.input_hist
948 self.user_ns['_ih'] = self.input_hist
945 self.user_ns['_oh'] = self.output_hist
949 self.user_ns['_oh'] = self.output_hist
946 self.user_ns['_dh'] = self.dir_hist
950 self.user_ns['_dh'] = self.dir_hist
947
951
948 # user aliases to input and output histories
952 # user aliases to input and output histories
949 self.user_ns['In'] = self.input_hist
953 self.user_ns['In'] = self.input_hist
950 self.user_ns['Out'] = self.output_hist
954 self.user_ns['Out'] = self.output_hist
951
955
952 self.user_ns['_sh'] = IPython.shadowns
956 self.user_ns['_sh'] = IPython.shadowns
953
957
954 # Fill the history zero entry, user counter starts at 1
958 # Fill the history zero entry, user counter starts at 1
955 self.input_hist.append('\n')
959 self.input_hist.append('\n')
956 self.input_hist_raw.append('\n')
960 self.input_hist_raw.append('\n')
957
961
958 def add_builtins(self):
962 def add_builtins(self):
959 """Store ipython references into the builtin namespace.
963 """Store ipython references into the builtin namespace.
960
964
961 Some parts of ipython operate via builtins injected here, which hold a
965 Some parts of ipython operate via builtins injected here, which hold a
962 reference to IPython itself."""
966 reference to IPython itself."""
963
967
964 # TODO: deprecate all of these, they are unsafe
968 # TODO: deprecate all of these, they are unsafe
965 builtins_new = dict(__IPYTHON__ = self,
969 builtins_new = dict(__IPYTHON__ = self,
966 ip_set_hook = self.set_hook,
970 ip_set_hook = self.set_hook,
967 jobs = self.jobs,
971 jobs = self.jobs,
968 ipmagic = wrap_deprecated(self.ipmagic,'_ip.magic()'),
972 ipmagic = wrap_deprecated(self.ipmagic,'_ip.magic()'),
969 ipalias = wrap_deprecated(self.ipalias),
973 ipalias = wrap_deprecated(self.ipalias),
970 ipsystem = wrap_deprecated(self.ipsystem,'_ip.system()'),
974 ipsystem = wrap_deprecated(self.ipsystem,'_ip.system()'),
971 #_ip = self.api
975 #_ip = self.api
972 )
976 )
973 for biname,bival in builtins_new.items():
977 for biname,bival in builtins_new.items():
974 try:
978 try:
975 # store the orignal value so we can restore it
979 # store the orignal value so we can restore it
976 self.builtins_added[biname] = __builtin__.__dict__[biname]
980 self.builtins_added[biname] = __builtin__.__dict__[biname]
977 except KeyError:
981 except KeyError:
978 # or mark that it wasn't defined, and we'll just delete it at
982 # or mark that it wasn't defined, and we'll just delete it at
979 # cleanup
983 # cleanup
980 self.builtins_added[biname] = Undefined
984 self.builtins_added[biname] = Undefined
981 __builtin__.__dict__[biname] = bival
985 __builtin__.__dict__[biname] = bival
982
986
983 # Keep in the builtins a flag for when IPython is active. We set it
987 # Keep in the builtins a flag for when IPython is active. We set it
984 # with setdefault so that multiple nested IPythons don't clobber one
988 # with setdefault so that multiple nested IPythons don't clobber one
985 # another. Each will increase its value by one upon being activated,
989 # another. Each will increase its value by one upon being activated,
986 # which also gives us a way to determine the nesting level.
990 # which also gives us a way to determine the nesting level.
987 __builtin__.__dict__.setdefault('__IPYTHON__active',0)
991 __builtin__.__dict__.setdefault('__IPYTHON__active',0)
988
992
989 def clean_builtins(self):
993 def clean_builtins(self):
990 """Remove any builtins which might have been added by add_builtins, or
994 """Remove any builtins which might have been added by add_builtins, or
991 restore overwritten ones to their previous values."""
995 restore overwritten ones to their previous values."""
992 for biname,bival in self.builtins_added.items():
996 for biname,bival in self.builtins_added.items():
993 if bival is Undefined:
997 if bival is Undefined:
994 del __builtin__.__dict__[biname]
998 del __builtin__.__dict__[biname]
995 else:
999 else:
996 __builtin__.__dict__[biname] = bival
1000 __builtin__.__dict__[biname] = bival
997 self.builtins_added.clear()
1001 self.builtins_added.clear()
998
1002
999 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
1003 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
1000 """set_hook(name,hook) -> sets an internal IPython hook.
1004 """set_hook(name,hook) -> sets an internal IPython hook.
1001
1005
1002 IPython exposes some of its internal API as user-modifiable hooks. By
1006 IPython exposes some of its internal API as user-modifiable hooks. By
1003 adding your function to one of these hooks, you can modify IPython's
1007 adding your function to one of these hooks, you can modify IPython's
1004 behavior to call at runtime your own routines."""
1008 behavior to call at runtime your own routines."""
1005
1009
1006 # At some point in the future, this should validate the hook before it
1010 # At some point in the future, this should validate the hook before it
1007 # accepts it. Probably at least check that the hook takes the number
1011 # accepts it. Probably at least check that the hook takes the number
1008 # of args it's supposed to.
1012 # of args it's supposed to.
1009
1013
1010 f = new.instancemethod(hook,self,self.__class__)
1014 f = new.instancemethod(hook,self,self.__class__)
1011
1015
1012 # check if the hook is for strdispatcher first
1016 # check if the hook is for strdispatcher first
1013 if str_key is not None:
1017 if str_key is not None:
1014 sdp = self.strdispatchers.get(name, StrDispatch())
1018 sdp = self.strdispatchers.get(name, StrDispatch())
1015 sdp.add_s(str_key, f, priority )
1019 sdp.add_s(str_key, f, priority )
1016 self.strdispatchers[name] = sdp
1020 self.strdispatchers[name] = sdp
1017 return
1021 return
1018 if re_key is not None:
1022 if re_key is not None:
1019 sdp = self.strdispatchers.get(name, StrDispatch())
1023 sdp = self.strdispatchers.get(name, StrDispatch())
1020 sdp.add_re(re.compile(re_key), f, priority )
1024 sdp.add_re(re.compile(re_key), f, priority )
1021 self.strdispatchers[name] = sdp
1025 self.strdispatchers[name] = sdp
1022 return
1026 return
1023
1027
1024 dp = getattr(self.hooks, name, None)
1028 dp = getattr(self.hooks, name, None)
1025 if name not in IPython.hooks.__all__:
1029 if name not in IPython.hooks.__all__:
1026 print "Warning! Hook '%s' is not one of %s" % (name, IPython.hooks.__all__ )
1030 print "Warning! Hook '%s' is not one of %s" % (name, IPython.hooks.__all__ )
1027 if not dp:
1031 if not dp:
1028 dp = IPython.hooks.CommandChainDispatcher()
1032 dp = IPython.hooks.CommandChainDispatcher()
1029
1033
1030 try:
1034 try:
1031 dp.add(f,priority)
1035 dp.add(f,priority)
1032 except AttributeError:
1036 except AttributeError:
1033 # it was not commandchain, plain old func - replace
1037 # it was not commandchain, plain old func - replace
1034 dp = f
1038 dp = f
1035
1039
1036 setattr(self.hooks,name, dp)
1040 setattr(self.hooks,name, dp)
1037
1041
1038
1042
1039 #setattr(self.hooks,name,new.instancemethod(hook,self,self.__class__))
1043 #setattr(self.hooks,name,new.instancemethod(hook,self,self.__class__))
1040
1044
1041 def set_crash_handler(self,crashHandler):
1045 def set_crash_handler(self,crashHandler):
1042 """Set the IPython crash handler.
1046 """Set the IPython crash handler.
1043
1047
1044 This must be a callable with a signature suitable for use as
1048 This must be a callable with a signature suitable for use as
1045 sys.excepthook."""
1049 sys.excepthook."""
1046
1050
1047 # Install the given crash handler as the Python exception hook
1051 # Install the given crash handler as the Python exception hook
1048 sys.excepthook = crashHandler
1052 sys.excepthook = crashHandler
1049
1053
1050 # The instance will store a pointer to this, so that runtime code
1054 # The instance will store a pointer to this, so that runtime code
1051 # (such as magics) can access it. This is because during the
1055 # (such as magics) can access it. This is because during the
1052 # read-eval loop, it gets temporarily overwritten (to deal with GUI
1056 # read-eval loop, it gets temporarily overwritten (to deal with GUI
1053 # frameworks).
1057 # frameworks).
1054 self.sys_excepthook = sys.excepthook
1058 self.sys_excepthook = sys.excepthook
1055
1059
1056
1060
1057 def set_custom_exc(self,exc_tuple,handler):
1061 def set_custom_exc(self,exc_tuple,handler):
1058 """set_custom_exc(exc_tuple,handler)
1062 """set_custom_exc(exc_tuple,handler)
1059
1063
1060 Set a custom exception handler, which will be called if any of the
1064 Set a custom exception handler, which will be called if any of the
1061 exceptions in exc_tuple occur in the mainloop (specifically, in the
1065 exceptions in exc_tuple occur in the mainloop (specifically, in the
1062 runcode() method.
1066 runcode() method.
1063
1067
1064 Inputs:
1068 Inputs:
1065
1069
1066 - exc_tuple: a *tuple* of valid exceptions to call the defined
1070 - exc_tuple: a *tuple* of valid exceptions to call the defined
1067 handler for. It is very important that you use a tuple, and NOT A
1071 handler for. It is very important that you use a tuple, and NOT A
1068 LIST here, because of the way Python's except statement works. If
1072 LIST here, because of the way Python's except statement works. If
1069 you only want to trap a single exception, use a singleton tuple:
1073 you only want to trap a single exception, use a singleton tuple:
1070
1074
1071 exc_tuple == (MyCustomException,)
1075 exc_tuple == (MyCustomException,)
1072
1076
1073 - handler: this must be defined as a function with the following
1077 - handler: this must be defined as a function with the following
1074 basic interface: def my_handler(self,etype,value,tb).
1078 basic interface: def my_handler(self,etype,value,tb).
1075
1079
1076 This will be made into an instance method (via new.instancemethod)
1080 This will be made into an instance method (via new.instancemethod)
1077 of IPython itself, and it will be called if any of the exceptions
1081 of IPython itself, and it will be called if any of the exceptions
1078 listed in the exc_tuple are caught. If the handler is None, an
1082 listed in the exc_tuple are caught. If the handler is None, an
1079 internal basic one is used, which just prints basic info.
1083 internal basic one is used, which just prints basic info.
1080
1084
1081 WARNING: by putting in your own exception handler into IPython's main
1085 WARNING: by putting in your own exception handler into IPython's main
1082 execution loop, you run a very good chance of nasty crashes. This
1086 execution loop, you run a very good chance of nasty crashes. This
1083 facility should only be used if you really know what you are doing."""
1087 facility should only be used if you really know what you are doing."""
1084
1088
1085 assert type(exc_tuple)==type(()) , \
1089 assert type(exc_tuple)==type(()) , \
1086 "The custom exceptions must be given AS A TUPLE."
1090 "The custom exceptions must be given AS A TUPLE."
1087
1091
1088 def dummy_handler(self,etype,value,tb):
1092 def dummy_handler(self,etype,value,tb):
1089 print '*** Simple custom exception handler ***'
1093 print '*** Simple custom exception handler ***'
1090 print 'Exception type :',etype
1094 print 'Exception type :',etype
1091 print 'Exception value:',value
1095 print 'Exception value:',value
1092 print 'Traceback :',tb
1096 print 'Traceback :',tb
1093 print 'Source code :','\n'.join(self.buffer)
1097 print 'Source code :','\n'.join(self.buffer)
1094
1098
1095 if handler is None: handler = dummy_handler
1099 if handler is None: handler = dummy_handler
1096
1100
1097 self.CustomTB = new.instancemethod(handler,self,self.__class__)
1101 self.CustomTB = new.instancemethod(handler,self,self.__class__)
1098 self.custom_exceptions = exc_tuple
1102 self.custom_exceptions = exc_tuple
1099
1103
1100 def set_custom_completer(self,completer,pos=0):
1104 def set_custom_completer(self,completer,pos=0):
1101 """set_custom_completer(completer,pos=0)
1105 """set_custom_completer(completer,pos=0)
1102
1106
1103 Adds a new custom completer function.
1107 Adds a new custom completer function.
1104
1108
1105 The position argument (defaults to 0) is the index in the completers
1109 The position argument (defaults to 0) is the index in the completers
1106 list where you want the completer to be inserted."""
1110 list where you want the completer to be inserted."""
1107
1111
1108 newcomp = new.instancemethod(completer,self.Completer,
1112 newcomp = new.instancemethod(completer,self.Completer,
1109 self.Completer.__class__)
1113 self.Completer.__class__)
1110 self.Completer.matchers.insert(pos,newcomp)
1114 self.Completer.matchers.insert(pos,newcomp)
1111
1115
1112 def set_completer(self):
1116 def set_completer(self):
1113 """reset readline's completer to be our own."""
1117 """reset readline's completer to be our own."""
1114 self.readline.set_completer(self.Completer.complete)
1118 self.readline.set_completer(self.Completer.complete)
1115
1119
1116 def _get_call_pdb(self):
1120 def _get_call_pdb(self):
1117 return self._call_pdb
1121 return self._call_pdb
1118
1122
1119 def _set_call_pdb(self,val):
1123 def _set_call_pdb(self,val):
1120
1124
1121 if val not in (0,1,False,True):
1125 if val not in (0,1,False,True):
1122 raise ValueError,'new call_pdb value must be boolean'
1126 raise ValueError,'new call_pdb value must be boolean'
1123
1127
1124 # store value in instance
1128 # store value in instance
1125 self._call_pdb = val
1129 self._call_pdb = val
1126
1130
1127 # notify the actual exception handlers
1131 # notify the actual exception handlers
1128 self.InteractiveTB.call_pdb = val
1132 self.InteractiveTB.call_pdb = val
1129 if self.isthreaded:
1133 if self.isthreaded:
1130 try:
1134 try:
1131 self.sys_excepthook.call_pdb = val
1135 self.sys_excepthook.call_pdb = val
1132 except:
1136 except:
1133 warn('Failed to activate pdb for threaded exception handler')
1137 warn('Failed to activate pdb for threaded exception handler')
1134
1138
1135 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
1139 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
1136 'Control auto-activation of pdb at exceptions')
1140 'Control auto-activation of pdb at exceptions')
1137
1141
1138 # These special functions get installed in the builtin namespace, to
1142 # These special functions get installed in the builtin namespace, to
1139 # provide programmatic (pure python) access to magics, aliases and system
1143 # provide programmatic (pure python) access to magics, aliases and system
1140 # calls. This is important for logging, user scripting, and more.
1144 # calls. This is important for logging, user scripting, and more.
1141
1145
1142 # We are basically exposing, via normal python functions, the three
1146 # We are basically exposing, via normal python functions, the three
1143 # mechanisms in which ipython offers special call modes (magics for
1147 # mechanisms in which ipython offers special call modes (magics for
1144 # internal control, aliases for direct system access via pre-selected
1148 # internal control, aliases for direct system access via pre-selected
1145 # names, and !cmd for calling arbitrary system commands).
1149 # names, and !cmd for calling arbitrary system commands).
1146
1150
1147 def ipmagic(self,arg_s):
1151 def ipmagic(self,arg_s):
1148 """Call a magic function by name.
1152 """Call a magic function by name.
1149
1153
1150 Input: a string containing the name of the magic function to call and any
1154 Input: a string containing the name of the magic function to call and any
1151 additional arguments to be passed to the magic.
1155 additional arguments to be passed to the magic.
1152
1156
1153 ipmagic('name -opt foo bar') is equivalent to typing at the ipython
1157 ipmagic('name -opt foo bar') is equivalent to typing at the ipython
1154 prompt:
1158 prompt:
1155
1159
1156 In[1]: %name -opt foo bar
1160 In[1]: %name -opt foo bar
1157
1161
1158 To call a magic without arguments, simply use ipmagic('name').
1162 To call a magic without arguments, simply use ipmagic('name').
1159
1163
1160 This provides a proper Python function to call IPython's magics in any
1164 This provides a proper Python function to call IPython's magics in any
1161 valid Python code you can type at the interpreter, including loops and
1165 valid Python code you can type at the interpreter, including loops and
1162 compound statements. It is added by IPython to the Python builtin
1166 compound statements. It is added by IPython to the Python builtin
1163 namespace upon initialization."""
1167 namespace upon initialization."""
1164
1168
1165 args = arg_s.split(' ',1)
1169 args = arg_s.split(' ',1)
1166 magic_name = args[0]
1170 magic_name = args[0]
1167 magic_name = magic_name.lstrip(self.ESC_MAGIC)
1171 magic_name = magic_name.lstrip(self.ESC_MAGIC)
1168
1172
1169 try:
1173 try:
1170 magic_args = args[1]
1174 magic_args = args[1]
1171 except IndexError:
1175 except IndexError:
1172 magic_args = ''
1176 magic_args = ''
1173 fn = getattr(self,'magic_'+magic_name,None)
1177 fn = getattr(self,'magic_'+magic_name,None)
1174 if fn is None:
1178 if fn is None:
1175 error("Magic function `%s` not found." % magic_name)
1179 error("Magic function `%s` not found." % magic_name)
1176 else:
1180 else:
1177 magic_args = self.var_expand(magic_args,1)
1181 magic_args = self.var_expand(magic_args,1)
1178 return fn(magic_args)
1182 return fn(magic_args)
1179
1183
1180 def ipalias(self,arg_s):
1184 def ipalias(self,arg_s):
1181 """Call an alias by name.
1185 """Call an alias by name.
1182
1186
1183 Input: a string containing the name of the alias to call and any
1187 Input: a string containing the name of the alias to call and any
1184 additional arguments to be passed to the magic.
1188 additional arguments to be passed to the magic.
1185
1189
1186 ipalias('name -opt foo bar') is equivalent to typing at the ipython
1190 ipalias('name -opt foo bar') is equivalent to typing at the ipython
1187 prompt:
1191 prompt:
1188
1192
1189 In[1]: name -opt foo bar
1193 In[1]: name -opt foo bar
1190
1194
1191 To call an alias without arguments, simply use ipalias('name').
1195 To call an alias without arguments, simply use ipalias('name').
1192
1196
1193 This provides a proper Python function to call IPython's aliases in any
1197 This provides a proper Python function to call IPython's aliases in any
1194 valid Python code you can type at the interpreter, including loops and
1198 valid Python code you can type at the interpreter, including loops and
1195 compound statements. It is added by IPython to the Python builtin
1199 compound statements. It is added by IPython to the Python builtin
1196 namespace upon initialization."""
1200 namespace upon initialization."""
1197
1201
1198 args = arg_s.split(' ',1)
1202 args = arg_s.split(' ',1)
1199 alias_name = args[0]
1203 alias_name = args[0]
1200 try:
1204 try:
1201 alias_args = args[1]
1205 alias_args = args[1]
1202 except IndexError:
1206 except IndexError:
1203 alias_args = ''
1207 alias_args = ''
1204 if alias_name in self.alias_table:
1208 if alias_name in self.alias_table:
1205 self.call_alias(alias_name,alias_args)
1209 self.call_alias(alias_name,alias_args)
1206 else:
1210 else:
1207 error("Alias `%s` not found." % alias_name)
1211 error("Alias `%s` not found." % alias_name)
1208
1212
1209 def ipsystem(self,arg_s):
1213 def ipsystem(self,arg_s):
1210 """Make a system call, using IPython."""
1214 """Make a system call, using IPython."""
1211
1215
1212 self.system(arg_s)
1216 self.system(arg_s)
1213
1217
1214 def complete(self,text):
1218 def complete(self,text):
1215 """Return a sorted list of all possible completions on text.
1219 """Return a sorted list of all possible completions on text.
1216
1220
1217 Inputs:
1221 Inputs:
1218
1222
1219 - text: a string of text to be completed on.
1223 - text: a string of text to be completed on.
1220
1224
1221 This is a wrapper around the completion mechanism, similar to what
1225 This is a wrapper around the completion mechanism, similar to what
1222 readline does at the command line when the TAB key is hit. By
1226 readline does at the command line when the TAB key is hit. By
1223 exposing it as a method, it can be used by other non-readline
1227 exposing it as a method, it can be used by other non-readline
1224 environments (such as GUIs) for text completion.
1228 environments (such as GUIs) for text completion.
1225
1229
1226 Simple usage example:
1230 Simple usage example:
1227
1231
1228 In [7]: x = 'hello'
1232 In [7]: x = 'hello'
1229
1233
1230 In [8]: x
1234 In [8]: x
1231 Out[8]: 'hello'
1235 Out[8]: 'hello'
1232
1236
1233 In [9]: print x
1237 In [9]: print x
1234 hello
1238 hello
1235
1239
1236 In [10]: _ip.IP.complete('x.l')
1240 In [10]: _ip.IP.complete('x.l')
1237 Out[10]: ['x.ljust', 'x.lower', 'x.lstrip']
1241 Out[10]: ['x.ljust', 'x.lower', 'x.lstrip']
1238 """
1242 """
1239
1243
1240 complete = self.Completer.complete
1244 complete = self.Completer.complete
1241 state = 0
1245 state = 0
1242 # use a dict so we get unique keys, since ipyhton's multiple
1246 # use a dict so we get unique keys, since ipyhton's multiple
1243 # completers can return duplicates. When we make 2.4 a requirement,
1247 # completers can return duplicates. When we make 2.4 a requirement,
1244 # start using sets instead, which are faster.
1248 # start using sets instead, which are faster.
1245 comps = {}
1249 comps = {}
1246 while True:
1250 while True:
1247 newcomp = complete(text,state,line_buffer=text)
1251 newcomp = complete(text,state,line_buffer=text)
1248 if newcomp is None:
1252 if newcomp is None:
1249 break
1253 break
1250 comps[newcomp] = 1
1254 comps[newcomp] = 1
1251 state += 1
1255 state += 1
1252 outcomps = comps.keys()
1256 outcomps = comps.keys()
1253 outcomps.sort()
1257 outcomps.sort()
1254 #print "T:",text,"OC:",outcomps # dbg
1258 #print "T:",text,"OC:",outcomps # dbg
1255 #print "vars:",self.user_ns.keys()
1259 #print "vars:",self.user_ns.keys()
1256 return outcomps
1260 return outcomps
1257
1261
1258 def set_completer_frame(self, frame=None):
1262 def set_completer_frame(self, frame=None):
1259 if frame:
1263 if frame:
1260 self.Completer.namespace = frame.f_locals
1264 self.Completer.namespace = frame.f_locals
1261 self.Completer.global_namespace = frame.f_globals
1265 self.Completer.global_namespace = frame.f_globals
1262 else:
1266 else:
1263 self.Completer.namespace = self.user_ns
1267 self.Completer.namespace = self.user_ns
1264 self.Completer.global_namespace = self.user_global_ns
1268 self.Completer.global_namespace = self.user_global_ns
1265
1269
1266 def init_auto_alias(self):
1270 def init_auto_alias(self):
1267 """Define some aliases automatically.
1271 """Define some aliases automatically.
1268
1272
1269 These are ALL parameter-less aliases"""
1273 These are ALL parameter-less aliases"""
1270
1274
1271 for alias,cmd in self.auto_alias:
1275 for alias,cmd in self.auto_alias:
1272 self.getapi().defalias(alias,cmd)
1276 self.getapi().defalias(alias,cmd)
1273
1277
1274
1278
1275 def alias_table_validate(self,verbose=0):
1279 def alias_table_validate(self,verbose=0):
1276 """Update information about the alias table.
1280 """Update information about the alias table.
1277
1281
1278 In particular, make sure no Python keywords/builtins are in it."""
1282 In particular, make sure no Python keywords/builtins are in it."""
1279
1283
1280 no_alias = self.no_alias
1284 no_alias = self.no_alias
1281 for k in self.alias_table.keys():
1285 for k in self.alias_table.keys():
1282 if k in no_alias:
1286 if k in no_alias:
1283 del self.alias_table[k]
1287 del self.alias_table[k]
1284 if verbose:
1288 if verbose:
1285 print ("Deleting alias <%s>, it's a Python "
1289 print ("Deleting alias <%s>, it's a Python "
1286 "keyword or builtin." % k)
1290 "keyword or builtin." % k)
1287
1291
1288 def set_autoindent(self,value=None):
1292 def set_autoindent(self,value=None):
1289 """Set the autoindent flag, checking for readline support.
1293 """Set the autoindent flag, checking for readline support.
1290
1294
1291 If called with no arguments, it acts as a toggle."""
1295 If called with no arguments, it acts as a toggle."""
1292
1296
1293 if not self.has_readline:
1297 if not self.has_readline:
1294 if os.name == 'posix':
1298 if os.name == 'posix':
1295 warn("The auto-indent feature requires the readline library")
1299 warn("The auto-indent feature requires the readline library")
1296 self.autoindent = 0
1300 self.autoindent = 0
1297 return
1301 return
1298 if value is None:
1302 if value is None:
1299 self.autoindent = not self.autoindent
1303 self.autoindent = not self.autoindent
1300 else:
1304 else:
1301 self.autoindent = value
1305 self.autoindent = value
1302
1306
1303 def rc_set_toggle(self,rc_field,value=None):
1307 def rc_set_toggle(self,rc_field,value=None):
1304 """Set or toggle a field in IPython's rc config. structure.
1308 """Set or toggle a field in IPython's rc config. structure.
1305
1309
1306 If called with no arguments, it acts as a toggle.
1310 If called with no arguments, it acts as a toggle.
1307
1311
1308 If called with a non-existent field, the resulting AttributeError
1312 If called with a non-existent field, the resulting AttributeError
1309 exception will propagate out."""
1313 exception will propagate out."""
1310
1314
1311 rc_val = getattr(self.rc,rc_field)
1315 rc_val = getattr(self.rc,rc_field)
1312 if value is None:
1316 if value is None:
1313 value = not rc_val
1317 value = not rc_val
1314 setattr(self.rc,rc_field,value)
1318 setattr(self.rc,rc_field,value)
1315
1319
1316 def user_setup(self,ipythondir,rc_suffix,mode='install'):
1320 def user_setup(self,ipythondir,rc_suffix,mode='install'):
1317 """Install the user configuration directory.
1321 """Install the user configuration directory.
1318
1322
1319 Note
1323 Note
1320 ----
1324 ----
1321 DEPRECATED: use the top-level user_setup() function instead.
1325 DEPRECATED: use the top-level user_setup() function instead.
1322 """
1326 """
1323 return user_setup(ipythondir,rc_suffix,mode)
1327 return user_setup(ipythondir,rc_suffix,mode)
1324
1328
1325 def atexit_operations(self):
1329 def atexit_operations(self):
1326 """This will be executed at the time of exit.
1330 """This will be executed at the time of exit.
1327
1331
1328 Saving of persistent data should be performed here. """
1332 Saving of persistent data should be performed here. """
1329
1333
1330 #print '*** IPython exit cleanup ***' # dbg
1334 #print '*** IPython exit cleanup ***' # dbg
1331 # input history
1335 # input history
1332 self.savehist()
1336 self.savehist()
1333
1337
1334 # Cleanup all tempfiles left around
1338 # Cleanup all tempfiles left around
1335 for tfile in self.tempfiles:
1339 for tfile in self.tempfiles:
1336 try:
1340 try:
1337 os.unlink(tfile)
1341 os.unlink(tfile)
1338 except OSError:
1342 except OSError:
1339 pass
1343 pass
1340
1344
1341 # Clear all user namespaces to release all references cleanly.
1345 # Clear all user namespaces to release all references cleanly.
1342 self.reset()
1346 self.reset()
1343
1347
1344 # Run user hooks
1348 # Run user hooks
1345 self.hooks.shutdown_hook()
1349 self.hooks.shutdown_hook()
1346
1350
1347 def reset(self):
1351 def reset(self):
1348 """Clear all internal namespaces.
1352 """Clear all internal namespaces.
1349
1353
1350 Note that this is much more aggressive than %reset, since it clears
1354 Note that this is much more aggressive than %reset, since it clears
1351 fully all namespaces, as well as all input/output lists.
1355 fully all namespaces, as well as all input/output lists.
1352 """
1356 """
1353 for ns in self.ns_refs_table:
1357 for ns in self.ns_refs_table:
1354 ns.clear()
1358 ns.clear()
1355
1359
1356 # Clear input and output histories
1360 # Clear input and output histories
1357 self.input_hist[:] = []
1361 self.input_hist[:] = []
1358 self.input_hist_raw[:] = []
1362 self.input_hist_raw[:] = []
1359 self.output_hist.clear()
1363 self.output_hist.clear()
1360 # Restore the user namespaces to minimal usability
1364 # Restore the user namespaces to minimal usability
1361 self.init_namespaces()
1365 self.init_namespaces()
1362
1366
1363 def savehist(self):
1367 def savehist(self):
1364 """Save input history to a file (via readline library)."""
1368 """Save input history to a file (via readline library)."""
1365
1369
1366 if not self.has_readline:
1370 if not self.has_readline:
1367 return
1371 return
1368
1372
1369 try:
1373 try:
1370 self.readline.write_history_file(self.histfile)
1374 self.readline.write_history_file(self.histfile)
1371 except:
1375 except:
1372 print 'Unable to save IPython command history to file: ' + \
1376 print 'Unable to save IPython command history to file: ' + \
1373 `self.histfile`
1377 `self.histfile`
1374
1378
1375 def reloadhist(self):
1379 def reloadhist(self):
1376 """Reload the input history from disk file."""
1380 """Reload the input history from disk file."""
1377
1381
1378 if self.has_readline:
1382 if self.has_readline:
1379 try:
1383 try:
1380 self.readline.clear_history()
1384 self.readline.clear_history()
1381 self.readline.read_history_file(self.shell.histfile)
1385 self.readline.read_history_file(self.shell.histfile)
1382 except AttributeError:
1386 except AttributeError:
1383 pass
1387 pass
1384
1388
1385
1389
1386 def history_saving_wrapper(self, func):
1390 def history_saving_wrapper(self, func):
1387 """ Wrap func for readline history saving
1391 """ Wrap func for readline history saving
1388
1392
1389 Convert func into callable that saves & restores
1393 Convert func into callable that saves & restores
1390 history around the call """
1394 history around the call """
1391
1395
1392 if not self.has_readline:
1396 if not self.has_readline:
1393 return func
1397 return func
1394
1398
1395 def wrapper():
1399 def wrapper():
1396 self.savehist()
1400 self.savehist()
1397 try:
1401 try:
1398 func()
1402 func()
1399 finally:
1403 finally:
1400 readline.read_history_file(self.histfile)
1404 readline.read_history_file(self.histfile)
1401 return wrapper
1405 return wrapper
1402
1406
1403 def pre_readline(self):
1407 def pre_readline(self):
1404 """readline hook to be used at the start of each line.
1408 """readline hook to be used at the start of each line.
1405
1409
1406 Currently it handles auto-indent only."""
1410 Currently it handles auto-indent only."""
1407
1411
1408 #debugx('self.indent_current_nsp','pre_readline:')
1412 #debugx('self.indent_current_nsp','pre_readline:')
1409
1413
1410 if self.rl_do_indent:
1414 if self.rl_do_indent:
1411 self.readline.insert_text(self.indent_current_str())
1415 self.readline.insert_text(self.indent_current_str())
1412 if self.rl_next_input is not None:
1416 if self.rl_next_input is not None:
1413 self.readline.insert_text(self.rl_next_input)
1417 self.readline.insert_text(self.rl_next_input)
1414 self.rl_next_input = None
1418 self.rl_next_input = None
1415
1419
1416 def init_readline(self):
1420 def init_readline(self):
1417 """Command history completion/saving/reloading."""
1421 """Command history completion/saving/reloading."""
1418
1422
1419
1423
1420 import IPython.rlineimpl as readline
1424 import IPython.rlineimpl as readline
1421
1425
1422 if not readline.have_readline:
1426 if not readline.have_readline:
1423 self.has_readline = 0
1427 self.has_readline = 0
1424 self.readline = None
1428 self.readline = None
1425 # no point in bugging windows users with this every time:
1429 # no point in bugging windows users with this every time:
1426 warn('Readline services not available on this platform.')
1430 warn('Readline services not available on this platform.')
1427 else:
1431 else:
1428 sys.modules['readline'] = readline
1432 sys.modules['readline'] = readline
1429 import atexit
1433 import atexit
1430 from IPython.completer import IPCompleter
1434 from IPython.completer import IPCompleter
1431 self.Completer = IPCompleter(self,
1435 self.Completer = IPCompleter(self,
1432 self.user_ns,
1436 self.user_ns,
1433 self.user_global_ns,
1437 self.user_global_ns,
1434 self.rc.readline_omit__names,
1438 self.rc.readline_omit__names,
1435 self.alias_table)
1439 self.alias_table)
1436 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1440 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1437 self.strdispatchers['complete_command'] = sdisp
1441 self.strdispatchers['complete_command'] = sdisp
1438 self.Completer.custom_completers = sdisp
1442 self.Completer.custom_completers = sdisp
1439 # Platform-specific configuration
1443 # Platform-specific configuration
1440 if os.name == 'nt':
1444 if os.name == 'nt':
1441 self.readline_startup_hook = readline.set_pre_input_hook
1445 self.readline_startup_hook = readline.set_pre_input_hook
1442 else:
1446 else:
1443 self.readline_startup_hook = readline.set_startup_hook
1447 self.readline_startup_hook = readline.set_startup_hook
1444
1448
1445 # Load user's initrc file (readline config)
1449 # Load user's initrc file (readline config)
1446 # Or if libedit is used, load editrc.
1450 # Or if libedit is used, load editrc.
1447 inputrc_name = os.environ.get('INPUTRC')
1451 inputrc_name = os.environ.get('INPUTRC')
1448 if inputrc_name is None:
1452 if inputrc_name is None:
1449 home_dir = get_home_dir()
1453 home_dir = get_home_dir()
1450 if home_dir is not None:
1454 if home_dir is not None:
1451 inputrc_name = '.inputrc'
1455 inputrc_name = '.inputrc'
1452 if readline.uses_libedit:
1456 if readline.uses_libedit:
1453 inputrc_name = '.editrc'
1457 inputrc_name = '.editrc'
1454 inputrc_name = os.path.join(home_dir, inputrc_name)
1458 inputrc_name = os.path.join(home_dir, inputrc_name)
1455 if os.path.isfile(inputrc_name):
1459 if os.path.isfile(inputrc_name):
1456 try:
1460 try:
1457 readline.read_init_file(inputrc_name)
1461 readline.read_init_file(inputrc_name)
1458 except:
1462 except:
1459 warn('Problems reading readline initialization file <%s>'
1463 warn('Problems reading readline initialization file <%s>'
1460 % inputrc_name)
1464 % inputrc_name)
1461
1465
1462 self.has_readline = 1
1466 self.has_readline = 1
1463 self.readline = readline
1467 self.readline = readline
1464 # save this in sys so embedded copies can restore it properly
1468 # save this in sys so embedded copies can restore it properly
1465 sys.ipcompleter = self.Completer.complete
1469 sys.ipcompleter = self.Completer.complete
1466 self.set_completer()
1470 self.set_completer()
1467
1471
1468 # Configure readline according to user's prefs
1472 # Configure readline according to user's prefs
1469 # This is only done if GNU readline is being used. If libedit
1473 # This is only done if GNU readline is being used. If libedit
1470 # is being used (as on Leopard) the readline config is
1474 # is being used (as on Leopard) the readline config is
1471 # not run as the syntax for libedit is different.
1475 # not run as the syntax for libedit is different.
1472 if not readline.uses_libedit:
1476 if not readline.uses_libedit:
1473 for rlcommand in self.rc.readline_parse_and_bind:
1477 for rlcommand in self.rc.readline_parse_and_bind:
1474 #print "loading rl:",rlcommand # dbg
1478 #print "loading rl:",rlcommand # dbg
1475 readline.parse_and_bind(rlcommand)
1479 readline.parse_and_bind(rlcommand)
1476
1480
1477 # Remove some chars from the delimiters list. If we encounter
1481 # Remove some chars from the delimiters list. If we encounter
1478 # unicode chars, discard them.
1482 # unicode chars, discard them.
1479 delims = readline.get_completer_delims().encode("ascii", "ignore")
1483 delims = readline.get_completer_delims().encode("ascii", "ignore")
1480 delims = delims.translate(string._idmap,
1484 delims = delims.translate(string._idmap,
1481 self.rc.readline_remove_delims)
1485 self.rc.readline_remove_delims)
1482 readline.set_completer_delims(delims)
1486 readline.set_completer_delims(delims)
1483 # otherwise we end up with a monster history after a while:
1487 # otherwise we end up with a monster history after a while:
1484 readline.set_history_length(1000)
1488 readline.set_history_length(1000)
1485 try:
1489 try:
1486 #print '*** Reading readline history' # dbg
1490 #print '*** Reading readline history' # dbg
1487 readline.read_history_file(self.histfile)
1491 readline.read_history_file(self.histfile)
1488 except IOError:
1492 except IOError:
1489 pass # It doesn't exist yet.
1493 pass # It doesn't exist yet.
1490
1494
1491 atexit.register(self.atexit_operations)
1495 atexit.register(self.atexit_operations)
1492 del atexit
1496 del atexit
1493
1497
1494 # Configure auto-indent for all platforms
1498 # Configure auto-indent for all platforms
1495 self.set_autoindent(self.rc.autoindent)
1499 self.set_autoindent(self.rc.autoindent)
1496
1500
1497 def ask_yes_no(self,prompt,default=True):
1501 def ask_yes_no(self,prompt,default=True):
1498 if self.rc.quiet:
1502 if self.rc.quiet:
1499 return True
1503 return True
1500 return ask_yes_no(prompt,default)
1504 return ask_yes_no(prompt,default)
1501
1505
1502 def new_main_mod(self,ns=None):
1506 def new_main_mod(self,ns=None):
1503 """Return a new 'main' module object for user code execution.
1507 """Return a new 'main' module object for user code execution.
1504 """
1508 """
1505 main_mod = self._user_main_module
1509 main_mod = self._user_main_module
1506 init_fakemod_dict(main_mod,ns)
1510 init_fakemod_dict(main_mod,ns)
1507 return main_mod
1511 return main_mod
1508
1512
1509 def cache_main_mod(self,ns,fname):
1513 def cache_main_mod(self,ns,fname):
1510 """Cache a main module's namespace.
1514 """Cache a main module's namespace.
1511
1515
1512 When scripts are executed via %run, we must keep a reference to the
1516 When scripts are executed via %run, we must keep a reference to the
1513 namespace of their __main__ module (a FakeModule instance) around so
1517 namespace of their __main__ module (a FakeModule instance) around so
1514 that Python doesn't clear it, rendering objects defined therein
1518 that Python doesn't clear it, rendering objects defined therein
1515 useless.
1519 useless.
1516
1520
1517 This method keeps said reference in a private dict, keyed by the
1521 This method keeps said reference in a private dict, keyed by the
1518 absolute path of the module object (which corresponds to the script
1522 absolute path of the module object (which corresponds to the script
1519 path). This way, for multiple executions of the same script we only
1523 path). This way, for multiple executions of the same script we only
1520 keep one copy of the namespace (the last one), thus preventing memory
1524 keep one copy of the namespace (the last one), thus preventing memory
1521 leaks from old references while allowing the objects from the last
1525 leaks from old references while allowing the objects from the last
1522 execution to be accessible.
1526 execution to be accessible.
1523
1527
1524 Note: we can not allow the actual FakeModule instances to be deleted,
1528 Note: we can not allow the actual FakeModule instances to be deleted,
1525 because of how Python tears down modules (it hard-sets all their
1529 because of how Python tears down modules (it hard-sets all their
1526 references to None without regard for reference counts). This method
1530 references to None without regard for reference counts). This method
1527 must therefore make a *copy* of the given namespace, to allow the
1531 must therefore make a *copy* of the given namespace, to allow the
1528 original module's __dict__ to be cleared and reused.
1532 original module's __dict__ to be cleared and reused.
1529
1533
1530
1534
1531 Parameters
1535 Parameters
1532 ----------
1536 ----------
1533 ns : a namespace (a dict, typically)
1537 ns : a namespace (a dict, typically)
1534
1538
1535 fname : str
1539 fname : str
1536 Filename associated with the namespace.
1540 Filename associated with the namespace.
1537
1541
1538 Examples
1542 Examples
1539 --------
1543 --------
1540
1544
1541 In [10]: import IPython
1545 In [10]: import IPython
1542
1546
1543 In [11]: _ip.IP.cache_main_mod(IPython.__dict__,IPython.__file__)
1547 In [11]: _ip.IP.cache_main_mod(IPython.__dict__,IPython.__file__)
1544
1548
1545 In [12]: IPython.__file__ in _ip.IP._main_ns_cache
1549 In [12]: IPython.__file__ in _ip.IP._main_ns_cache
1546 Out[12]: True
1550 Out[12]: True
1547 """
1551 """
1548 self._main_ns_cache[os.path.abspath(fname)] = ns.copy()
1552 self._main_ns_cache[os.path.abspath(fname)] = ns.copy()
1549
1553
1550 def clear_main_mod_cache(self):
1554 def clear_main_mod_cache(self):
1551 """Clear the cache of main modules.
1555 """Clear the cache of main modules.
1552
1556
1553 Mainly for use by utilities like %reset.
1557 Mainly for use by utilities like %reset.
1554
1558
1555 Examples
1559 Examples
1556 --------
1560 --------
1557
1561
1558 In [15]: import IPython
1562 In [15]: import IPython
1559
1563
1560 In [16]: _ip.IP.cache_main_mod(IPython.__dict__,IPython.__file__)
1564 In [16]: _ip.IP.cache_main_mod(IPython.__dict__,IPython.__file__)
1561
1565
1562 In [17]: len(_ip.IP._main_ns_cache) > 0
1566 In [17]: len(_ip.IP._main_ns_cache) > 0
1563 Out[17]: True
1567 Out[17]: True
1564
1568
1565 In [18]: _ip.IP.clear_main_mod_cache()
1569 In [18]: _ip.IP.clear_main_mod_cache()
1566
1570
1567 In [19]: len(_ip.IP._main_ns_cache) == 0
1571 In [19]: len(_ip.IP._main_ns_cache) == 0
1568 Out[19]: True
1572 Out[19]: True
1569 """
1573 """
1570 self._main_ns_cache.clear()
1574 self._main_ns_cache.clear()
1571
1575
1572 def _should_recompile(self,e):
1576 def _should_recompile(self,e):
1573 """Utility routine for edit_syntax_error"""
1577 """Utility routine for edit_syntax_error"""
1574
1578
1575 if e.filename in ('<ipython console>','<input>','<string>',
1579 if e.filename in ('<ipython console>','<input>','<string>',
1576 '<console>','<BackgroundJob compilation>',
1580 '<console>','<BackgroundJob compilation>',
1577 None):
1581 None):
1578
1582
1579 return False
1583 return False
1580 try:
1584 try:
1581 if (self.rc.autoedit_syntax and
1585 if (self.rc.autoedit_syntax and
1582 not self.ask_yes_no('Return to editor to correct syntax error? '
1586 not self.ask_yes_no('Return to editor to correct syntax error? '
1583 '[Y/n] ','y')):
1587 '[Y/n] ','y')):
1584 return False
1588 return False
1585 except EOFError:
1589 except EOFError:
1586 return False
1590 return False
1587
1591
1588 def int0(x):
1592 def int0(x):
1589 try:
1593 try:
1590 return int(x)
1594 return int(x)
1591 except TypeError:
1595 except TypeError:
1592 return 0
1596 return 0
1593 # always pass integer line and offset values to editor hook
1597 # always pass integer line and offset values to editor hook
1594 try:
1598 try:
1595 self.hooks.fix_error_editor(e.filename,
1599 self.hooks.fix_error_editor(e.filename,
1596 int0(e.lineno),int0(e.offset),e.msg)
1600 int0(e.lineno),int0(e.offset),e.msg)
1597 except IPython.ipapi.TryNext:
1601 except IPython.ipapi.TryNext:
1598 warn('Could not open editor')
1602 warn('Could not open editor')
1599 return False
1603 return False
1600 return True
1604 return True
1601
1605
1602 def edit_syntax_error(self):
1606 def edit_syntax_error(self):
1603 """The bottom half of the syntax error handler called in the main loop.
1607 """The bottom half of the syntax error handler called in the main loop.
1604
1608
1605 Loop until syntax error is fixed or user cancels.
1609 Loop until syntax error is fixed or user cancels.
1606 """
1610 """
1607
1611
1608 while self.SyntaxTB.last_syntax_error:
1612 while self.SyntaxTB.last_syntax_error:
1609 # copy and clear last_syntax_error
1613 # copy and clear last_syntax_error
1610 err = self.SyntaxTB.clear_err_state()
1614 err = self.SyntaxTB.clear_err_state()
1611 if not self._should_recompile(err):
1615 if not self._should_recompile(err):
1612 return
1616 return
1613 try:
1617 try:
1614 # may set last_syntax_error again if a SyntaxError is raised
1618 # may set last_syntax_error again if a SyntaxError is raised
1615 self.safe_execfile(err.filename,self.user_ns)
1619 self.safe_execfile(err.filename,self.user_ns)
1616 except:
1620 except:
1617 self.showtraceback()
1621 self.showtraceback()
1618 else:
1622 else:
1619 try:
1623 try:
1620 f = file(err.filename)
1624 f = file(err.filename)
1621 try:
1625 try:
1622 sys.displayhook(f.read())
1626 sys.displayhook(f.read())
1623 finally:
1627 finally:
1624 f.close()
1628 f.close()
1625 except:
1629 except:
1626 self.showtraceback()
1630 self.showtraceback()
1627
1631
1628 def showsyntaxerror(self, filename=None):
1632 def showsyntaxerror(self, filename=None):
1629 """Display the syntax error that just occurred.
1633 """Display the syntax error that just occurred.
1630
1634
1631 This doesn't display a stack trace because there isn't one.
1635 This doesn't display a stack trace because there isn't one.
1632
1636
1633 If a filename is given, it is stuffed in the exception instead
1637 If a filename is given, it is stuffed in the exception instead
1634 of what was there before (because Python's parser always uses
1638 of what was there before (because Python's parser always uses
1635 "<string>" when reading from a string).
1639 "<string>" when reading from a string).
1636 """
1640 """
1637 etype, value, last_traceback = sys.exc_info()
1641 etype, value, last_traceback = sys.exc_info()
1638
1642
1639 # See note about these variables in showtraceback() below
1643 # See note about these variables in showtraceback() below
1640 sys.last_type = etype
1644 sys.last_type = etype
1641 sys.last_value = value
1645 sys.last_value = value
1642 sys.last_traceback = last_traceback
1646 sys.last_traceback = last_traceback
1643
1647
1644 if filename and etype is SyntaxError:
1648 if filename and etype is SyntaxError:
1645 # Work hard to stuff the correct filename in the exception
1649 # Work hard to stuff the correct filename in the exception
1646 try:
1650 try:
1647 msg, (dummy_filename, lineno, offset, line) = value
1651 msg, (dummy_filename, lineno, offset, line) = value
1648 except:
1652 except:
1649 # Not the format we expect; leave it alone
1653 # Not the format we expect; leave it alone
1650 pass
1654 pass
1651 else:
1655 else:
1652 # Stuff in the right filename
1656 # Stuff in the right filename
1653 try:
1657 try:
1654 # Assume SyntaxError is a class exception
1658 # Assume SyntaxError is a class exception
1655 value = SyntaxError(msg, (filename, lineno, offset, line))
1659 value = SyntaxError(msg, (filename, lineno, offset, line))
1656 except:
1660 except:
1657 # If that failed, assume SyntaxError is a string
1661 # If that failed, assume SyntaxError is a string
1658 value = msg, (filename, lineno, offset, line)
1662 value = msg, (filename, lineno, offset, line)
1659 self.SyntaxTB(etype,value,[])
1663 self.SyntaxTB(etype,value,[])
1660
1664
1661 def debugger(self,force=False):
1665 def debugger(self,force=False):
1662 """Call the pydb/pdb debugger.
1666 """Call the pydb/pdb debugger.
1663
1667
1664 Keywords:
1668 Keywords:
1665
1669
1666 - force(False): by default, this routine checks the instance call_pdb
1670 - force(False): by default, this routine checks the instance call_pdb
1667 flag and does not actually invoke the debugger if the flag is false.
1671 flag and does not actually invoke the debugger if the flag is false.
1668 The 'force' option forces the debugger to activate even if the flag
1672 The 'force' option forces the debugger to activate even if the flag
1669 is false.
1673 is false.
1670 """
1674 """
1671
1675
1672 if not (force or self.call_pdb):
1676 if not (force or self.call_pdb):
1673 return
1677 return
1674
1678
1675 if not hasattr(sys,'last_traceback'):
1679 if not hasattr(sys,'last_traceback'):
1676 error('No traceback has been produced, nothing to debug.')
1680 error('No traceback has been produced, nothing to debug.')
1677 return
1681 return
1678
1682
1679 # use pydb if available
1683 # use pydb if available
1680 if Debugger.has_pydb:
1684 if Debugger.has_pydb:
1681 from pydb import pm
1685 from pydb import pm
1682 else:
1686 else:
1683 # fallback to our internal debugger
1687 # fallback to our internal debugger
1684 pm = lambda : self.InteractiveTB.debugger(force=True)
1688 pm = lambda : self.InteractiveTB.debugger(force=True)
1685 self.history_saving_wrapper(pm)()
1689 self.history_saving_wrapper(pm)()
1686
1690
1687 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None):
1691 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None):
1688 """Display the exception that just occurred.
1692 """Display the exception that just occurred.
1689
1693
1690 If nothing is known about the exception, this is the method which
1694 If nothing is known about the exception, this is the method which
1691 should be used throughout the code for presenting user tracebacks,
1695 should be used throughout the code for presenting user tracebacks,
1692 rather than directly invoking the InteractiveTB object.
1696 rather than directly invoking the InteractiveTB object.
1693
1697
1694 A specific showsyntaxerror() also exists, but this method can take
1698 A specific showsyntaxerror() also exists, but this method can take
1695 care of calling it if needed, so unless you are explicitly catching a
1699 care of calling it if needed, so unless you are explicitly catching a
1696 SyntaxError exception, don't try to analyze the stack manually and
1700 SyntaxError exception, don't try to analyze the stack manually and
1697 simply call this method."""
1701 simply call this method."""
1698
1702
1699
1703
1700 # Though this won't be called by syntax errors in the input line,
1704 # Though this won't be called by syntax errors in the input line,
1701 # there may be SyntaxError cases whith imported code.
1705 # there may be SyntaxError cases whith imported code.
1702
1706
1703 try:
1707 try:
1704 if exc_tuple is None:
1708 if exc_tuple is None:
1705 etype, value, tb = sys.exc_info()
1709 etype, value, tb = sys.exc_info()
1706 else:
1710 else:
1707 etype, value, tb = exc_tuple
1711 etype, value, tb = exc_tuple
1708
1712
1709 if etype is SyntaxError:
1713 if etype is SyntaxError:
1710 self.showsyntaxerror(filename)
1714 self.showsyntaxerror(filename)
1711 elif etype is IPython.ipapi.UsageError:
1715 elif etype is IPython.ipapi.UsageError:
1712 print "UsageError:", value
1716 print "UsageError:", value
1713 else:
1717 else:
1714 # WARNING: these variables are somewhat deprecated and not
1718 # WARNING: these variables are somewhat deprecated and not
1715 # necessarily safe to use in a threaded environment, but tools
1719 # necessarily safe to use in a threaded environment, but tools
1716 # like pdb depend on their existence, so let's set them. If we
1720 # like pdb depend on their existence, so let's set them. If we
1717 # find problems in the field, we'll need to revisit their use.
1721 # find problems in the field, we'll need to revisit their use.
1718 sys.last_type = etype
1722 sys.last_type = etype
1719 sys.last_value = value
1723 sys.last_value = value
1720 sys.last_traceback = tb
1724 sys.last_traceback = tb
1721
1725
1722 if etype in self.custom_exceptions:
1726 if etype in self.custom_exceptions:
1723 self.CustomTB(etype,value,tb)
1727 self.CustomTB(etype,value,tb)
1724 else:
1728 else:
1725 self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)
1729 self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)
1726 if self.InteractiveTB.call_pdb and self.has_readline:
1730 if self.InteractiveTB.call_pdb and self.has_readline:
1727 # pdb mucks up readline, fix it back
1731 # pdb mucks up readline, fix it back
1728 self.set_completer()
1732 self.set_completer()
1729 except KeyboardInterrupt:
1733 except KeyboardInterrupt:
1730 self.write("\nKeyboardInterrupt\n")
1734 self.write("\nKeyboardInterrupt\n")
1731
1735
1732 def mainloop(self,banner=None):
1736 def mainloop(self,banner=None):
1733 """Creates the local namespace and starts the mainloop.
1737 """Creates the local namespace and starts the mainloop.
1734
1738
1735 If an optional banner argument is given, it will override the
1739 If an optional banner argument is given, it will override the
1736 internally created default banner."""
1740 internally created default banner."""
1737
1741
1738 if self.rc.c: # Emulate Python's -c option
1742 if self.rc.c: # Emulate Python's -c option
1739 self.exec_init_cmd()
1743 self.exec_init_cmd()
1740 if banner is None:
1744 if banner is None:
1741 if not self.rc.banner:
1745 if not self.rc.banner:
1742 banner = ''
1746 banner = ''
1743 # banner is string? Use it directly!
1747 # banner is string? Use it directly!
1744 elif isinstance(self.rc.banner,basestring):
1748 elif isinstance(self.rc.banner,basestring):
1745 banner = self.rc.banner
1749 banner = self.rc.banner
1746 else:
1750 else:
1747 banner = self.BANNER+self.banner2
1751 banner = self.BANNER+self.banner2
1748
1752
1749 # if you run stuff with -c <cmd>, raw hist is not updated
1753 # if you run stuff with -c <cmd>, raw hist is not updated
1750 # ensure that it's in sync
1754 # ensure that it's in sync
1751 if len(self.input_hist) != len (self.input_hist_raw):
1755 if len(self.input_hist) != len (self.input_hist_raw):
1752 self.input_hist_raw = InputList(self.input_hist)
1756 self.input_hist_raw = InputList(self.input_hist)
1753
1757
1754 while 1:
1758 while 1:
1755 try:
1759 try:
1756 self.interact(banner)
1760 self.interact(banner)
1757 #self.interact_with_readline()
1761 #self.interact_with_readline()
1758
1762
1759 # XXX for testing of a readline-decoupled repl loop, call
1763 # XXX for testing of a readline-decoupled repl loop, call
1760 # interact_with_readline above
1764 # interact_with_readline above
1761
1765
1762 break
1766 break
1763 except KeyboardInterrupt:
1767 except KeyboardInterrupt:
1764 # this should not be necessary, but KeyboardInterrupt
1768 # this should not be necessary, but KeyboardInterrupt
1765 # handling seems rather unpredictable...
1769 # handling seems rather unpredictable...
1766 self.write("\nKeyboardInterrupt in interact()\n")
1770 self.write("\nKeyboardInterrupt in interact()\n")
1767
1771
1768 def exec_init_cmd(self):
1772 def exec_init_cmd(self):
1769 """Execute a command given at the command line.
1773 """Execute a command given at the command line.
1770
1774
1771 This emulates Python's -c option."""
1775 This emulates Python's -c option."""
1772
1776
1773 #sys.argv = ['-c']
1777 #sys.argv = ['-c']
1774 self.push(self.prefilter(self.rc.c, False))
1778 self.push(self.prefilter(self.rc.c, False))
1775 if not self.rc.interact:
1779 if not self.rc.interact:
1776 self.ask_exit()
1780 self.ask_exit()
1777
1781
1778 def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):
1782 def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):
1779 """Embeds IPython into a running python program.
1783 """Embeds IPython into a running python program.
1780
1784
1781 Input:
1785 Input:
1782
1786
1783 - header: An optional header message can be specified.
1787 - header: An optional header message can be specified.
1784
1788
1785 - local_ns, global_ns: working namespaces. If given as None, the
1789 - local_ns, global_ns: working namespaces. If given as None, the
1786 IPython-initialized one is updated with __main__.__dict__, so that
1790 IPython-initialized one is updated with __main__.__dict__, so that
1787 program variables become visible but user-specific configuration
1791 program variables become visible but user-specific configuration
1788 remains possible.
1792 remains possible.
1789
1793
1790 - stack_depth: specifies how many levels in the stack to go to
1794 - stack_depth: specifies how many levels in the stack to go to
1791 looking for namespaces (when local_ns and global_ns are None). This
1795 looking for namespaces (when local_ns and global_ns are None). This
1792 allows an intermediate caller to make sure that this function gets
1796 allows an intermediate caller to make sure that this function gets
1793 the namespace from the intended level in the stack. By default (0)
1797 the namespace from the intended level in the stack. By default (0)
1794 it will get its locals and globals from the immediate caller.
1798 it will get its locals and globals from the immediate caller.
1795
1799
1796 Warning: it's possible to use this in a program which is being run by
1800 Warning: it's possible to use this in a program which is being run by
1797 IPython itself (via %run), but some funny things will happen (a few
1801 IPython itself (via %run), but some funny things will happen (a few
1798 globals get overwritten). In the future this will be cleaned up, as
1802 globals get overwritten). In the future this will be cleaned up, as
1799 there is no fundamental reason why it can't work perfectly."""
1803 there is no fundamental reason why it can't work perfectly."""
1800
1804
1801 # Get locals and globals from caller
1805 # Get locals and globals from caller
1802 if local_ns is None or global_ns is None:
1806 if local_ns is None or global_ns is None:
1803 call_frame = sys._getframe(stack_depth).f_back
1807 call_frame = sys._getframe(stack_depth).f_back
1804
1808
1805 if local_ns is None:
1809 if local_ns is None:
1806 local_ns = call_frame.f_locals
1810 local_ns = call_frame.f_locals
1807 if global_ns is None:
1811 if global_ns is None:
1808 global_ns = call_frame.f_globals
1812 global_ns = call_frame.f_globals
1809
1813
1810 # Update namespaces and fire up interpreter
1814 # Update namespaces and fire up interpreter
1811
1815
1812 # The global one is easy, we can just throw it in
1816 # The global one is easy, we can just throw it in
1813 self.user_global_ns = global_ns
1817 self.user_global_ns = global_ns
1814
1818
1815 # but the user/local one is tricky: ipython needs it to store internal
1819 # but the user/local one is tricky: ipython needs it to store internal
1816 # data, but we also need the locals. We'll copy locals in the user
1820 # data, but we also need the locals. We'll copy locals in the user
1817 # one, but will track what got copied so we can delete them at exit.
1821 # one, but will track what got copied so we can delete them at exit.
1818 # This is so that a later embedded call doesn't see locals from a
1822 # This is so that a later embedded call doesn't see locals from a
1819 # previous call (which most likely existed in a separate scope).
1823 # previous call (which most likely existed in a separate scope).
1820 local_varnames = local_ns.keys()
1824 local_varnames = local_ns.keys()
1821 self.user_ns.update(local_ns)
1825 self.user_ns.update(local_ns)
1822 #self.user_ns['local_ns'] = local_ns # dbg
1826 #self.user_ns['local_ns'] = local_ns # dbg
1823
1827
1824 # Patch for global embedding to make sure that things don't overwrite
1828 # Patch for global embedding to make sure that things don't overwrite
1825 # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
1829 # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
1826 # FIXME. Test this a bit more carefully (the if.. is new)
1830 # FIXME. Test this a bit more carefully (the if.. is new)
1827 if local_ns is None and global_ns is None:
1831 if local_ns is None and global_ns is None:
1828 self.user_global_ns.update(__main__.__dict__)
1832 self.user_global_ns.update(__main__.__dict__)
1829
1833
1830 # make sure the tab-completer has the correct frame information, so it
1834 # make sure the tab-completer has the correct frame information, so it
1831 # actually completes using the frame's locals/globals
1835 # actually completes using the frame's locals/globals
1832 self.set_completer_frame()
1836 self.set_completer_frame()
1833
1837
1834 # before activating the interactive mode, we need to make sure that
1838 # before activating the interactive mode, we need to make sure that
1835 # all names in the builtin namespace needed by ipython point to
1839 # all names in the builtin namespace needed by ipython point to
1836 # ourselves, and not to other instances.
1840 # ourselves, and not to other instances.
1837 self.add_builtins()
1841 self.add_builtins()
1838
1842
1839 self.interact(header)
1843 self.interact(header)
1840
1844
1841 # now, purge out the user namespace from anything we might have added
1845 # now, purge out the user namespace from anything we might have added
1842 # from the caller's local namespace
1846 # from the caller's local namespace
1843 delvar = self.user_ns.pop
1847 delvar = self.user_ns.pop
1844 for var in local_varnames:
1848 for var in local_varnames:
1845 delvar(var,None)
1849 delvar(var,None)
1846 # and clean builtins we may have overridden
1850 # and clean builtins we may have overridden
1847 self.clean_builtins()
1851 self.clean_builtins()
1848
1852
1849 def interact_prompt(self):
1853 def interact_prompt(self):
1850 """ Print the prompt (in read-eval-print loop)
1854 """ Print the prompt (in read-eval-print loop)
1851
1855
1852 Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not
1856 Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not
1853 used in standard IPython flow.
1857 used in standard IPython flow.
1854 """
1858 """
1855 if self.more:
1859 if self.more:
1856 try:
1860 try:
1857 prompt = self.hooks.generate_prompt(True)
1861 prompt = self.hooks.generate_prompt(True)
1858 except:
1862 except:
1859 self.showtraceback()
1863 self.showtraceback()
1860 if self.autoindent:
1864 if self.autoindent:
1861 self.rl_do_indent = True
1865 self.rl_do_indent = True
1862
1866
1863 else:
1867 else:
1864 try:
1868 try:
1865 prompt = self.hooks.generate_prompt(False)
1869 prompt = self.hooks.generate_prompt(False)
1866 except:
1870 except:
1867 self.showtraceback()
1871 self.showtraceback()
1868 self.write(prompt)
1872 self.write(prompt)
1869
1873
1870 def interact_handle_input(self,line):
1874 def interact_handle_input(self,line):
1871 """ Handle the input line (in read-eval-print loop)
1875 """ Handle the input line (in read-eval-print loop)
1872
1876
1873 Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not
1877 Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not
1874 used in standard IPython flow.
1878 used in standard IPython flow.
1875 """
1879 """
1876 if line.lstrip() == line:
1880 if line.lstrip() == line:
1877 self.shadowhist.add(line.strip())
1881 self.shadowhist.add(line.strip())
1878 lineout = self.prefilter(line,self.more)
1882 lineout = self.prefilter(line,self.more)
1879
1883
1880 if line.strip():
1884 if line.strip():
1881 if self.more:
1885 if self.more:
1882 self.input_hist_raw[-1] += '%s\n' % line
1886 self.input_hist_raw[-1] += '%s\n' % line
1883 else:
1887 else:
1884 self.input_hist_raw.append('%s\n' % line)
1888 self.input_hist_raw.append('%s\n' % line)
1885
1889
1886
1890
1887 self.more = self.push(lineout)
1891 self.more = self.push(lineout)
1888 if (self.SyntaxTB.last_syntax_error and
1892 if (self.SyntaxTB.last_syntax_error and
1889 self.rc.autoedit_syntax):
1893 self.rc.autoedit_syntax):
1890 self.edit_syntax_error()
1894 self.edit_syntax_error()
1891
1895
1892 def interact_with_readline(self):
1896 def interact_with_readline(self):
1893 """ Demo of using interact_handle_input, interact_prompt
1897 """ Demo of using interact_handle_input, interact_prompt
1894
1898
1895 This is the main read-eval-print loop. If you need to implement your own (e.g. for GUI),
1899 This is the main read-eval-print loop. If you need to implement your own (e.g. for GUI),
1896 it should work like this.
1900 it should work like this.
1897 """
1901 """
1898 self.readline_startup_hook(self.pre_readline)
1902 self.readline_startup_hook(self.pre_readline)
1899 while not self.exit_now:
1903 while not self.exit_now:
1900 self.interact_prompt()
1904 self.interact_prompt()
1901 if self.more:
1905 if self.more:
1902 self.rl_do_indent = True
1906 self.rl_do_indent = True
1903 else:
1907 else:
1904 self.rl_do_indent = False
1908 self.rl_do_indent = False
1905 line = raw_input_original().decode(self.stdin_encoding)
1909 line = raw_input_original().decode(self.stdin_encoding)
1906 self.interact_handle_input(line)
1910 self.interact_handle_input(line)
1907
1911
1908
1912
1909 def interact(self, banner=None):
1913 def interact(self, banner=None):
1910 """Closely emulate the interactive Python console.
1914 """Closely emulate the interactive Python console.
1911
1915
1912 The optional banner argument specify the banner to print
1916 The optional banner argument specify the banner to print
1913 before the first interaction; by default it prints a banner
1917 before the first interaction; by default it prints a banner
1914 similar to the one printed by the real Python interpreter,
1918 similar to the one printed by the real Python interpreter,
1915 followed by the current class name in parentheses (so as not
1919 followed by the current class name in parentheses (so as not
1916 to confuse this with the real interpreter -- since it's so
1920 to confuse this with the real interpreter -- since it's so
1917 close!).
1921 close!).
1918
1922
1919 """
1923 """
1920
1924
1921 if self.exit_now:
1925 if self.exit_now:
1922 # batch run -> do not interact
1926 # batch run -> do not interact
1923 return
1927 return
1924 cprt = 'Type "copyright", "credits" or "license" for more information.'
1928 cprt = 'Type "copyright", "credits" or "license" for more information.'
1925 if banner is None:
1929 if banner is None:
1926 self.write("Python %s on %s\n%s\n(%s)\n" %
1930 self.write("Python %s on %s\n%s\n(%s)\n" %
1927 (sys.version, sys.platform, cprt,
1931 (sys.version, sys.platform, cprt,
1928 self.__class__.__name__))
1932 self.__class__.__name__))
1929 else:
1933 else:
1930 self.write(banner)
1934 self.write(banner)
1931
1935
1932 more = 0
1936 more = 0
1933
1937
1934 # Mark activity in the builtins
1938 # Mark activity in the builtins
1935 __builtin__.__dict__['__IPYTHON__active'] += 1
1939 __builtin__.__dict__['__IPYTHON__active'] += 1
1936
1940
1937 if self.has_readline:
1941 if self.has_readline:
1938 self.readline_startup_hook(self.pre_readline)
1942 self.readline_startup_hook(self.pre_readline)
1939 # exit_now is set by a call to %Exit or %Quit, through the
1943 # exit_now is set by a call to %Exit or %Quit, through the
1940 # ask_exit callback.
1944 # ask_exit callback.
1941
1945
1942 while not self.exit_now:
1946 while not self.exit_now:
1943 self.hooks.pre_prompt_hook()
1947 self.hooks.pre_prompt_hook()
1944 if more:
1948 if more:
1945 try:
1949 try:
1946 prompt = self.hooks.generate_prompt(True)
1950 prompt = self.hooks.generate_prompt(True)
1947 except:
1951 except:
1948 self.showtraceback()
1952 self.showtraceback()
1949 if self.autoindent:
1953 if self.autoindent:
1950 self.rl_do_indent = True
1954 self.rl_do_indent = True
1951
1955
1952 else:
1956 else:
1953 try:
1957 try:
1954 prompt = self.hooks.generate_prompt(False)
1958 prompt = self.hooks.generate_prompt(False)
1955 except:
1959 except:
1956 self.showtraceback()
1960 self.showtraceback()
1957 try:
1961 try:
1958 line = self.raw_input(prompt,more)
1962 line = self.raw_input(prompt,more)
1959 if self.exit_now:
1963 if self.exit_now:
1960 # quick exit on sys.std[in|out] close
1964 # quick exit on sys.std[in|out] close
1961 break
1965 break
1962 if self.autoindent:
1966 if self.autoindent:
1963 self.rl_do_indent = False
1967 self.rl_do_indent = False
1964
1968
1965 except KeyboardInterrupt:
1969 except KeyboardInterrupt:
1966 #double-guard against keyboardinterrupts during kbdint handling
1970 #double-guard against keyboardinterrupts during kbdint handling
1967 try:
1971 try:
1968 self.write('\nKeyboardInterrupt\n')
1972 self.write('\nKeyboardInterrupt\n')
1969 self.resetbuffer()
1973 self.resetbuffer()
1970 # keep cache in sync with the prompt counter:
1974 # keep cache in sync with the prompt counter:
1971 self.outputcache.prompt_count -= 1
1975 self.outputcache.prompt_count -= 1
1972
1976
1973 if self.autoindent:
1977 if self.autoindent:
1974 self.indent_current_nsp = 0
1978 self.indent_current_nsp = 0
1975 more = 0
1979 more = 0
1976 except KeyboardInterrupt:
1980 except KeyboardInterrupt:
1977 pass
1981 pass
1978 except EOFError:
1982 except EOFError:
1979 if self.autoindent:
1983 if self.autoindent:
1980 self.rl_do_indent = False
1984 self.rl_do_indent = False
1981 self.readline_startup_hook(None)
1985 self.readline_startup_hook(None)
1982 self.write('\n')
1986 self.write('\n')
1983 self.exit()
1987 self.exit()
1984 except bdb.BdbQuit:
1988 except bdb.BdbQuit:
1985 warn('The Python debugger has exited with a BdbQuit exception.\n'
1989 warn('The Python debugger has exited with a BdbQuit exception.\n'
1986 'Because of how pdb handles the stack, it is impossible\n'
1990 'Because of how pdb handles the stack, it is impossible\n'
1987 'for IPython to properly format this particular exception.\n'
1991 'for IPython to properly format this particular exception.\n'
1988 'IPython will resume normal operation.')
1992 'IPython will resume normal operation.')
1989 except:
1993 except:
1990 # exceptions here are VERY RARE, but they can be triggered
1994 # exceptions here are VERY RARE, but they can be triggered
1991 # asynchronously by signal handlers, for example.
1995 # asynchronously by signal handlers, for example.
1992 self.showtraceback()
1996 self.showtraceback()
1993 else:
1997 else:
1994 more = self.push(line)
1998 more = self.push(line)
1995 if (self.SyntaxTB.last_syntax_error and
1999 if (self.SyntaxTB.last_syntax_error and
1996 self.rc.autoedit_syntax):
2000 self.rc.autoedit_syntax):
1997 self.edit_syntax_error()
2001 self.edit_syntax_error()
1998
2002
1999 # We are off again...
2003 # We are off again...
2000 __builtin__.__dict__['__IPYTHON__active'] -= 1
2004 __builtin__.__dict__['__IPYTHON__active'] -= 1
2001
2005
2002 def excepthook(self, etype, value, tb):
2006 def excepthook(self, etype, value, tb):
2003 """One more defense for GUI apps that call sys.excepthook.
2007 """One more defense for GUI apps that call sys.excepthook.
2004
2008
2005 GUI frameworks like wxPython trap exceptions and call
2009 GUI frameworks like wxPython trap exceptions and call
2006 sys.excepthook themselves. I guess this is a feature that
2010 sys.excepthook themselves. I guess this is a feature that
2007 enables them to keep running after exceptions that would
2011 enables them to keep running after exceptions that would
2008 otherwise kill their mainloop. This is a bother for IPython
2012 otherwise kill their mainloop. This is a bother for IPython
2009 which excepts to catch all of the program exceptions with a try:
2013 which excepts to catch all of the program exceptions with a try:
2010 except: statement.
2014 except: statement.
2011
2015
2012 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
2016 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
2013 any app directly invokes sys.excepthook, it will look to the user like
2017 any app directly invokes sys.excepthook, it will look to the user like
2014 IPython crashed. In order to work around this, we can disable the
2018 IPython crashed. In order to work around this, we can disable the
2015 CrashHandler and replace it with this excepthook instead, which prints a
2019 CrashHandler and replace it with this excepthook instead, which prints a
2016 regular traceback using our InteractiveTB. In this fashion, apps which
2020 regular traceback using our InteractiveTB. In this fashion, apps which
2017 call sys.excepthook will generate a regular-looking exception from
2021 call sys.excepthook will generate a regular-looking exception from
2018 IPython, and the CrashHandler will only be triggered by real IPython
2022 IPython, and the CrashHandler will only be triggered by real IPython
2019 crashes.
2023 crashes.
2020
2024
2021 This hook should be used sparingly, only in places which are not likely
2025 This hook should be used sparingly, only in places which are not likely
2022 to be true IPython errors.
2026 to be true IPython errors.
2023 """
2027 """
2024 self.showtraceback((etype,value,tb),tb_offset=0)
2028 self.showtraceback((etype,value,tb),tb_offset=0)
2025
2029
2026 def expand_aliases(self,fn,rest):
2030 def expand_aliases(self,fn,rest):
2027 """ Expand multiple levels of aliases:
2031 """ Expand multiple levels of aliases:
2028
2032
2029 if:
2033 if:
2030
2034
2031 alias foo bar /tmp
2035 alias foo bar /tmp
2032 alias baz foo
2036 alias baz foo
2033
2037
2034 then:
2038 then:
2035
2039
2036 baz huhhahhei -> bar /tmp huhhahhei
2040 baz huhhahhei -> bar /tmp huhhahhei
2037
2041
2038 """
2042 """
2039 line = fn + " " + rest
2043 line = fn + " " + rest
2040
2044
2041 done = set()
2045 done = set()
2042 while 1:
2046 while 1:
2043 pre,fn,rest = prefilter.splitUserInput(line,
2047 pre,fn,rest = prefilter.splitUserInput(line,
2044 prefilter.shell_line_split)
2048 prefilter.shell_line_split)
2045 if fn in self.alias_table:
2049 if fn in self.alias_table:
2046 if fn in done:
2050 if fn in done:
2047 warn("Cyclic alias definition, repeated '%s'" % fn)
2051 warn("Cyclic alias definition, repeated '%s'" % fn)
2048 return ""
2052 return ""
2049 done.add(fn)
2053 done.add(fn)
2050
2054
2051 l2 = self.transform_alias(fn,rest)
2055 l2 = self.transform_alias(fn,rest)
2052 # dir -> dir
2056 # dir -> dir
2053 # print "alias",line, "->",l2 #dbg
2057 # print "alias",line, "->",l2 #dbg
2054 if l2 == line:
2058 if l2 == line:
2055 break
2059 break
2056 # ls -> ls -F should not recurse forever
2060 # ls -> ls -F should not recurse forever
2057 if l2.split(None,1)[0] == line.split(None,1)[0]:
2061 if l2.split(None,1)[0] == line.split(None,1)[0]:
2058 line = l2
2062 line = l2
2059 break
2063 break
2060
2064
2061 line=l2
2065 line=l2
2062
2066
2063
2067
2064 # print "al expand to",line #dbg
2068 # print "al expand to",line #dbg
2065 else:
2069 else:
2066 break
2070 break
2067
2071
2068 return line
2072 return line
2069
2073
2070 def transform_alias(self, alias,rest=''):
2074 def transform_alias(self, alias,rest=''):
2071 """ Transform alias to system command string.
2075 """ Transform alias to system command string.
2072 """
2076 """
2073 trg = self.alias_table[alias]
2077 trg = self.alias_table[alias]
2074
2078
2075 nargs,cmd = trg
2079 nargs,cmd = trg
2076 # print trg #dbg
2080 # print trg #dbg
2077 if ' ' in cmd and os.path.isfile(cmd):
2081 if ' ' in cmd and os.path.isfile(cmd):
2078 cmd = '"%s"' % cmd
2082 cmd = '"%s"' % cmd
2079
2083
2080 # Expand the %l special to be the user's input line
2084 # Expand the %l special to be the user's input line
2081 if cmd.find('%l') >= 0:
2085 if cmd.find('%l') >= 0:
2082 cmd = cmd.replace('%l',rest)
2086 cmd = cmd.replace('%l',rest)
2083 rest = ''
2087 rest = ''
2084 if nargs==0:
2088 if nargs==0:
2085 # Simple, argument-less aliases
2089 # Simple, argument-less aliases
2086 cmd = '%s %s' % (cmd,rest)
2090 cmd = '%s %s' % (cmd,rest)
2087 else:
2091 else:
2088 # Handle aliases with positional arguments
2092 # Handle aliases with positional arguments
2089 args = rest.split(None,nargs)
2093 args = rest.split(None,nargs)
2090 if len(args)< nargs:
2094 if len(args)< nargs:
2091 error('Alias <%s> requires %s arguments, %s given.' %
2095 error('Alias <%s> requires %s arguments, %s given.' %
2092 (alias,nargs,len(args)))
2096 (alias,nargs,len(args)))
2093 return None
2097 return None
2094 cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))
2098 cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))
2095 # Now call the macro, evaluating in the user's namespace
2099 # Now call the macro, evaluating in the user's namespace
2096 #print 'new command: <%r>' % cmd # dbg
2100 #print 'new command: <%r>' % cmd # dbg
2097 return cmd
2101 return cmd
2098
2102
2099 def call_alias(self,alias,rest=''):
2103 def call_alias(self,alias,rest=''):
2100 """Call an alias given its name and the rest of the line.
2104 """Call an alias given its name and the rest of the line.
2101
2105
2102 This is only used to provide backwards compatibility for users of
2106 This is only used to provide backwards compatibility for users of
2103 ipalias(), use of which is not recommended for anymore."""
2107 ipalias(), use of which is not recommended for anymore."""
2104
2108
2105 # Now call the macro, evaluating in the user's namespace
2109 # Now call the macro, evaluating in the user's namespace
2106 cmd = self.transform_alias(alias, rest)
2110 cmd = self.transform_alias(alias, rest)
2107 try:
2111 try:
2108 self.system(cmd)
2112 self.system(cmd)
2109 except:
2113 except:
2110 self.showtraceback()
2114 self.showtraceback()
2111
2115
2112 def indent_current_str(self):
2116 def indent_current_str(self):
2113 """return the current level of indentation as a string"""
2117 """return the current level of indentation as a string"""
2114 return self.indent_current_nsp * ' '
2118 return self.indent_current_nsp * ' '
2115
2119
2116 def autoindent_update(self,line):
2120 def autoindent_update(self,line):
2117 """Keep track of the indent level."""
2121 """Keep track of the indent level."""
2118
2122
2119 #debugx('line')
2123 #debugx('line')
2120 #debugx('self.indent_current_nsp')
2124 #debugx('self.indent_current_nsp')
2121 if self.autoindent:
2125 if self.autoindent:
2122 if line:
2126 if line:
2123 inisp = num_ini_spaces(line)
2127 inisp = num_ini_spaces(line)
2124 if inisp < self.indent_current_nsp:
2128 if inisp < self.indent_current_nsp:
2125 self.indent_current_nsp = inisp
2129 self.indent_current_nsp = inisp
2126
2130
2127 if line[-1] == ':':
2131 if line[-1] == ':':
2128 self.indent_current_nsp += 4
2132 self.indent_current_nsp += 4
2129 elif dedent_re.match(line):
2133 elif dedent_re.match(line):
2130 self.indent_current_nsp -= 4
2134 self.indent_current_nsp -= 4
2131 else:
2135 else:
2132 self.indent_current_nsp = 0
2136 self.indent_current_nsp = 0
2133
2137
2134 def runlines(self,lines):
2138 def runlines(self,lines):
2135 """Run a string of one or more lines of source.
2139 """Run a string of one or more lines of source.
2136
2140
2137 This method is capable of running a string containing multiple source
2141 This method is capable of running a string containing multiple source
2138 lines, as if they had been entered at the IPython prompt. Since it
2142 lines, as if they had been entered at the IPython prompt. Since it
2139 exposes IPython's processing machinery, the given strings can contain
2143 exposes IPython's processing machinery, the given strings can contain
2140 magic calls (%magic), special shell access (!cmd), etc."""
2144 magic calls (%magic), special shell access (!cmd), etc."""
2141
2145
2142 # We must start with a clean buffer, in case this is run from an
2146 # We must start with a clean buffer, in case this is run from an
2143 # interactive IPython session (via a magic, for example).
2147 # interactive IPython session (via a magic, for example).
2144 self.resetbuffer()
2148 self.resetbuffer()
2145 lines = lines.split('\n')
2149 lines = lines.split('\n')
2146 more = 0
2150 more = 0
2147
2151
2148 for line in lines:
2152 for line in lines:
2149 # skip blank lines so we don't mess up the prompt counter, but do
2153 # skip blank lines so we don't mess up the prompt counter, but do
2150 # NOT skip even a blank line if we are in a code block (more is
2154 # NOT skip even a blank line if we are in a code block (more is
2151 # true)
2155 # true)
2152
2156
2153 if line or more:
2157 if line or more:
2154 # push to raw history, so hist line numbers stay in sync
2158 # push to raw history, so hist line numbers stay in sync
2155 self.input_hist_raw.append("# " + line + "\n")
2159 self.input_hist_raw.append("# " + line + "\n")
2156 more = self.push(self.prefilter(line,more))
2160 more = self.push(self.prefilter(line,more))
2157 # IPython's runsource returns None if there was an error
2161 # IPython's runsource returns None if there was an error
2158 # compiling the code. This allows us to stop processing right
2162 # compiling the code. This allows us to stop processing right
2159 # away, so the user gets the error message at the right place.
2163 # away, so the user gets the error message at the right place.
2160 if more is None:
2164 if more is None:
2161 break
2165 break
2162 else:
2166 else:
2163 self.input_hist_raw.append("\n")
2167 self.input_hist_raw.append("\n")
2164 # final newline in case the input didn't have it, so that the code
2168 # final newline in case the input didn't have it, so that the code
2165 # actually does get executed
2169 # actually does get executed
2166 if more:
2170 if more:
2167 self.push('\n')
2171 self.push('\n')
2168
2172
2169 def runsource(self, source, filename='<input>', symbol='single'):
2173 def runsource(self, source, filename='<input>', symbol='single'):
2170 """Compile and run some source in the interpreter.
2174 """Compile and run some source in the interpreter.
2171
2175
2172 Arguments are as for compile_command().
2176 Arguments are as for compile_command().
2173
2177
2174 One several things can happen:
2178 One several things can happen:
2175
2179
2176 1) The input is incorrect; compile_command() raised an
2180 1) The input is incorrect; compile_command() raised an
2177 exception (SyntaxError or OverflowError). A syntax traceback
2181 exception (SyntaxError or OverflowError). A syntax traceback
2178 will be printed by calling the showsyntaxerror() method.
2182 will be printed by calling the showsyntaxerror() method.
2179
2183
2180 2) The input is incomplete, and more input is required;
2184 2) The input is incomplete, and more input is required;
2181 compile_command() returned None. Nothing happens.
2185 compile_command() returned None. Nothing happens.
2182
2186
2183 3) The input is complete; compile_command() returned a code
2187 3) The input is complete; compile_command() returned a code
2184 object. The code is executed by calling self.runcode() (which
2188 object. The code is executed by calling self.runcode() (which
2185 also handles run-time exceptions, except for SystemExit).
2189 also handles run-time exceptions, except for SystemExit).
2186
2190
2187 The return value is:
2191 The return value is:
2188
2192
2189 - True in case 2
2193 - True in case 2
2190
2194
2191 - False in the other cases, unless an exception is raised, where
2195 - False in the other cases, unless an exception is raised, where
2192 None is returned instead. This can be used by external callers to
2196 None is returned instead. This can be used by external callers to
2193 know whether to continue feeding input or not.
2197 know whether to continue feeding input or not.
2194
2198
2195 The return value can be used to decide whether to use sys.ps1 or
2199 The return value can be used to decide whether to use sys.ps1 or
2196 sys.ps2 to prompt the next line."""
2200 sys.ps2 to prompt the next line."""
2197
2201
2198 # if the source code has leading blanks, add 'if 1:\n' to it
2202 # if the source code has leading blanks, add 'if 1:\n' to it
2199 # this allows execution of indented pasted code. It is tempting
2203 # this allows execution of indented pasted code. It is tempting
2200 # to add '\n' at the end of source to run commands like ' a=1'
2204 # to add '\n' at the end of source to run commands like ' a=1'
2201 # directly, but this fails for more complicated scenarios
2205 # directly, but this fails for more complicated scenarios
2202 source=source.encode(self.stdin_encoding)
2206 source=source.encode(self.stdin_encoding)
2203 if source[:1] in [' ', '\t']:
2207 if source[:1] in [' ', '\t']:
2204 source = 'if 1:\n%s' % source
2208 source = 'if 1:\n%s' % source
2205
2209
2206 try:
2210 try:
2207 code = self.compile(source,filename,symbol)
2211 code = self.compile(source,filename,symbol)
2208 except (OverflowError, SyntaxError, ValueError, TypeError):
2212 except (OverflowError, SyntaxError, ValueError, TypeError):
2209 # Case 1
2213 # Case 1
2210 self.showsyntaxerror(filename)
2214 self.showsyntaxerror(filename)
2211 return None
2215 return None
2212
2216
2213 if code is None:
2217 if code is None:
2214 # Case 2
2218 # Case 2
2215 return True
2219 return True
2216
2220
2217 # Case 3
2221 # Case 3
2218 # We store the code object so that threaded shells and
2222 # We store the code object so that threaded shells and
2219 # custom exception handlers can access all this info if needed.
2223 # custom exception handlers can access all this info if needed.
2220 # The source corresponding to this can be obtained from the
2224 # The source corresponding to this can be obtained from the
2221 # buffer attribute as '\n'.join(self.buffer).
2225 # buffer attribute as '\n'.join(self.buffer).
2222 self.code_to_run = code
2226 self.code_to_run = code
2223 # now actually execute the code object
2227 # now actually execute the code object
2224 if self.runcode(code) == 0:
2228 if self.runcode(code) == 0:
2225 return False
2229 return False
2226 else:
2230 else:
2227 return None
2231 return None
2228
2232
2229 def runcode(self,code_obj):
2233 def runcode(self,code_obj):
2230 """Execute a code object.
2234 """Execute a code object.
2231
2235
2232 When an exception occurs, self.showtraceback() is called to display a
2236 When an exception occurs, self.showtraceback() is called to display a
2233 traceback.
2237 traceback.
2234
2238
2235 Return value: a flag indicating whether the code to be run completed
2239 Return value: a flag indicating whether the code to be run completed
2236 successfully:
2240 successfully:
2237
2241
2238 - 0: successful execution.
2242 - 0: successful execution.
2239 - 1: an error occurred.
2243 - 1: an error occurred.
2240 """
2244 """
2241
2245
2242 # Set our own excepthook in case the user code tries to call it
2246 # Set our own excepthook in case the user code tries to call it
2243 # directly, so that the IPython crash handler doesn't get triggered
2247 # directly, so that the IPython crash handler doesn't get triggered
2244 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2248 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2245
2249
2246 # we save the original sys.excepthook in the instance, in case config
2250 # we save the original sys.excepthook in the instance, in case config
2247 # code (such as magics) needs access to it.
2251 # code (such as magics) needs access to it.
2248 self.sys_excepthook = old_excepthook
2252 self.sys_excepthook = old_excepthook
2249 outflag = 1 # happens in more places, so it's easier as default
2253 outflag = 1 # happens in more places, so it's easier as default
2250 try:
2254 try:
2251 try:
2255 try:
2252 self.hooks.pre_runcode_hook()
2256 self.hooks.pre_runcode_hook()
2253 exec code_obj in self.user_global_ns, self.user_ns
2257 exec code_obj in self.user_global_ns, self.user_ns
2254 finally:
2258 finally:
2255 # Reset our crash handler in place
2259 # Reset our crash handler in place
2256 sys.excepthook = old_excepthook
2260 sys.excepthook = old_excepthook
2257 except SystemExit:
2261 except SystemExit:
2258 self.resetbuffer()
2262 self.resetbuffer()
2259 self.showtraceback()
2263 self.showtraceback()
2260 warn("Type %exit or %quit to exit IPython "
2264 warn("Type %exit or %quit to exit IPython "
2261 "(%Exit or %Quit do so unconditionally).",level=1)
2265 "(%Exit or %Quit do so unconditionally).",level=1)
2262 except self.custom_exceptions:
2266 except self.custom_exceptions:
2263 etype,value,tb = sys.exc_info()
2267 etype,value,tb = sys.exc_info()
2264 self.CustomTB(etype,value,tb)
2268 self.CustomTB(etype,value,tb)
2265 except:
2269 except:
2266 self.showtraceback()
2270 self.showtraceback()
2267 else:
2271 else:
2268 outflag = 0
2272 outflag = 0
2269 if softspace(sys.stdout, 0):
2273 if softspace(sys.stdout, 0):
2270 print
2274 print
2271 # Flush out code object which has been run (and source)
2275 # Flush out code object which has been run (and source)
2272 self.code_to_run = None
2276 self.code_to_run = None
2273 return outflag
2277 return outflag
2274
2278
2275 def push(self, line):
2279 def push(self, line):
2276 """Push a line to the interpreter.
2280 """Push a line to the interpreter.
2277
2281
2278 The line should not have a trailing newline; it may have
2282 The line should not have a trailing newline; it may have
2279 internal newlines. The line is appended to a buffer and the
2283 internal newlines. The line is appended to a buffer and the
2280 interpreter's runsource() method is called with the
2284 interpreter's runsource() method is called with the
2281 concatenated contents of the buffer as source. If this
2285 concatenated contents of the buffer as source. If this
2282 indicates that the command was executed or invalid, the buffer
2286 indicates that the command was executed or invalid, the buffer
2283 is reset; otherwise, the command is incomplete, and the buffer
2287 is reset; otherwise, the command is incomplete, and the buffer
2284 is left as it was after the line was appended. The return
2288 is left as it was after the line was appended. The return
2285 value is 1 if more input is required, 0 if the line was dealt
2289 value is 1 if more input is required, 0 if the line was dealt
2286 with in some way (this is the same as runsource()).
2290 with in some way (this is the same as runsource()).
2287 """
2291 """
2288
2292
2289 # autoindent management should be done here, and not in the
2293 # autoindent management should be done here, and not in the
2290 # interactive loop, since that one is only seen by keyboard input. We
2294 # interactive loop, since that one is only seen by keyboard input. We
2291 # need this done correctly even for code run via runlines (which uses
2295 # need this done correctly even for code run via runlines (which uses
2292 # push).
2296 # push).
2293
2297
2294 #print 'push line: <%s>' % line # dbg
2298 #print 'push line: <%s>' % line # dbg
2295 for subline in line.splitlines():
2299 for subline in line.splitlines():
2296 self.autoindent_update(subline)
2300 self.autoindent_update(subline)
2297 self.buffer.append(line)
2301 self.buffer.append(line)
2298 more = self.runsource('\n'.join(self.buffer), self.filename)
2302 more = self.runsource('\n'.join(self.buffer), self.filename)
2299 if not more:
2303 if not more:
2300 self.resetbuffer()
2304 self.resetbuffer()
2301 return more
2305 return more
2302
2306
2303 def split_user_input(self, line):
2307 def split_user_input(self, line):
2304 # This is really a hold-over to support ipapi and some extensions
2308 # This is really a hold-over to support ipapi and some extensions
2305 return prefilter.splitUserInput(line)
2309 return prefilter.splitUserInput(line)
2306
2310
2307 def resetbuffer(self):
2311 def resetbuffer(self):
2308 """Reset the input buffer."""
2312 """Reset the input buffer."""
2309 self.buffer[:] = []
2313 self.buffer[:] = []
2310
2314
2311 def raw_input(self,prompt='',continue_prompt=False):
2315 def raw_input(self,prompt='',continue_prompt=False):
2312 """Write a prompt and read a line.
2316 """Write a prompt and read a line.
2313
2317
2314 The returned line does not include the trailing newline.
2318 The returned line does not include the trailing newline.
2315 When the user enters the EOF key sequence, EOFError is raised.
2319 When the user enters the EOF key sequence, EOFError is raised.
2316
2320
2317 Optional inputs:
2321 Optional inputs:
2318
2322
2319 - prompt(''): a string to be printed to prompt the user.
2323 - prompt(''): a string to be printed to prompt the user.
2320
2324
2321 - continue_prompt(False): whether this line is the first one or a
2325 - continue_prompt(False): whether this line is the first one or a
2322 continuation in a sequence of inputs.
2326 continuation in a sequence of inputs.
2323 """
2327 """
2324
2328
2325 # Code run by the user may have modified the readline completer state.
2329 # Code run by the user may have modified the readline completer state.
2326 # We must ensure that our completer is back in place.
2330 # We must ensure that our completer is back in place.
2327 if self.has_readline:
2331 if self.has_readline:
2328 self.set_completer()
2332 self.set_completer()
2329
2333
2330 try:
2334 try:
2331 line = raw_input_original(prompt).decode(self.stdin_encoding)
2335 line = raw_input_original(prompt).decode(self.stdin_encoding)
2332 except ValueError:
2336 except ValueError:
2333 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
2337 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
2334 " or sys.stdout.close()!\nExiting IPython!")
2338 " or sys.stdout.close()!\nExiting IPython!")
2335 self.ask_exit()
2339 self.ask_exit()
2336 return ""
2340 return ""
2337
2341
2338 # Try to be reasonably smart about not re-indenting pasted input more
2342 # Try to be reasonably smart about not re-indenting pasted input more
2339 # than necessary. We do this by trimming out the auto-indent initial
2343 # than necessary. We do this by trimming out the auto-indent initial
2340 # spaces, if the user's actual input started itself with whitespace.
2344 # spaces, if the user's actual input started itself with whitespace.
2341 #debugx('self.buffer[-1]')
2345 #debugx('self.buffer[-1]')
2342
2346
2343 if self.autoindent:
2347 if self.autoindent:
2344 if num_ini_spaces(line) > self.indent_current_nsp:
2348 if num_ini_spaces(line) > self.indent_current_nsp:
2345 line = line[self.indent_current_nsp:]
2349 line = line[self.indent_current_nsp:]
2346 self.indent_current_nsp = 0
2350 self.indent_current_nsp = 0
2347
2351
2348 # store the unfiltered input before the user has any chance to modify
2352 # store the unfiltered input before the user has any chance to modify
2349 # it.
2353 # it.
2350 if line.strip():
2354 if line.strip():
2351 if continue_prompt:
2355 if continue_prompt:
2352 self.input_hist_raw[-1] += '%s\n' % line
2356 self.input_hist_raw[-1] += '%s\n' % line
2353 if self.has_readline: # and some config option is set?
2357 if self.has_readline: # and some config option is set?
2354 try:
2358 try:
2355 histlen = self.readline.get_current_history_length()
2359 histlen = self.readline.get_current_history_length()
2356 if histlen > 1:
2360 if histlen > 1:
2357 newhist = self.input_hist_raw[-1].rstrip()
2361 newhist = self.input_hist_raw[-1].rstrip()
2358 self.readline.remove_history_item(histlen-1)
2362 self.readline.remove_history_item(histlen-1)
2359 self.readline.replace_history_item(histlen-2,
2363 self.readline.replace_history_item(histlen-2,
2360 newhist.encode(self.stdin_encoding))
2364 newhist.encode(self.stdin_encoding))
2361 except AttributeError:
2365 except AttributeError:
2362 pass # re{move,place}_history_item are new in 2.4.
2366 pass # re{move,place}_history_item are new in 2.4.
2363 else:
2367 else:
2364 self.input_hist_raw.append('%s\n' % line)
2368 self.input_hist_raw.append('%s\n' % line)
2365 # only entries starting at first column go to shadow history
2369 # only entries starting at first column go to shadow history
2366 if line.lstrip() == line:
2370 if line.lstrip() == line:
2367 self.shadowhist.add(line.strip())
2371 self.shadowhist.add(line.strip())
2368 elif not continue_prompt:
2372 elif not continue_prompt:
2369 self.input_hist_raw.append('\n')
2373 self.input_hist_raw.append('\n')
2370 try:
2374 try:
2371 lineout = self.prefilter(line,continue_prompt)
2375 lineout = self.prefilter(line,continue_prompt)
2372 except:
2376 except:
2373 # blanket except, in case a user-defined prefilter crashes, so it
2377 # blanket except, in case a user-defined prefilter crashes, so it
2374 # can't take all of ipython with it.
2378 # can't take all of ipython with it.
2375 self.showtraceback()
2379 self.showtraceback()
2376 return ''
2380 return ''
2377 else:
2381 else:
2378 return lineout
2382 return lineout
2379
2383
2380 def _prefilter(self, line, continue_prompt):
2384 def _prefilter(self, line, continue_prompt):
2381 """Calls different preprocessors, depending on the form of line."""
2385 """Calls different preprocessors, depending on the form of line."""
2382
2386
2383 # All handlers *must* return a value, even if it's blank ('').
2387 # All handlers *must* return a value, even if it's blank ('').
2384
2388
2385 # Lines are NOT logged here. Handlers should process the line as
2389 # Lines are NOT logged here. Handlers should process the line as
2386 # needed, update the cache AND log it (so that the input cache array
2390 # needed, update the cache AND log it (so that the input cache array
2387 # stays synced).
2391 # stays synced).
2388
2392
2389 #.....................................................................
2393 #.....................................................................
2390 # Code begins
2394 # Code begins
2391
2395
2392 #if line.startswith('%crash'): raise RuntimeError,'Crash now!' # dbg
2396 #if line.startswith('%crash'): raise RuntimeError,'Crash now!' # dbg
2393
2397
2394 # save the line away in case we crash, so the post-mortem handler can
2398 # save the line away in case we crash, so the post-mortem handler can
2395 # record it
2399 # record it
2396 self._last_input_line = line
2400 self._last_input_line = line
2397
2401
2398 #print '***line: <%s>' % line # dbg
2402 #print '***line: <%s>' % line # dbg
2399
2403
2400 if not line:
2404 if not line:
2401 # Return immediately on purely empty lines, so that if the user
2405 # Return immediately on purely empty lines, so that if the user
2402 # previously typed some whitespace that started a continuation
2406 # previously typed some whitespace that started a continuation
2403 # prompt, he can break out of that loop with just an empty line.
2407 # prompt, he can break out of that loop with just an empty line.
2404 # This is how the default python prompt works.
2408 # This is how the default python prompt works.
2405
2409
2406 # Only return if the accumulated input buffer was just whitespace!
2410 # Only return if the accumulated input buffer was just whitespace!
2407 if ''.join(self.buffer).isspace():
2411 if ''.join(self.buffer).isspace():
2408 self.buffer[:] = []
2412 self.buffer[:] = []
2409 return ''
2413 return ''
2410
2414
2411 line_info = prefilter.LineInfo(line, continue_prompt)
2415 line_info = prefilter.LineInfo(line, continue_prompt)
2412
2416
2413 # the input history needs to track even empty lines
2417 # the input history needs to track even empty lines
2414 stripped = line.strip()
2418 stripped = line.strip()
2415
2419
2416 if not stripped:
2420 if not stripped:
2417 if not continue_prompt:
2421 if not continue_prompt:
2418 self.outputcache.prompt_count -= 1
2422 self.outputcache.prompt_count -= 1
2419 return self.handle_normal(line_info)
2423 return self.handle_normal(line_info)
2420
2424
2421 # print '***cont',continue_prompt # dbg
2425 # print '***cont',continue_prompt # dbg
2422 # special handlers are only allowed for single line statements
2426 # special handlers are only allowed for single line statements
2423 if continue_prompt and not self.rc.multi_line_specials:
2427 if continue_prompt and not self.rc.multi_line_specials:
2424 return self.handle_normal(line_info)
2428 return self.handle_normal(line_info)
2425
2429
2426
2430
2427 # See whether any pre-existing handler can take care of it
2431 # See whether any pre-existing handler can take care of it
2428 rewritten = self.hooks.input_prefilter(stripped)
2432 rewritten = self.hooks.input_prefilter(stripped)
2429 if rewritten != stripped: # ok, some prefilter did something
2433 if rewritten != stripped: # ok, some prefilter did something
2430 rewritten = line_info.pre + rewritten # add indentation
2434 rewritten = line_info.pre + rewritten # add indentation
2431 return self.handle_normal(prefilter.LineInfo(rewritten,
2435 return self.handle_normal(prefilter.LineInfo(rewritten,
2432 continue_prompt))
2436 continue_prompt))
2433
2437
2434 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2438 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2435
2439
2436 return prefilter.prefilter(line_info, self)
2440 return prefilter.prefilter(line_info, self)
2437
2441
2438
2442
2439 def _prefilter_dumb(self, line, continue_prompt):
2443 def _prefilter_dumb(self, line, continue_prompt):
2440 """simple prefilter function, for debugging"""
2444 """simple prefilter function, for debugging"""
2441 return self.handle_normal(line,continue_prompt)
2445 return self.handle_normal(line,continue_prompt)
2442
2446
2443
2447
2444 def multiline_prefilter(self, line, continue_prompt):
2448 def multiline_prefilter(self, line, continue_prompt):
2445 """ Run _prefilter for each line of input
2449 """ Run _prefilter for each line of input
2446
2450
2447 Covers cases where there are multiple lines in the user entry,
2451 Covers cases where there are multiple lines in the user entry,
2448 which is the case when the user goes back to a multiline history
2452 which is the case when the user goes back to a multiline history
2449 entry and presses enter.
2453 entry and presses enter.
2450
2454
2451 """
2455 """
2452 out = []
2456 out = []
2453 for l in line.rstrip('\n').split('\n'):
2457 for l in line.rstrip('\n').split('\n'):
2454 out.append(self._prefilter(l, continue_prompt))
2458 out.append(self._prefilter(l, continue_prompt))
2455 return '\n'.join(out)
2459 return '\n'.join(out)
2456
2460
2457 # Set the default prefilter() function (this can be user-overridden)
2461 # Set the default prefilter() function (this can be user-overridden)
2458 prefilter = multiline_prefilter
2462 prefilter = multiline_prefilter
2459
2463
2460 def handle_normal(self,line_info):
2464 def handle_normal(self,line_info):
2461 """Handle normal input lines. Use as a template for handlers."""
2465 """Handle normal input lines. Use as a template for handlers."""
2462
2466
2463 # With autoindent on, we need some way to exit the input loop, and I
2467 # With autoindent on, we need some way to exit the input loop, and I
2464 # don't want to force the user to have to backspace all the way to
2468 # don't want to force the user to have to backspace all the way to
2465 # clear the line. The rule will be in this case, that either two
2469 # clear the line. The rule will be in this case, that either two
2466 # lines of pure whitespace in a row, or a line of pure whitespace but
2470 # lines of pure whitespace in a row, or a line of pure whitespace but
2467 # of a size different to the indent level, will exit the input loop.
2471 # of a size different to the indent level, will exit the input loop.
2468 line = line_info.line
2472 line = line_info.line
2469 continue_prompt = line_info.continue_prompt
2473 continue_prompt = line_info.continue_prompt
2470
2474
2471 if (continue_prompt and self.autoindent and line.isspace() and
2475 if (continue_prompt and self.autoindent and line.isspace() and
2472 (0 < abs(len(line) - self.indent_current_nsp) <= 2 or
2476 (0 < abs(len(line) - self.indent_current_nsp) <= 2 or
2473 (self.buffer[-1]).isspace() )):
2477 (self.buffer[-1]).isspace() )):
2474 line = ''
2478 line = ''
2475
2479
2476 self.log(line,line,continue_prompt)
2480 self.log(line,line,continue_prompt)
2477 return line
2481 return line
2478
2482
2479 def handle_alias(self,line_info):
2483 def handle_alias(self,line_info):
2480 """Handle alias input lines. """
2484 """Handle alias input lines. """
2481 tgt = self.alias_table[line_info.iFun]
2485 tgt = self.alias_table[line_info.iFun]
2482 # print "=>",tgt #dbg
2486 # print "=>",tgt #dbg
2483 if callable(tgt):
2487 if callable(tgt):
2484 if '$' in line_info.line:
2488 if '$' in line_info.line:
2485 call_meth = '(_ip, _ip.itpl(%s))'
2489 call_meth = '(_ip, _ip.itpl(%s))'
2486 else:
2490 else:
2487 call_meth = '(_ip,%s)'
2491 call_meth = '(_ip,%s)'
2488 line_out = ("%s_sh.%s" + call_meth) % (line_info.preWhitespace,
2492 line_out = ("%s_sh.%s" + call_meth) % (line_info.preWhitespace,
2489 line_info.iFun,
2493 line_info.iFun,
2490 make_quoted_expr(line_info.line))
2494 make_quoted_expr(line_info.line))
2491 else:
2495 else:
2492 transformed = self.expand_aliases(line_info.iFun,line_info.theRest)
2496 transformed = self.expand_aliases(line_info.iFun,line_info.theRest)
2493
2497
2494 # pre is needed, because it carries the leading whitespace. Otherwise
2498 # pre is needed, because it carries the leading whitespace. Otherwise
2495 # aliases won't work in indented sections.
2499 # aliases won't work in indented sections.
2496 line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
2500 line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
2497 make_quoted_expr( transformed ))
2501 make_quoted_expr( transformed ))
2498
2502
2499 self.log(line_info.line,line_out,line_info.continue_prompt)
2503 self.log(line_info.line,line_out,line_info.continue_prompt)
2500 #print 'line out:',line_out # dbg
2504 #print 'line out:',line_out # dbg
2501 return line_out
2505 return line_out
2502
2506
2503 def handle_shell_escape(self, line_info):
2507 def handle_shell_escape(self, line_info):
2504 """Execute the line in a shell, empty return value"""
2508 """Execute the line in a shell, empty return value"""
2505 #print 'line in :', `line` # dbg
2509 #print 'line in :', `line` # dbg
2506 line = line_info.line
2510 line = line_info.line
2507 if line.lstrip().startswith('!!'):
2511 if line.lstrip().startswith('!!'):
2508 # rewrite LineInfo's line, iFun and theRest to properly hold the
2512 # rewrite LineInfo's line, iFun and theRest to properly hold the
2509 # call to %sx and the actual command to be executed, so
2513 # call to %sx and the actual command to be executed, so
2510 # handle_magic can work correctly. Note that this works even if
2514 # handle_magic can work correctly. Note that this works even if
2511 # the line is indented, so it handles multi_line_specials
2515 # the line is indented, so it handles multi_line_specials
2512 # properly.
2516 # properly.
2513 new_rest = line.lstrip()[2:]
2517 new_rest = line.lstrip()[2:]
2514 line_info.line = '%ssx %s' % (self.ESC_MAGIC,new_rest)
2518 line_info.line = '%ssx %s' % (self.ESC_MAGIC,new_rest)
2515 line_info.iFun = 'sx'
2519 line_info.iFun = 'sx'
2516 line_info.theRest = new_rest
2520 line_info.theRest = new_rest
2517 return self.handle_magic(line_info)
2521 return self.handle_magic(line_info)
2518 else:
2522 else:
2519 cmd = line.lstrip().lstrip('!')
2523 cmd = line.lstrip().lstrip('!')
2520 line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
2524 line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
2521 make_quoted_expr(cmd))
2525 make_quoted_expr(cmd))
2522 # update cache/log and return
2526 # update cache/log and return
2523 self.log(line,line_out,line_info.continue_prompt)
2527 self.log(line,line_out,line_info.continue_prompt)
2524 return line_out
2528 return line_out
2525
2529
2526 def handle_magic(self, line_info):
2530 def handle_magic(self, line_info):
2527 """Execute magic functions."""
2531 """Execute magic functions."""
2528 iFun = line_info.iFun
2532 iFun = line_info.iFun
2529 theRest = line_info.theRest
2533 theRest = line_info.theRest
2530 cmd = '%s_ip.magic(%s)' % (line_info.preWhitespace,
2534 cmd = '%s_ip.magic(%s)' % (line_info.preWhitespace,
2531 make_quoted_expr(iFun + " " + theRest))
2535 make_quoted_expr(iFun + " " + theRest))
2532 self.log(line_info.line,cmd,line_info.continue_prompt)
2536 self.log(line_info.line,cmd,line_info.continue_prompt)
2533 #print 'in handle_magic, cmd=<%s>' % cmd # dbg
2537 #print 'in handle_magic, cmd=<%s>' % cmd # dbg
2534 return cmd
2538 return cmd
2535
2539
2536 def handle_auto(self, line_info):
2540 def handle_auto(self, line_info):
2537 """Hande lines which can be auto-executed, quoting if requested."""
2541 """Hande lines which can be auto-executed, quoting if requested."""
2538
2542
2539 line = line_info.line
2543 line = line_info.line
2540 iFun = line_info.iFun
2544 iFun = line_info.iFun
2541 theRest = line_info.theRest
2545 theRest = line_info.theRest
2542 pre = line_info.pre
2546 pre = line_info.pre
2543 continue_prompt = line_info.continue_prompt
2547 continue_prompt = line_info.continue_prompt
2544 obj = line_info.ofind(self)['obj']
2548 obj = line_info.ofind(self)['obj']
2545
2549
2546 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2550 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2547
2551
2548 # This should only be active for single-line input!
2552 # This should only be active for single-line input!
2549 if continue_prompt:
2553 if continue_prompt:
2550 self.log(line,line,continue_prompt)
2554 self.log(line,line,continue_prompt)
2551 return line
2555 return line
2552
2556
2553 force_auto = isinstance(obj, IPython.ipapi.IPyAutocall)
2557 force_auto = isinstance(obj, IPython.ipapi.IPyAutocall)
2554 auto_rewrite = True
2558 auto_rewrite = True
2555
2559
2556 if pre == self.ESC_QUOTE:
2560 if pre == self.ESC_QUOTE:
2557 # Auto-quote splitting on whitespace
2561 # Auto-quote splitting on whitespace
2558 newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) )
2562 newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) )
2559 elif pre == self.ESC_QUOTE2:
2563 elif pre == self.ESC_QUOTE2:
2560 # Auto-quote whole string
2564 # Auto-quote whole string
2561 newcmd = '%s("%s")' % (iFun,theRest)
2565 newcmd = '%s("%s")' % (iFun,theRest)
2562 elif pre == self.ESC_PAREN:
2566 elif pre == self.ESC_PAREN:
2563 newcmd = '%s(%s)' % (iFun,",".join(theRest.split()))
2567 newcmd = '%s(%s)' % (iFun,",".join(theRest.split()))
2564 else:
2568 else:
2565 # Auto-paren.
2569 # Auto-paren.
2566 # We only apply it to argument-less calls if the autocall
2570 # We only apply it to argument-less calls if the autocall
2567 # parameter is set to 2. We only need to check that autocall is <
2571 # parameter is set to 2. We only need to check that autocall is <
2568 # 2, since this function isn't called unless it's at least 1.
2572 # 2, since this function isn't called unless it's at least 1.
2569 if not theRest and (self.rc.autocall < 2) and not force_auto:
2573 if not theRest and (self.rc.autocall < 2) and not force_auto:
2570 newcmd = '%s %s' % (iFun,theRest)
2574 newcmd = '%s %s' % (iFun,theRest)
2571 auto_rewrite = False
2575 auto_rewrite = False
2572 else:
2576 else:
2573 if not force_auto and theRest.startswith('['):
2577 if not force_auto and theRest.startswith('['):
2574 if hasattr(obj,'__getitem__'):
2578 if hasattr(obj,'__getitem__'):
2575 # Don't autocall in this case: item access for an object
2579 # Don't autocall in this case: item access for an object
2576 # which is BOTH callable and implements __getitem__.
2580 # which is BOTH callable and implements __getitem__.
2577 newcmd = '%s %s' % (iFun,theRest)
2581 newcmd = '%s %s' % (iFun,theRest)
2578 auto_rewrite = False
2582 auto_rewrite = False
2579 else:
2583 else:
2580 # if the object doesn't support [] access, go ahead and
2584 # if the object doesn't support [] access, go ahead and
2581 # autocall
2585 # autocall
2582 newcmd = '%s(%s)' % (iFun.rstrip(),theRest)
2586 newcmd = '%s(%s)' % (iFun.rstrip(),theRest)
2583 elif theRest.endswith(';'):
2587 elif theRest.endswith(';'):
2584 newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1])
2588 newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1])
2585 else:
2589 else:
2586 newcmd = '%s(%s)' % (iFun.rstrip(), theRest)
2590 newcmd = '%s(%s)' % (iFun.rstrip(), theRest)
2587
2591
2588 if auto_rewrite:
2592 if auto_rewrite:
2589 rw = self.outputcache.prompt1.auto_rewrite() + newcmd
2593 rw = self.outputcache.prompt1.auto_rewrite() + newcmd
2590
2594
2591 try:
2595 try:
2592 # plain ascii works better w/ pyreadline, on some machines, so
2596 # plain ascii works better w/ pyreadline, on some machines, so
2593 # we use it and only print uncolored rewrite if we have unicode
2597 # we use it and only print uncolored rewrite if we have unicode
2594 rw = str(rw)
2598 rw = str(rw)
2595 print >>Term.cout, rw
2599 print >>Term.cout, rw
2596 except UnicodeEncodeError:
2600 except UnicodeEncodeError:
2597 print "-------------->" + newcmd
2601 print "-------------->" + newcmd
2598
2602
2599 # log what is now valid Python, not the actual user input (without the
2603 # log what is now valid Python, not the actual user input (without the
2600 # final newline)
2604 # final newline)
2601 self.log(line,newcmd,continue_prompt)
2605 self.log(line,newcmd,continue_prompt)
2602 return newcmd
2606 return newcmd
2603
2607
2604 def handle_help(self, line_info):
2608 def handle_help(self, line_info):
2605 """Try to get some help for the object.
2609 """Try to get some help for the object.
2606
2610
2607 obj? or ?obj -> basic information.
2611 obj? or ?obj -> basic information.
2608 obj?? or ??obj -> more details.
2612 obj?? or ??obj -> more details.
2609 """
2613 """
2610
2614
2611 line = line_info.line
2615 line = line_info.line
2612 # We need to make sure that we don't process lines which would be
2616 # We need to make sure that we don't process lines which would be
2613 # otherwise valid python, such as "x=1 # what?"
2617 # otherwise valid python, such as "x=1 # what?"
2614 try:
2618 try:
2615 codeop.compile_command(line)
2619 codeop.compile_command(line)
2616 except SyntaxError:
2620 except SyntaxError:
2617 # We should only handle as help stuff which is NOT valid syntax
2621 # We should only handle as help stuff which is NOT valid syntax
2618 if line[0]==self.ESC_HELP:
2622 if line[0]==self.ESC_HELP:
2619 line = line[1:]
2623 line = line[1:]
2620 elif line[-1]==self.ESC_HELP:
2624 elif line[-1]==self.ESC_HELP:
2621 line = line[:-1]
2625 line = line[:-1]
2622 self.log(line,'#?'+line,line_info.continue_prompt)
2626 self.log(line,'#?'+line,line_info.continue_prompt)
2623 if line:
2627 if line:
2624 #print 'line:<%r>' % line # dbg
2628 #print 'line:<%r>' % line # dbg
2625 self.magic_pinfo(line)
2629 self.magic_pinfo(line)
2626 else:
2630 else:
2627 page(self.usage,screen_lines=self.rc.screen_length)
2631 page(self.usage,screen_lines=self.rc.screen_length)
2628 return '' # Empty string is needed here!
2632 return '' # Empty string is needed here!
2629 except:
2633 except:
2630 # Pass any other exceptions through to the normal handler
2634 # Pass any other exceptions through to the normal handler
2631 return self.handle_normal(line_info)
2635 return self.handle_normal(line_info)
2632 else:
2636 else:
2633 # If the code compiles ok, we should handle it normally
2637 # If the code compiles ok, we should handle it normally
2634 return self.handle_normal(line_info)
2638 return self.handle_normal(line_info)
2635
2639
2636 def getapi(self):
2640 def getapi(self):
2637 """ Get an IPApi object for this shell instance
2641 """ Get an IPApi object for this shell instance
2638
2642
2639 Getting an IPApi object is always preferable to accessing the shell
2643 Getting an IPApi object is always preferable to accessing the shell
2640 directly, but this holds true especially for extensions.
2644 directly, but this holds true especially for extensions.
2641
2645
2642 It should always be possible to implement an extension with IPApi
2646 It should always be possible to implement an extension with IPApi
2643 alone. If not, contact maintainer to request an addition.
2647 alone. If not, contact maintainer to request an addition.
2644
2648
2645 """
2649 """
2646 return self.api
2650 return self.api
2647
2651
2648 def handle_emacs(self, line_info):
2652 def handle_emacs(self, line_info):
2649 """Handle input lines marked by python-mode."""
2653 """Handle input lines marked by python-mode."""
2650
2654
2651 # Currently, nothing is done. Later more functionality can be added
2655 # Currently, nothing is done. Later more functionality can be added
2652 # here if needed.
2656 # here if needed.
2653
2657
2654 # The input cache shouldn't be updated
2658 # The input cache shouldn't be updated
2655 return line_info.line
2659 return line_info.line
2656
2660
2657
2661
2658 def mktempfile(self,data=None):
2662 def mktempfile(self,data=None):
2659 """Make a new tempfile and return its filename.
2663 """Make a new tempfile and return its filename.
2660
2664
2661 This makes a call to tempfile.mktemp, but it registers the created
2665 This makes a call to tempfile.mktemp, but it registers the created
2662 filename internally so ipython cleans it up at exit time.
2666 filename internally so ipython cleans it up at exit time.
2663
2667
2664 Optional inputs:
2668 Optional inputs:
2665
2669
2666 - data(None): if data is given, it gets written out to the temp file
2670 - data(None): if data is given, it gets written out to the temp file
2667 immediately, and the file is closed again."""
2671 immediately, and the file is closed again."""
2668
2672
2669 filename = tempfile.mktemp('.py','ipython_edit_')
2673 filename = tempfile.mktemp('.py','ipython_edit_')
2670 self.tempfiles.append(filename)
2674 self.tempfiles.append(filename)
2671
2675
2672 if data:
2676 if data:
2673 tmp_file = open(filename,'w')
2677 tmp_file = open(filename,'w')
2674 tmp_file.write(data)
2678 tmp_file.write(data)
2675 tmp_file.close()
2679 tmp_file.close()
2676 return filename
2680 return filename
2677
2681
2678 def write(self,data):
2682 def write(self,data):
2679 """Write a string to the default output"""
2683 """Write a string to the default output"""
2680 Term.cout.write(data)
2684 Term.cout.write(data)
2681
2685
2682 def write_err(self,data):
2686 def write_err(self,data):
2683 """Write a string to the default error output"""
2687 """Write a string to the default error output"""
2684 Term.cerr.write(data)
2688 Term.cerr.write(data)
2685
2689
2686 def ask_exit(self):
2690 def ask_exit(self):
2687 """ Call for exiting. Can be overiden and used as a callback. """
2691 """ Call for exiting. Can be overiden and used as a callback. """
2688 self.exit_now = True
2692 self.exit_now = True
2689
2693
2690 def exit(self):
2694 def exit(self):
2691 """Handle interactive exit.
2695 """Handle interactive exit.
2692
2696
2693 This method calls the ask_exit callback."""
2697 This method calls the ask_exit callback."""
2694
2698
2695 if self.rc.confirm_exit:
2699 if self.rc.confirm_exit:
2696 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
2700 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
2697 self.ask_exit()
2701 self.ask_exit()
2698 else:
2702 else:
2699 self.ask_exit()
2703 self.ask_exit()
2700
2704
2701 def safe_execfile(self,fname,*where,**kw):
2705 def safe_execfile(self,fname,*where,**kw):
2702 """A safe version of the builtin execfile().
2706 """A safe version of the builtin execfile().
2703
2707
2704 This version will never throw an exception, and knows how to handle
2708 This version will never throw an exception, and knows how to handle
2705 ipython logs as well.
2709 ipython logs as well.
2706
2710
2707 :Parameters:
2711 :Parameters:
2708 fname : string
2712 fname : string
2709 Name of the file to be executed.
2713 Name of the file to be executed.
2710
2714
2711 where : tuple
2715 where : tuple
2712 One or two namespaces, passed to execfile() as (globals,locals).
2716 One or two namespaces, passed to execfile() as (globals,locals).
2713 If only one is given, it is passed as both.
2717 If only one is given, it is passed as both.
2714
2718
2715 :Keywords:
2719 :Keywords:
2716 islog : boolean (False)
2720 islog : boolean (False)
2717
2721
2718 quiet : boolean (True)
2722 quiet : boolean (True)
2719
2723
2720 exit_ignore : boolean (False)
2724 exit_ignore : boolean (False)
2721 """
2725 """
2722
2726
2723 def syspath_cleanup():
2727 def syspath_cleanup():
2724 """Internal cleanup routine for sys.path."""
2728 """Internal cleanup routine for sys.path."""
2725 if add_dname:
2729 if add_dname:
2726 try:
2730 try:
2727 sys.path.remove(dname)
2731 sys.path.remove(dname)
2728 except ValueError:
2732 except ValueError:
2729 # For some reason the user has already removed it, ignore.
2733 # For some reason the user has already removed it, ignore.
2730 pass
2734 pass
2731
2735
2732 fname = os.path.expanduser(fname)
2736 fname = os.path.expanduser(fname)
2733
2737
2734 # Find things also in current directory. This is needed to mimic the
2738 # Find things also in current directory. This is needed to mimic the
2735 # behavior of running a script from the system command line, where
2739 # behavior of running a script from the system command line, where
2736 # Python inserts the script's directory into sys.path
2740 # Python inserts the script's directory into sys.path
2737 dname = os.path.dirname(os.path.abspath(fname))
2741 dname = os.path.dirname(os.path.abspath(fname))
2738 add_dname = False
2742 add_dname = False
2739 if dname not in sys.path:
2743 if dname not in sys.path:
2740 sys.path.insert(0,dname)
2744 sys.path.insert(0,dname)
2741 add_dname = True
2745 add_dname = True
2742
2746
2743 try:
2747 try:
2744 xfile = open(fname)
2748 xfile = open(fname)
2745 except:
2749 except:
2746 print >> Term.cerr, \
2750 print >> Term.cerr, \
2747 'Could not open file <%s> for safe execution.' % fname
2751 'Could not open file <%s> for safe execution.' % fname
2748 syspath_cleanup()
2752 syspath_cleanup()
2749 return None
2753 return None
2750
2754
2751 kw.setdefault('islog',0)
2755 kw.setdefault('islog',0)
2752 kw.setdefault('quiet',1)
2756 kw.setdefault('quiet',1)
2753 kw.setdefault('exit_ignore',0)
2757 kw.setdefault('exit_ignore',0)
2754
2758
2755 first = xfile.readline()
2759 first = xfile.readline()
2756 loghead = str(self.loghead_tpl).split('\n',1)[0].strip()
2760 loghead = str(self.loghead_tpl).split('\n',1)[0].strip()
2757 xfile.close()
2761 xfile.close()
2758 # line by line execution
2762 # line by line execution
2759 if first.startswith(loghead) or kw['islog']:
2763 if first.startswith(loghead) or kw['islog']:
2760 print 'Loading log file <%s> one line at a time...' % fname
2764 print 'Loading log file <%s> one line at a time...' % fname
2761 if kw['quiet']:
2765 if kw['quiet']:
2762 stdout_save = sys.stdout
2766 stdout_save = sys.stdout
2763 sys.stdout = StringIO.StringIO()
2767 sys.stdout = StringIO.StringIO()
2764 try:
2768 try:
2765 globs,locs = where[0:2]
2769 globs,locs = where[0:2]
2766 except:
2770 except:
2767 try:
2771 try:
2768 globs = locs = where[0]
2772 globs = locs = where[0]
2769 except:
2773 except:
2770 globs = locs = globals()
2774 globs = locs = globals()
2771 badblocks = []
2775 badblocks = []
2772
2776
2773 # we also need to identify indented blocks of code when replaying
2777 # we also need to identify indented blocks of code when replaying
2774 # logs and put them together before passing them to an exec
2778 # logs and put them together before passing them to an exec
2775 # statement. This takes a bit of regexp and look-ahead work in the
2779 # statement. This takes a bit of regexp and look-ahead work in the
2776 # file. It's easiest if we swallow the whole thing in memory
2780 # file. It's easiest if we swallow the whole thing in memory
2777 # first, and manually walk through the lines list moving the
2781 # first, and manually walk through the lines list moving the
2778 # counter ourselves.
2782 # counter ourselves.
2779 indent_re = re.compile('\s+\S')
2783 indent_re = re.compile('\s+\S')
2780 xfile = open(fname)
2784 xfile = open(fname)
2781 filelines = xfile.readlines()
2785 filelines = xfile.readlines()
2782 xfile.close()
2786 xfile.close()
2783 nlines = len(filelines)
2787 nlines = len(filelines)
2784 lnum = 0
2788 lnum = 0
2785 while lnum < nlines:
2789 while lnum < nlines:
2786 line = filelines[lnum]
2790 line = filelines[lnum]
2787 lnum += 1
2791 lnum += 1
2788 # don't re-insert logger status info into cache
2792 # don't re-insert logger status info into cache
2789 if line.startswith('#log#'):
2793 if line.startswith('#log#'):
2790 continue
2794 continue
2791 else:
2795 else:
2792 # build a block of code (maybe a single line) for execution
2796 # build a block of code (maybe a single line) for execution
2793 block = line
2797 block = line
2794 try:
2798 try:
2795 next = filelines[lnum] # lnum has already incremented
2799 next = filelines[lnum] # lnum has already incremented
2796 except:
2800 except:
2797 next = None
2801 next = None
2798 while next and indent_re.match(next):
2802 while next and indent_re.match(next):
2799 block += next
2803 block += next
2800 lnum += 1
2804 lnum += 1
2801 try:
2805 try:
2802 next = filelines[lnum]
2806 next = filelines[lnum]
2803 except:
2807 except:
2804 next = None
2808 next = None
2805 # now execute the block of one or more lines
2809 # now execute the block of one or more lines
2806 try:
2810 try:
2807 exec block in globs,locs
2811 exec block in globs,locs
2808 except SystemExit:
2812 except SystemExit:
2809 pass
2813 pass
2810 except:
2814 except:
2811 badblocks.append(block.rstrip())
2815 badblocks.append(block.rstrip())
2812 if kw['quiet']: # restore stdout
2816 if kw['quiet']: # restore stdout
2813 sys.stdout.close()
2817 sys.stdout.close()
2814 sys.stdout = stdout_save
2818 sys.stdout = stdout_save
2815 print 'Finished replaying log file <%s>' % fname
2819 print 'Finished replaying log file <%s>' % fname
2816 if badblocks:
2820 if badblocks:
2817 print >> sys.stderr, ('\nThe following lines/blocks in file '
2821 print >> sys.stderr, ('\nThe following lines/blocks in file '
2818 '<%s> reported errors:' % fname)
2822 '<%s> reported errors:' % fname)
2819
2823
2820 for badline in badblocks:
2824 for badline in badblocks:
2821 print >> sys.stderr, badline
2825 print >> sys.stderr, badline
2822 else: # regular file execution
2826 else: # regular file execution
2823 try:
2827 try:
2824 if sys.platform == 'win32' and sys.version_info < (2,5,1):
2828 if sys.platform == 'win32' and sys.version_info < (2,5,1):
2825 # Work around a bug in Python for Windows. The bug was
2829 # Work around a bug in Python for Windows. The bug was
2826 # fixed in in Python 2.5 r54159 and 54158, but that's still
2830 # fixed in in Python 2.5 r54159 and 54158, but that's still
2827 # SVN Python as of March/07. For details, see:
2831 # SVN Python as of March/07. For details, see:
2828 # http://projects.scipy.org/ipython/ipython/ticket/123
2832 # http://projects.scipy.org/ipython/ipython/ticket/123
2829 try:
2833 try:
2830 globs,locs = where[0:2]
2834 globs,locs = where[0:2]
2831 except:
2835 except:
2832 try:
2836 try:
2833 globs = locs = where[0]
2837 globs = locs = where[0]
2834 except:
2838 except:
2835 globs = locs = globals()
2839 globs = locs = globals()
2836 exec file(fname) in globs,locs
2840 exec file(fname) in globs,locs
2837 else:
2841 else:
2838 execfile(fname,*where)
2842 execfile(fname,*where)
2839 except SyntaxError:
2843 except SyntaxError:
2840 self.showsyntaxerror()
2844 self.showsyntaxerror()
2841 warn('Failure executing file: <%s>' % fname)
2845 warn('Failure executing file: <%s>' % fname)
2842 except SystemExit,status:
2846 except SystemExit,status:
2843 # Code that correctly sets the exit status flag to success (0)
2847 # Code that correctly sets the exit status flag to success (0)
2844 # shouldn't be bothered with a traceback. Note that a plain
2848 # shouldn't be bothered with a traceback. Note that a plain
2845 # sys.exit() does NOT set the message to 0 (it's empty) so that
2849 # sys.exit() does NOT set the message to 0 (it's empty) so that
2846 # will still get a traceback. Note that the structure of the
2850 # will still get a traceback. Note that the structure of the
2847 # SystemExit exception changed between Python 2.4 and 2.5, so
2851 # SystemExit exception changed between Python 2.4 and 2.5, so
2848 # the checks must be done in a version-dependent way.
2852 # the checks must be done in a version-dependent way.
2849 show = False
2853 show = False
2850
2854
2851 if sys.version_info[:2] > (2,5):
2855 if sys.version_info[:2] > (2,5):
2852 if status.message!=0 and not kw['exit_ignore']:
2856 if status.message!=0 and not kw['exit_ignore']:
2853 show = True
2857 show = True
2854 else:
2858 else:
2855 if status.code and not kw['exit_ignore']:
2859 if status.code and not kw['exit_ignore']:
2856 show = True
2860 show = True
2857 if show:
2861 if show:
2858 self.showtraceback()
2862 self.showtraceback()
2859 warn('Failure executing file: <%s>' % fname)
2863 warn('Failure executing file: <%s>' % fname)
2860 except:
2864 except:
2861 self.showtraceback()
2865 self.showtraceback()
2862 warn('Failure executing file: <%s>' % fname)
2866 warn('Failure executing file: <%s>' % fname)
2863
2867
2864 syspath_cleanup()
2868 syspath_cleanup()
2865
2869
2866 #************************* end of file <iplib.py> *****************************
2870 #************************* end of file <iplib.py> *****************************
@@ -1,825 +1,813
1 #!/usr/bin/env python
1 #!/usr/bin/env python
2 # encoding: utf-8
2 # encoding: utf-8
3
3
4 """Start an IPython cluster = (controller + engines)."""
4 """Start an IPython cluster = (controller + engines)."""
5
5
6 #-----------------------------------------------------------------------------
6 #-----------------------------------------------------------------------------
7 # Copyright (C) 2008 The IPython Development Team
7 # Copyright (C) 2008 The IPython Development Team
8 #
8 #
9 # Distributed under the terms of the BSD License. The full license is in
9 # Distributed under the terms of the BSD License. The full license is in
10 # the file COPYING, distributed as part of this software.
10 # the file COPYING, distributed as part of this software.
11 #-----------------------------------------------------------------------------
11 #-----------------------------------------------------------------------------
12
12
13 #-----------------------------------------------------------------------------
13 #-----------------------------------------------------------------------------
14 # Imports
14 # Imports
15 #-----------------------------------------------------------------------------
15 #-----------------------------------------------------------------------------
16
16
17 import os
17 import os
18 import re
18 import re
19 import sys
19 import sys
20 import signal
20 import signal
21 import tempfile
21 import tempfile
22 pjoin = os.path.join
22 pjoin = os.path.join
23
23
24 from twisted.internet import reactor, defer
24 from twisted.internet import reactor, defer
25 from twisted.internet.protocol import ProcessProtocol
25 from twisted.internet.protocol import ProcessProtocol
26 from twisted.internet.error import ProcessDone, ProcessTerminated
26 from twisted.internet.error import ProcessDone, ProcessTerminated
27 from twisted.internet.utils import getProcessOutput
27 from twisted.internet.utils import getProcessOutput
28 from twisted.python import failure, log
28 from twisted.python import failure, log
29
29
30 from IPython.external import argparse
30 from IPython.external import argparse
31 from IPython.external import Itpl
31 from IPython.external import Itpl
32 from IPython.genutils import (
32 from IPython.genutils import (
33 get_ipython_dir,
33 get_ipython_dir,
34 get_log_dir,
34 get_log_dir,
35 get_security_dir,
35 get_security_dir,
36 num_cpus
36 num_cpus
37 )
37 )
38 from IPython.kernel.fcutil import have_crypto
38 from IPython.kernel.fcutil import have_crypto
39
39
40 # Create various ipython directories if they don't exist.
40 # Create various ipython directories if they don't exist.
41 # This must be done before IPython.kernel.config is imported.
41 # This must be done before IPython.kernel.config is imported.
42 from IPython.iplib import user_setup
42 from IPython.iplib import user_setup
43 if os.name == 'posix':
43 if os.name == 'posix':
44 rc_suffix = ''
44 rc_suffix = ''
45 else:
45 else:
46 rc_suffix = '.ini'
46 rc_suffix = '.ini'
47 user_setup(get_ipython_dir(), rc_suffix, mode='install', interactive=False)
47 user_setup(get_ipython_dir(), rc_suffix, mode='install', interactive=False)
48 get_log_dir()
48 get_log_dir()
49 get_security_dir()
49 get_security_dir()
50
50
51 from IPython.kernel.config import config_manager as kernel_config_manager
51 from IPython.kernel.config import config_manager as kernel_config_manager
52 from IPython.kernel.error import SecurityError, FileTimeoutError
52 from IPython.kernel.error import SecurityError, FileTimeoutError
53 from IPython.kernel.fcutil import have_crypto
53 from IPython.kernel.fcutil import have_crypto
54 from IPython.kernel.twistedutil import gatherBoth, wait_for_file
54 from IPython.kernel.twistedutil import gatherBoth, wait_for_file
55 from IPython.kernel.util import printer
55 from IPython.kernel.util import printer
56
56
57
58 #-----------------------------------------------------------------------------
57 #-----------------------------------------------------------------------------
59 # General process handling code
58 # General process handling code
60 #-----------------------------------------------------------------------------
59 #-----------------------------------------------------------------------------
61
60
62 def find_exe(cmd):
63 try:
64 import win32api
65 except ImportError:
66 raise ImportError('you need to have pywin32 installed for this to work')
67 else:
68 try:
69 (path, offest) = win32api.SearchPath(os.environ['PATH'],cmd + '.exe')
70 except:
71 (path, offset) = win32api.SearchPath(os.environ['PATH'],cmd + '.bat')
72 return path
73
61
74 class ProcessStateError(Exception):
62 class ProcessStateError(Exception):
75 pass
63 pass
76
64
77 class UnknownStatus(Exception):
65 class UnknownStatus(Exception):
78 pass
66 pass
79
67
80 class LauncherProcessProtocol(ProcessProtocol):
68 class LauncherProcessProtocol(ProcessProtocol):
81 """
69 """
82 A ProcessProtocol to go with the ProcessLauncher.
70 A ProcessProtocol to go with the ProcessLauncher.
83 """
71 """
84 def __init__(self, process_launcher):
72 def __init__(self, process_launcher):
85 self.process_launcher = process_launcher
73 self.process_launcher = process_launcher
86
74
87 def connectionMade(self):
75 def connectionMade(self):
88 self.process_launcher.fire_start_deferred(self.transport.pid)
76 self.process_launcher.fire_start_deferred(self.transport.pid)
89
77
90 def processEnded(self, status):
78 def processEnded(self, status):
91 value = status.value
79 value = status.value
92 if isinstance(value, ProcessDone):
80 if isinstance(value, ProcessDone):
93 self.process_launcher.fire_stop_deferred(0)
81 self.process_launcher.fire_stop_deferred(0)
94 elif isinstance(value, ProcessTerminated):
82 elif isinstance(value, ProcessTerminated):
95 self.process_launcher.fire_stop_deferred(
83 self.process_launcher.fire_stop_deferred(
96 {'exit_code':value.exitCode,
84 {'exit_code':value.exitCode,
97 'signal':value.signal,
85 'signal':value.signal,
98 'status':value.status
86 'status':value.status
99 }
87 }
100 )
88 )
101 else:
89 else:
102 raise UnknownStatus("unknown exit status, this is probably a bug in Twisted")
90 raise UnknownStatus("unknown exit status, this is probably a bug in Twisted")
103
91
104 def outReceived(self, data):
92 def outReceived(self, data):
105 log.msg(data)
93 log.msg(data)
106
94
107 def errReceived(self, data):
95 def errReceived(self, data):
108 log.err(data)
96 log.err(data)
109
97
110 class ProcessLauncher(object):
98 class ProcessLauncher(object):
111 """
99 """
112 Start and stop an external process in an asynchronous manner.
100 Start and stop an external process in an asynchronous manner.
113
101
114 Currently this uses deferreds to notify other parties of process state
102 Currently this uses deferreds to notify other parties of process state
115 changes. This is an awkward design and should be moved to using
103 changes. This is an awkward design and should be moved to using
116 a formal NotificationCenter.
104 a formal NotificationCenter.
117 """
105 """
118 def __init__(self, cmd_and_args):
106 def __init__(self, cmd_and_args):
119 self.cmd = cmd_and_args[0]
107 self.cmd = cmd_and_args[0]
120 self.args = cmd_and_args
108 self.args = cmd_and_args
121 self._reset()
109 self._reset()
122
110
123 def _reset(self):
111 def _reset(self):
124 self.process_protocol = None
112 self.process_protocol = None
125 self.pid = None
113 self.pid = None
126 self.start_deferred = None
114 self.start_deferred = None
127 self.stop_deferreds = []
115 self.stop_deferreds = []
128 self.state = 'before' # before, running, or after
116 self.state = 'before' # before, running, or after
129
117
130 @property
118 @property
131 def running(self):
119 def running(self):
132 if self.state == 'running':
120 if self.state == 'running':
133 return True
121 return True
134 else:
122 else:
135 return False
123 return False
136
124
137 def fire_start_deferred(self, pid):
125 def fire_start_deferred(self, pid):
138 self.pid = pid
126 self.pid = pid
139 self.state = 'running'
127 self.state = 'running'
140 log.msg('Process %r has started with pid=%i' % (self.args, pid))
128 log.msg('Process %r has started with pid=%i' % (self.args, pid))
141 self.start_deferred.callback(pid)
129 self.start_deferred.callback(pid)
142
130
143 def start(self):
131 def start(self):
144 if self.state == 'before':
132 if self.state == 'before':
145 self.process_protocol = LauncherProcessProtocol(self)
133 self.process_protocol = LauncherProcessProtocol(self)
146 self.start_deferred = defer.Deferred()
134 self.start_deferred = defer.Deferred()
147 self.process_transport = reactor.spawnProcess(
135 self.process_transport = reactor.spawnProcess(
148 self.process_protocol,
136 self.process_protocol,
149 self.cmd,
137 self.cmd,
150 self.args,
138 self.args,
151 env=os.environ
139 env=os.environ
152 )
140 )
153 return self.start_deferred
141 return self.start_deferred
154 else:
142 else:
155 s = 'the process has already been started and has state: %r' % \
143 s = 'the process has already been started and has state: %r' % \
156 self.state
144 self.state
157 return defer.fail(ProcessStateError(s))
145 return defer.fail(ProcessStateError(s))
158
146
159 def get_stop_deferred(self):
147 def get_stop_deferred(self):
160 if self.state == 'running' or self.state == 'before':
148 if self.state == 'running' or self.state == 'before':
161 d = defer.Deferred()
149 d = defer.Deferred()
162 self.stop_deferreds.append(d)
150 self.stop_deferreds.append(d)
163 return d
151 return d
164 else:
152 else:
165 s = 'this process is already complete'
153 s = 'this process is already complete'
166 return defer.fail(ProcessStateError(s))
154 return defer.fail(ProcessStateError(s))
167
155
168 def fire_stop_deferred(self, exit_code):
156 def fire_stop_deferred(self, exit_code):
169 log.msg('Process %r has stopped with %r' % (self.args, exit_code))
157 log.msg('Process %r has stopped with %r' % (self.args, exit_code))
170 self.state = 'after'
158 self.state = 'after'
171 for d in self.stop_deferreds:
159 for d in self.stop_deferreds:
172 d.callback(exit_code)
160 d.callback(exit_code)
173
161
174 def signal(self, sig):
162 def signal(self, sig):
175 """
163 """
176 Send a signal to the process.
164 Send a signal to the process.
177
165
178 The argument sig can be ('KILL','INT', etc.) or any signal number.
166 The argument sig can be ('KILL','INT', etc.) or any signal number.
179 """
167 """
180 if self.state == 'running':
168 if self.state == 'running':
181 self.process_transport.signalProcess(sig)
169 self.process_transport.signalProcess(sig)
182
170
183 # def __del__(self):
171 # def __del__(self):
184 # self.signal('KILL')
172 # self.signal('KILL')
185
173
186 def interrupt_then_kill(self, delay=1.0):
174 def interrupt_then_kill(self, delay=1.0):
187 self.signal('INT')
175 self.signal('INT')
188 reactor.callLater(delay, self.signal, 'KILL')
176 reactor.callLater(delay, self.signal, 'KILL')
189
177
190
178
191 #-----------------------------------------------------------------------------
179 #-----------------------------------------------------------------------------
192 # Code for launching controller and engines
180 # Code for launching controller and engines
193 #-----------------------------------------------------------------------------
181 #-----------------------------------------------------------------------------
194
182
195
183
196 class ControllerLauncher(ProcessLauncher):
184 class ControllerLauncher(ProcessLauncher):
197
185
198 def __init__(self, extra_args=None):
186 def __init__(self, extra_args=None):
199 if sys.platform == 'win32':
187 if sys.platform == 'win32':
200 # This logic is needed because the ipcontroller script doesn't
188 # This logic is needed because the ipcontroller script doesn't
201 # always get installed in the same way or in the same location.
189 # always get installed in the same way or in the same location.
202 from IPython.kernel.scripts import ipcontroller
190 from IPython.kernel.scripts import ipcontroller
203 script_location = ipcontroller.__file__.replace('.pyc', '.py')
191 script_location = ipcontroller.__file__.replace('.pyc', '.py')
204 # The -u option here turns on unbuffered output, which is required
192 # The -u option here turns on unbuffered output, which is required
205 # on Win32 to prevent wierd conflict and problems with Twisted.
193 # on Win32 to prevent wierd conflict and problems with Twisted.
206 # Also, use sys.executable to make sure we are picking up the
194 # Also, use sys.executable to make sure we are picking up the
207 # right python exe.
195 # right python exe.
208 args = [sys.executable, '-u', script_location]
196 args = [sys.executable, '-u', script_location]
209 else:
197 else:
210 args = ['ipcontroller']
198 args = ['ipcontroller']
211 self.extra_args = extra_args
199 self.extra_args = extra_args
212 if extra_args is not None:
200 if extra_args is not None:
213 args.extend(extra_args)
201 args.extend(extra_args)
214
202
215 ProcessLauncher.__init__(self, args)
203 ProcessLauncher.__init__(self, args)
216
204
217
205
218 class EngineLauncher(ProcessLauncher):
206 class EngineLauncher(ProcessLauncher):
219
207
220 def __init__(self, extra_args=None):
208 def __init__(self, extra_args=None):
221 if sys.platform == 'win32':
209 if sys.platform == 'win32':
222 # This logic is needed because the ipcontroller script doesn't
210 # This logic is needed because the ipcontroller script doesn't
223 # always get installed in the same way or in the same location.
211 # always get installed in the same way or in the same location.
224 from IPython.kernel.scripts import ipengine
212 from IPython.kernel.scripts import ipengine
225 script_location = ipengine.__file__.replace('.pyc', '.py')
213 script_location = ipengine.__file__.replace('.pyc', '.py')
226 # The -u option here turns on unbuffered output, which is required
214 # The -u option here turns on unbuffered output, which is required
227 # on Win32 to prevent wierd conflict and problems with Twisted.
215 # on Win32 to prevent wierd conflict and problems with Twisted.
228 # Also, use sys.executable to make sure we are picking up the
216 # Also, use sys.executable to make sure we are picking up the
229 # right python exe.
217 # right python exe.
230 args = [sys.executable, '-u', script_location]
218 args = [sys.executable, '-u', script_location]
231 else:
219 else:
232 args = ['ipengine']
220 args = ['ipengine']
233 self.extra_args = extra_args
221 self.extra_args = extra_args
234 if extra_args is not None:
222 if extra_args is not None:
235 args.extend(extra_args)
223 args.extend(extra_args)
236
224
237 ProcessLauncher.__init__(self, args)
225 ProcessLauncher.__init__(self, args)
238
226
239
227
240 class LocalEngineSet(object):
228 class LocalEngineSet(object):
241
229
242 def __init__(self, extra_args=None):
230 def __init__(self, extra_args=None):
243 self.extra_args = extra_args
231 self.extra_args = extra_args
244 self.launchers = []
232 self.launchers = []
245
233
246 def start(self, n):
234 def start(self, n):
247 dlist = []
235 dlist = []
248 for i in range(n):
236 for i in range(n):
249 el = EngineLauncher(extra_args=self.extra_args)
237 el = EngineLauncher(extra_args=self.extra_args)
250 d = el.start()
238 d = el.start()
251 self.launchers.append(el)
239 self.launchers.append(el)
252 dlist.append(d)
240 dlist.append(d)
253 dfinal = gatherBoth(dlist, consumeErrors=True)
241 dfinal = gatherBoth(dlist, consumeErrors=True)
254 dfinal.addCallback(self._handle_start)
242 dfinal.addCallback(self._handle_start)
255 return dfinal
243 return dfinal
256
244
257 def _handle_start(self, r):
245 def _handle_start(self, r):
258 log.msg('Engines started with pids: %r' % r)
246 log.msg('Engines started with pids: %r' % r)
259 return r
247 return r
260
248
261 def _handle_stop(self, r):
249 def _handle_stop(self, r):
262 log.msg('Engines received signal: %r' % r)
250 log.msg('Engines received signal: %r' % r)
263 return r
251 return r
264
252
265 def signal(self, sig):
253 def signal(self, sig):
266 dlist = []
254 dlist = []
267 for el in self.launchers:
255 for el in self.launchers:
268 d = el.get_stop_deferred()
256 d = el.get_stop_deferred()
269 dlist.append(d)
257 dlist.append(d)
270 el.signal(sig)
258 el.signal(sig)
271 dfinal = gatherBoth(dlist, consumeErrors=True)
259 dfinal = gatherBoth(dlist, consumeErrors=True)
272 dfinal.addCallback(self._handle_stop)
260 dfinal.addCallback(self._handle_stop)
273 return dfinal
261 return dfinal
274
262
275 def interrupt_then_kill(self, delay=1.0):
263 def interrupt_then_kill(self, delay=1.0):
276 dlist = []
264 dlist = []
277 for el in self.launchers:
265 for el in self.launchers:
278 d = el.get_stop_deferred()
266 d = el.get_stop_deferred()
279 dlist.append(d)
267 dlist.append(d)
280 el.interrupt_then_kill(delay)
268 el.interrupt_then_kill(delay)
281 dfinal = gatherBoth(dlist, consumeErrors=True)
269 dfinal = gatherBoth(dlist, consumeErrors=True)
282 dfinal.addCallback(self._handle_stop)
270 dfinal.addCallback(self._handle_stop)
283 return dfinal
271 return dfinal
284
272
285
273
286 class BatchEngineSet(object):
274 class BatchEngineSet(object):
287
275
288 # Subclasses must fill these in. See PBSEngineSet
276 # Subclasses must fill these in. See PBSEngineSet
289 submit_command = ''
277 submit_command = ''
290 delete_command = ''
278 delete_command = ''
291 job_id_regexp = ''
279 job_id_regexp = ''
292
280
293 def __init__(self, template_file, **kwargs):
281 def __init__(self, template_file, **kwargs):
294 self.template_file = template_file
282 self.template_file = template_file
295 self.context = {}
283 self.context = {}
296 self.context.update(kwargs)
284 self.context.update(kwargs)
297 self.batch_file = self.template_file+'-run'
285 self.batch_file = self.template_file+'-run'
298
286
299 def parse_job_id(self, output):
287 def parse_job_id(self, output):
300 m = re.match(self.job_id_regexp, output)
288 m = re.match(self.job_id_regexp, output)
301 if m is not None:
289 if m is not None:
302 job_id = m.group()
290 job_id = m.group()
303 else:
291 else:
304 raise Exception("job id couldn't be determined: %s" % output)
292 raise Exception("job id couldn't be determined: %s" % output)
305 self.job_id = job_id
293 self.job_id = job_id
306 log.msg('Job started with job id: %r' % job_id)
294 log.msg('Job started with job id: %r' % job_id)
307 return job_id
295 return job_id
308
296
309 def write_batch_script(self, n):
297 def write_batch_script(self, n):
310 self.context['n'] = n
298 self.context['n'] = n
311 template = open(self.template_file, 'r').read()
299 template = open(self.template_file, 'r').read()
312 log.msg('Using template for batch script: %s' % self.template_file)
300 log.msg('Using template for batch script: %s' % self.template_file)
313 script_as_string = Itpl.itplns(template, self.context)
301 script_as_string = Itpl.itplns(template, self.context)
314 log.msg('Writing instantiated batch script: %s' % self.batch_file)
302 log.msg('Writing instantiated batch script: %s' % self.batch_file)
315 f = open(self.batch_file,'w')
303 f = open(self.batch_file,'w')
316 f.write(script_as_string)
304 f.write(script_as_string)
317 f.close()
305 f.close()
318
306
319 def handle_error(self, f):
307 def handle_error(self, f):
320 f.printTraceback()
308 f.printTraceback()
321 f.raiseException()
309 f.raiseException()
322
310
323 def start(self, n):
311 def start(self, n):
324 self.write_batch_script(n)
312 self.write_batch_script(n)
325 d = getProcessOutput(self.submit_command,
313 d = getProcessOutput(self.submit_command,
326 [self.batch_file],env=os.environ)
314 [self.batch_file],env=os.environ)
327 d.addCallback(self.parse_job_id)
315 d.addCallback(self.parse_job_id)
328 d.addErrback(self.handle_error)
316 d.addErrback(self.handle_error)
329 return d
317 return d
330
318
331 def kill(self):
319 def kill(self):
332 d = getProcessOutput(self.delete_command,
320 d = getProcessOutput(self.delete_command,
333 [self.job_id],env=os.environ)
321 [self.job_id],env=os.environ)
334 return d
322 return d
335
323
336 class PBSEngineSet(BatchEngineSet):
324 class PBSEngineSet(BatchEngineSet):
337
325
338 submit_command = 'qsub'
326 submit_command = 'qsub'
339 delete_command = 'qdel'
327 delete_command = 'qdel'
340 job_id_regexp = '\d+'
328 job_id_regexp = '\d+'
341
329
342 def __init__(self, template_file, **kwargs):
330 def __init__(self, template_file, **kwargs):
343 BatchEngineSet.__init__(self, template_file, **kwargs)
331 BatchEngineSet.__init__(self, template_file, **kwargs)
344
332
345
333
346 sshx_template="""#!/bin/sh
334 sshx_template="""#!/bin/sh
347 "$@" &> /dev/null &
335 "$@" &> /dev/null &
348 echo $!
336 echo $!
349 """
337 """
350
338
351 engine_killer_template="""#!/bin/sh
339 engine_killer_template="""#!/bin/sh
352 ps -fu `whoami` | grep '[i]pengine' | awk '{print $2}' | xargs kill -TERM
340 ps -fu `whoami` | grep '[i]pengine' | awk '{print $2}' | xargs kill -TERM
353 """
341 """
354
342
355 class SSHEngineSet(object):
343 class SSHEngineSet(object):
356 sshx_template=sshx_template
344 sshx_template=sshx_template
357 engine_killer_template=engine_killer_template
345 engine_killer_template=engine_killer_template
358
346
359 def __init__(self, engine_hosts, sshx=None, ipengine="ipengine"):
347 def __init__(self, engine_hosts, sshx=None, ipengine="ipengine"):
360 """Start a controller on localhost and engines using ssh.
348 """Start a controller on localhost and engines using ssh.
361
349
362 The engine_hosts argument is a dict with hostnames as keys and
350 The engine_hosts argument is a dict with hostnames as keys and
363 the number of engine (int) as values. sshx is the name of a local
351 the number of engine (int) as values. sshx is the name of a local
364 file that will be used to run remote commands. This file is used
352 file that will be used to run remote commands. This file is used
365 to setup the environment properly.
353 to setup the environment properly.
366 """
354 """
367
355
368 self.temp_dir = tempfile.gettempdir()
356 self.temp_dir = tempfile.gettempdir()
369 if sshx is not None:
357 if sshx is not None:
370 self.sshx = sshx
358 self.sshx = sshx
371 else:
359 else:
372 # Write the sshx.sh file locally from our template.
360 # Write the sshx.sh file locally from our template.
373 self.sshx = os.path.join(
361 self.sshx = os.path.join(
374 self.temp_dir,
362 self.temp_dir,
375 '%s-main-sshx.sh' % os.environ['USER']
363 '%s-main-sshx.sh' % os.environ['USER']
376 )
364 )
377 f = open(self.sshx, 'w')
365 f = open(self.sshx, 'w')
378 f.writelines(self.sshx_template)
366 f.writelines(self.sshx_template)
379 f.close()
367 f.close()
380 self.engine_command = ipengine
368 self.engine_command = ipengine
381 self.engine_hosts = engine_hosts
369 self.engine_hosts = engine_hosts
382 # Write the engine killer script file locally from our template.
370 # Write the engine killer script file locally from our template.
383 self.engine_killer = os.path.join(
371 self.engine_killer = os.path.join(
384 self.temp_dir,
372 self.temp_dir,
385 '%s-local-engine_killer.sh' % os.environ['USER']
373 '%s-local-engine_killer.sh' % os.environ['USER']
386 )
374 )
387 f = open(self.engine_killer, 'w')
375 f = open(self.engine_killer, 'w')
388 f.writelines(self.engine_killer_template)
376 f.writelines(self.engine_killer_template)
389 f.close()
377 f.close()
390
378
391 def start(self, send_furl=False):
379 def start(self, send_furl=False):
392 dlist = []
380 dlist = []
393 for host in self.engine_hosts.keys():
381 for host in self.engine_hosts.keys():
394 count = self.engine_hosts[host]
382 count = self.engine_hosts[host]
395 d = self._start(host, count, send_furl)
383 d = self._start(host, count, send_furl)
396 dlist.append(d)
384 dlist.append(d)
397 return gatherBoth(dlist, consumeErrors=True)
385 return gatherBoth(dlist, consumeErrors=True)
398
386
399 def _start(self, hostname, count=1, send_furl=False):
387 def _start(self, hostname, count=1, send_furl=False):
400 if send_furl:
388 if send_furl:
401 d = self._scp_furl(hostname)
389 d = self._scp_furl(hostname)
402 else:
390 else:
403 d = defer.succeed(None)
391 d = defer.succeed(None)
404 d.addCallback(lambda r: self._scp_sshx(hostname))
392 d.addCallback(lambda r: self._scp_sshx(hostname))
405 d.addCallback(lambda r: self._ssh_engine(hostname, count))
393 d.addCallback(lambda r: self._ssh_engine(hostname, count))
406 return d
394 return d
407
395
408 def _scp_furl(self, hostname):
396 def _scp_furl(self, hostname):
409 scp_cmd = "scp ~/.ipython/security/ipcontroller-engine.furl %s:.ipython/security/" % (hostname)
397 scp_cmd = "scp ~/.ipython/security/ipcontroller-engine.furl %s:.ipython/security/" % (hostname)
410 cmd_list = scp_cmd.split()
398 cmd_list = scp_cmd.split()
411 cmd_list[1] = os.path.expanduser(cmd_list[1])
399 cmd_list[1] = os.path.expanduser(cmd_list[1])
412 log.msg('Copying furl file: %s' % scp_cmd)
400 log.msg('Copying furl file: %s' % scp_cmd)
413 d = getProcessOutput(cmd_list[0], cmd_list[1:], env=os.environ)
401 d = getProcessOutput(cmd_list[0], cmd_list[1:], env=os.environ)
414 return d
402 return d
415
403
416 def _scp_sshx(self, hostname):
404 def _scp_sshx(self, hostname):
417 scp_cmd = "scp %s %s:%s/%s-sshx.sh" % (
405 scp_cmd = "scp %s %s:%s/%s-sshx.sh" % (
418 self.sshx, hostname,
406 self.sshx, hostname,
419 self.temp_dir, os.environ['USER']
407 self.temp_dir, os.environ['USER']
420 )
408 )
421 print
409 print
422 log.msg("Copying sshx: %s" % scp_cmd)
410 log.msg("Copying sshx: %s" % scp_cmd)
423 sshx_scp = scp_cmd.split()
411 sshx_scp = scp_cmd.split()
424 d = getProcessOutput(sshx_scp[0], sshx_scp[1:], env=os.environ)
412 d = getProcessOutput(sshx_scp[0], sshx_scp[1:], env=os.environ)
425 return d
413 return d
426
414
427 def _ssh_engine(self, hostname, count):
415 def _ssh_engine(self, hostname, count):
428 exec_engine = "ssh %s sh %s/%s-sshx.sh %s" % (
416 exec_engine = "ssh %s sh %s/%s-sshx.sh %s" % (
429 hostname, self.temp_dir,
417 hostname, self.temp_dir,
430 os.environ['USER'], self.engine_command
418 os.environ['USER'], self.engine_command
431 )
419 )
432 cmds = exec_engine.split()
420 cmds = exec_engine.split()
433 dlist = []
421 dlist = []
434 log.msg("about to start engines...")
422 log.msg("about to start engines...")
435 for i in range(count):
423 for i in range(count):
436 log.msg('Starting engines: %s' % exec_engine)
424 log.msg('Starting engines: %s' % exec_engine)
437 d = getProcessOutput(cmds[0], cmds[1:], env=os.environ)
425 d = getProcessOutput(cmds[0], cmds[1:], env=os.environ)
438 dlist.append(d)
426 dlist.append(d)
439 return gatherBoth(dlist, consumeErrors=True)
427 return gatherBoth(dlist, consumeErrors=True)
440
428
441 def kill(self):
429 def kill(self):
442 dlist = []
430 dlist = []
443 for host in self.engine_hosts.keys():
431 for host in self.engine_hosts.keys():
444 d = self._killall(host)
432 d = self._killall(host)
445 dlist.append(d)
433 dlist.append(d)
446 return gatherBoth(dlist, consumeErrors=True)
434 return gatherBoth(dlist, consumeErrors=True)
447
435
448 def _killall(self, hostname):
436 def _killall(self, hostname):
449 d = self._scp_engine_killer(hostname)
437 d = self._scp_engine_killer(hostname)
450 d.addCallback(lambda r: self._ssh_kill(hostname))
438 d.addCallback(lambda r: self._ssh_kill(hostname))
451 # d.addErrback(self._exec_err)
439 # d.addErrback(self._exec_err)
452 return d
440 return d
453
441
454 def _scp_engine_killer(self, hostname):
442 def _scp_engine_killer(self, hostname):
455 scp_cmd = "scp %s %s:%s/%s-engine_killer.sh" % (
443 scp_cmd = "scp %s %s:%s/%s-engine_killer.sh" % (
456 self.engine_killer,
444 self.engine_killer,
457 hostname,
445 hostname,
458 self.temp_dir,
446 self.temp_dir,
459 os.environ['USER']
447 os.environ['USER']
460 )
448 )
461 cmds = scp_cmd.split()
449 cmds = scp_cmd.split()
462 log.msg('Copying engine_killer: %s' % scp_cmd)
450 log.msg('Copying engine_killer: %s' % scp_cmd)
463 d = getProcessOutput(cmds[0], cmds[1:], env=os.environ)
451 d = getProcessOutput(cmds[0], cmds[1:], env=os.environ)
464 return d
452 return d
465
453
466 def _ssh_kill(self, hostname):
454 def _ssh_kill(self, hostname):
467 kill_cmd = "ssh %s sh %s/%s-engine_killer.sh" % (
455 kill_cmd = "ssh %s sh %s/%s-engine_killer.sh" % (
468 hostname,
456 hostname,
469 self.temp_dir,
457 self.temp_dir,
470 os.environ['USER']
458 os.environ['USER']
471 )
459 )
472 log.msg('Killing engine: %s' % kill_cmd)
460 log.msg('Killing engine: %s' % kill_cmd)
473 kill_cmd = kill_cmd.split()
461 kill_cmd = kill_cmd.split()
474 d = getProcessOutput(kill_cmd[0], kill_cmd[1:], env=os.environ)
462 d = getProcessOutput(kill_cmd[0], kill_cmd[1:], env=os.environ)
475 return d
463 return d
476
464
477 def _exec_err(self, r):
465 def _exec_err(self, r):
478 log.msg(r)
466 log.msg(r)
479
467
480 #-----------------------------------------------------------------------------
468 #-----------------------------------------------------------------------------
481 # Main functions for the different types of clusters
469 # Main functions for the different types of clusters
482 #-----------------------------------------------------------------------------
470 #-----------------------------------------------------------------------------
483
471
484 # TODO:
472 # TODO:
485 # The logic in these codes should be moved into classes like LocalCluster
473 # The logic in these codes should be moved into classes like LocalCluster
486 # MpirunCluster, PBSCluster, etc. This would remove alot of the duplications.
474 # MpirunCluster, PBSCluster, etc. This would remove alot of the duplications.
487 # The main functions should then just parse the command line arguments, create
475 # The main functions should then just parse the command line arguments, create
488 # the appropriate class and call a 'start' method.
476 # the appropriate class and call a 'start' method.
489
477
490
478
491 def check_security(args, cont_args):
479 def check_security(args, cont_args):
492 """Check to see if we should run with SSL support."""
480 """Check to see if we should run with SSL support."""
493 if (not args.x or not args.y) and not have_crypto:
481 if (not args.x or not args.y) and not have_crypto:
494 log.err("""
482 log.err("""
495 OpenSSL/pyOpenSSL is not available, so we can't run in secure mode.
483 OpenSSL/pyOpenSSL is not available, so we can't run in secure mode.
496 Try running ipcluster with the -xy flags: ipcluster local -xy -n 4""")
484 Try running ipcluster with the -xy flags: ipcluster local -xy -n 4""")
497 reactor.stop()
485 reactor.stop()
498 return False
486 return False
499 if args.x:
487 if args.x:
500 cont_args.append('-x')
488 cont_args.append('-x')
501 if args.y:
489 if args.y:
502 cont_args.append('-y')
490 cont_args.append('-y')
503 return True
491 return True
504
492
505
493
506 def check_reuse(args, cont_args):
494 def check_reuse(args, cont_args):
507 """Check to see if we should try to resuse FURL files."""
495 """Check to see if we should try to resuse FURL files."""
508 if args.r:
496 if args.r:
509 cont_args.append('-r')
497 cont_args.append('-r')
510 if args.client_port == 0 or args.engine_port == 0:
498 if args.client_port == 0 or args.engine_port == 0:
511 log.err("""
499 log.err("""
512 To reuse FURL files, you must also set the client and engine ports using
500 To reuse FURL files, you must also set the client and engine ports using
513 the --client-port and --engine-port options.""")
501 the --client-port and --engine-port options.""")
514 reactor.stop()
502 reactor.stop()
515 return False
503 return False
516 cont_args.append('--client-port=%i' % args.client_port)
504 cont_args.append('--client-port=%i' % args.client_port)
517 cont_args.append('--engine-port=%i' % args.engine_port)
505 cont_args.append('--engine-port=%i' % args.engine_port)
518 return True
506 return True
519
507
520
508
521 def _err_and_stop(f):
509 def _err_and_stop(f):
522 """Errback to log a failure and halt the reactor on a fatal error."""
510 """Errback to log a failure and halt the reactor on a fatal error."""
523 log.err(f)
511 log.err(f)
524 reactor.stop()
512 reactor.stop()
525
513
526
514
527 def _delay_start(cont_pid, start_engines, furl_file, reuse):
515 def _delay_start(cont_pid, start_engines, furl_file, reuse):
528 """Wait for controller to create FURL files and the start the engines."""
516 """Wait for controller to create FURL files and the start the engines."""
529 if not reuse:
517 if not reuse:
530 if os.path.isfile(furl_file):
518 if os.path.isfile(furl_file):
531 os.unlink(furl_file)
519 os.unlink(furl_file)
532 log.msg('Waiting for controller to finish starting...')
520 log.msg('Waiting for controller to finish starting...')
533 d = wait_for_file(furl_file, delay=0.2, max_tries=50)
521 d = wait_for_file(furl_file, delay=0.2, max_tries=50)
534 d.addCallback(lambda _: log.msg('Controller started'))
522 d.addCallback(lambda _: log.msg('Controller started'))
535 d.addCallback(lambda _: start_engines(cont_pid))
523 d.addCallback(lambda _: start_engines(cont_pid))
536 return d
524 return d
537
525
538
526
539 def main_local(args):
527 def main_local(args):
540 cont_args = []
528 cont_args = []
541 cont_args.append('--logfile=%s' % pjoin(args.logdir,'ipcontroller'))
529 cont_args.append('--logfile=%s' % pjoin(args.logdir,'ipcontroller'))
542
530
543 # Check security settings before proceeding
531 # Check security settings before proceeding
544 if not check_security(args, cont_args):
532 if not check_security(args, cont_args):
545 return
533 return
546
534
547 # See if we are reusing FURL files
535 # See if we are reusing FURL files
548 if not check_reuse(args, cont_args):
536 if not check_reuse(args, cont_args):
549 return
537 return
550
538
551 cl = ControllerLauncher(extra_args=cont_args)
539 cl = ControllerLauncher(extra_args=cont_args)
552 dstart = cl.start()
540 dstart = cl.start()
553 def start_engines(cont_pid):
541 def start_engines(cont_pid):
554 engine_args = []
542 engine_args = []
555 engine_args.append('--logfile=%s' % \
543 engine_args.append('--logfile=%s' % \
556 pjoin(args.logdir,'ipengine%s-' % cont_pid))
544 pjoin(args.logdir,'ipengine%s-' % cont_pid))
557 eset = LocalEngineSet(extra_args=engine_args)
545 eset = LocalEngineSet(extra_args=engine_args)
558 def shutdown(signum, frame):
546 def shutdown(signum, frame):
559 log.msg('Stopping local cluster')
547 log.msg('Stopping local cluster')
560 # We are still playing with the times here, but these seem
548 # We are still playing with the times here, but these seem
561 # to be reliable in allowing everything to exit cleanly.
549 # to be reliable in allowing everything to exit cleanly.
562 eset.interrupt_then_kill(0.5)
550 eset.interrupt_then_kill(0.5)
563 cl.interrupt_then_kill(0.5)
551 cl.interrupt_then_kill(0.5)
564 reactor.callLater(1.0, reactor.stop)
552 reactor.callLater(1.0, reactor.stop)
565 signal.signal(signal.SIGINT,shutdown)
553 signal.signal(signal.SIGINT,shutdown)
566 d = eset.start(args.n)
554 d = eset.start(args.n)
567 return d
555 return d
568 config = kernel_config_manager.get_config_obj()
556 config = kernel_config_manager.get_config_obj()
569 furl_file = config['controller']['engine_furl_file']
557 furl_file = config['controller']['engine_furl_file']
570 dstart.addCallback(_delay_start, start_engines, furl_file, args.r)
558 dstart.addCallback(_delay_start, start_engines, furl_file, args.r)
571 dstart.addErrback(_err_and_stop)
559 dstart.addErrback(_err_and_stop)
572
560
573
561
574 def main_mpi(args):
562 def main_mpi(args):
575 cont_args = []
563 cont_args = []
576 cont_args.append('--logfile=%s' % pjoin(args.logdir,'ipcontroller'))
564 cont_args.append('--logfile=%s' % pjoin(args.logdir,'ipcontroller'))
577
565
578 # Check security settings before proceeding
566 # Check security settings before proceeding
579 if not check_security(args, cont_args):
567 if not check_security(args, cont_args):
580 return
568 return
581
569
582 # See if we are reusing FURL files
570 # See if we are reusing FURL files
583 if not check_reuse(args, cont_args):
571 if not check_reuse(args, cont_args):
584 return
572 return
585
573
586 cl = ControllerLauncher(extra_args=cont_args)
574 cl = ControllerLauncher(extra_args=cont_args)
587 dstart = cl.start()
575 dstart = cl.start()
588 def start_engines(cont_pid):
576 def start_engines(cont_pid):
589 raw_args = [args.cmd]
577 raw_args = [args.cmd]
590 raw_args.extend(['-n',str(args.n)])
578 raw_args.extend(['-n',str(args.n)])
591 raw_args.append('ipengine')
579 raw_args.append('ipengine')
592 raw_args.append('-l')
580 raw_args.append('-l')
593 raw_args.append(pjoin(args.logdir,'ipengine%s-' % cont_pid))
581 raw_args.append(pjoin(args.logdir,'ipengine%s-' % cont_pid))
594 if args.mpi:
582 if args.mpi:
595 raw_args.append('--mpi=%s' % args.mpi)
583 raw_args.append('--mpi=%s' % args.mpi)
596 eset = ProcessLauncher(raw_args)
584 eset = ProcessLauncher(raw_args)
597 def shutdown(signum, frame):
585 def shutdown(signum, frame):
598 log.msg('Stopping local cluster')
586 log.msg('Stopping local cluster')
599 # We are still playing with the times here, but these seem
587 # We are still playing with the times here, but these seem
600 # to be reliable in allowing everything to exit cleanly.
588 # to be reliable in allowing everything to exit cleanly.
601 eset.interrupt_then_kill(1.0)
589 eset.interrupt_then_kill(1.0)
602 cl.interrupt_then_kill(1.0)
590 cl.interrupt_then_kill(1.0)
603 reactor.callLater(2.0, reactor.stop)
591 reactor.callLater(2.0, reactor.stop)
604 signal.signal(signal.SIGINT,shutdown)
592 signal.signal(signal.SIGINT,shutdown)
605 d = eset.start()
593 d = eset.start()
606 return d
594 return d
607 config = kernel_config_manager.get_config_obj()
595 config = kernel_config_manager.get_config_obj()
608 furl_file = config['controller']['engine_furl_file']
596 furl_file = config['controller']['engine_furl_file']
609 dstart.addCallback(_delay_start, start_engines, furl_file, args.r)
597 dstart.addCallback(_delay_start, start_engines, furl_file, args.r)
610 dstart.addErrback(_err_and_stop)
598 dstart.addErrback(_err_and_stop)
611
599
612
600
613 def main_pbs(args):
601 def main_pbs(args):
614 cont_args = []
602 cont_args = []
615 cont_args.append('--logfile=%s' % pjoin(args.logdir,'ipcontroller'))
603 cont_args.append('--logfile=%s' % pjoin(args.logdir,'ipcontroller'))
616
604
617 # Check security settings before proceeding
605 # Check security settings before proceeding
618 if not check_security(args, cont_args):
606 if not check_security(args, cont_args):
619 return
607 return
620
608
621 # See if we are reusing FURL files
609 # See if we are reusing FURL files
622 if not check_reuse(args, cont_args):
610 if not check_reuse(args, cont_args):
623 return
611 return
624
612
625 cl = ControllerLauncher(extra_args=cont_args)
613 cl = ControllerLauncher(extra_args=cont_args)
626 dstart = cl.start()
614 dstart = cl.start()
627 def start_engines(r):
615 def start_engines(r):
628 pbs_set = PBSEngineSet(args.pbsscript)
616 pbs_set = PBSEngineSet(args.pbsscript)
629 def shutdown(signum, frame):
617 def shutdown(signum, frame):
630 log.msg('Stopping pbs cluster')
618 log.msg('Stopping pbs cluster')
631 d = pbs_set.kill()
619 d = pbs_set.kill()
632 d.addBoth(lambda _: cl.interrupt_then_kill(1.0))
620 d.addBoth(lambda _: cl.interrupt_then_kill(1.0))
633 d.addBoth(lambda _: reactor.callLater(2.0, reactor.stop))
621 d.addBoth(lambda _: reactor.callLater(2.0, reactor.stop))
634 signal.signal(signal.SIGINT,shutdown)
622 signal.signal(signal.SIGINT,shutdown)
635 d = pbs_set.start(args.n)
623 d = pbs_set.start(args.n)
636 return d
624 return d
637 config = kernel_config_manager.get_config_obj()
625 config = kernel_config_manager.get_config_obj()
638 furl_file = config['controller']['engine_furl_file']
626 furl_file = config['controller']['engine_furl_file']
639 dstart.addCallback(_delay_start, start_engines, furl_file, args.r)
627 dstart.addCallback(_delay_start, start_engines, furl_file, args.r)
640 dstart.addErrback(_err_and_stop)
628 dstart.addErrback(_err_and_stop)
641
629
642
630
643 def main_ssh(args):
631 def main_ssh(args):
644 """Start a controller on localhost and engines using ssh.
632 """Start a controller on localhost and engines using ssh.
645
633
646 Your clusterfile should look like::
634 Your clusterfile should look like::
647
635
648 send_furl = False # True, if you want
636 send_furl = False # True, if you want
649 engines = {
637 engines = {
650 'engine_host1' : engine_count,
638 'engine_host1' : engine_count,
651 'engine_host2' : engine_count2
639 'engine_host2' : engine_count2
652 }
640 }
653 """
641 """
654 clusterfile = {}
642 clusterfile = {}
655 execfile(args.clusterfile, clusterfile)
643 execfile(args.clusterfile, clusterfile)
656 if not clusterfile.has_key('send_furl'):
644 if not clusterfile.has_key('send_furl'):
657 clusterfile['send_furl'] = False
645 clusterfile['send_furl'] = False
658
646
659 cont_args = []
647 cont_args = []
660 cont_args.append('--logfile=%s' % pjoin(args.logdir,'ipcontroller'))
648 cont_args.append('--logfile=%s' % pjoin(args.logdir,'ipcontroller'))
661
649
662 # Check security settings before proceeding
650 # Check security settings before proceeding
663 if not check_security(args, cont_args):
651 if not check_security(args, cont_args):
664 return
652 return
665
653
666 # See if we are reusing FURL files
654 # See if we are reusing FURL files
667 if not check_reuse(args, cont_args):
655 if not check_reuse(args, cont_args):
668 return
656 return
669
657
670 cl = ControllerLauncher(extra_args=cont_args)
658 cl = ControllerLauncher(extra_args=cont_args)
671 dstart = cl.start()
659 dstart = cl.start()
672 def start_engines(cont_pid):
660 def start_engines(cont_pid):
673 ssh_set = SSHEngineSet(clusterfile['engines'], sshx=args.sshx)
661 ssh_set = SSHEngineSet(clusterfile['engines'], sshx=args.sshx)
674 def shutdown(signum, frame):
662 def shutdown(signum, frame):
675 d = ssh_set.kill()
663 d = ssh_set.kill()
676 cl.interrupt_then_kill(1.0)
664 cl.interrupt_then_kill(1.0)
677 reactor.callLater(2.0, reactor.stop)
665 reactor.callLater(2.0, reactor.stop)
678 signal.signal(signal.SIGINT,shutdown)
666 signal.signal(signal.SIGINT,shutdown)
679 d = ssh_set.start(clusterfile['send_furl'])
667 d = ssh_set.start(clusterfile['send_furl'])
680 return d
668 return d
681 config = kernel_config_manager.get_config_obj()
669 config = kernel_config_manager.get_config_obj()
682 furl_file = config['controller']['engine_furl_file']
670 furl_file = config['controller']['engine_furl_file']
683 dstart.addCallback(_delay_start, start_engines, furl_file, args.r)
671 dstart.addCallback(_delay_start, start_engines, furl_file, args.r)
684 dstart.addErrback(_err_and_stop)
672 dstart.addErrback(_err_and_stop)
685
673
686
674
687 def get_args():
675 def get_args():
688 base_parser = argparse.ArgumentParser(add_help=False)
676 base_parser = argparse.ArgumentParser(add_help=False)
689 base_parser.add_argument(
677 base_parser.add_argument(
690 '-r',
678 '-r',
691 action='store_true',
679 action='store_true',
692 dest='r',
680 dest='r',
693 help='try to reuse FURL files. Use with --client-port and --engine-port'
681 help='try to reuse FURL files. Use with --client-port and --engine-port'
694 )
682 )
695 base_parser.add_argument(
683 base_parser.add_argument(
696 '--client-port',
684 '--client-port',
697 type=int,
685 type=int,
698 dest='client_port',
686 dest='client_port',
699 help='the port the controller will listen on for client connections',
687 help='the port the controller will listen on for client connections',
700 default=0
688 default=0
701 )
689 )
702 base_parser.add_argument(
690 base_parser.add_argument(
703 '--engine-port',
691 '--engine-port',
704 type=int,
692 type=int,
705 dest='engine_port',
693 dest='engine_port',
706 help='the port the controller will listen on for engine connections',
694 help='the port the controller will listen on for engine connections',
707 default=0
695 default=0
708 )
696 )
709 base_parser.add_argument(
697 base_parser.add_argument(
710 '-x',
698 '-x',
711 action='store_true',
699 action='store_true',
712 dest='x',
700 dest='x',
713 help='turn off client security'
701 help='turn off client security'
714 )
702 )
715 base_parser.add_argument(
703 base_parser.add_argument(
716 '-y',
704 '-y',
717 action='store_true',
705 action='store_true',
718 dest='y',
706 dest='y',
719 help='turn off engine security'
707 help='turn off engine security'
720 )
708 )
721 base_parser.add_argument(
709 base_parser.add_argument(
722 "--logdir",
710 "--logdir",
723 type=str,
711 type=str,
724 dest="logdir",
712 dest="logdir",
725 help="directory to put log files (default=$IPYTHONDIR/log)",
713 help="directory to put log files (default=$IPYTHONDIR/log)",
726 default=pjoin(get_ipython_dir(),'log')
714 default=pjoin(get_ipython_dir(),'log')
727 )
715 )
728 base_parser.add_argument(
716 base_parser.add_argument(
729 "-n",
717 "-n",
730 "--num",
718 "--num",
731 type=int,
719 type=int,
732 dest="n",
720 dest="n",
733 default=2,
721 default=2,
734 help="the number of engines to start"
722 help="the number of engines to start"
735 )
723 )
736
724
737 parser = argparse.ArgumentParser(
725 parser = argparse.ArgumentParser(
738 description='IPython cluster startup. This starts a controller and\
726 description='IPython cluster startup. This starts a controller and\
739 engines using various approaches. Use the IPYTHONDIR environment\
727 engines using various approaches. Use the IPYTHONDIR environment\
740 variable to change your IPython directory from the default of\
728 variable to change your IPython directory from the default of\
741 .ipython or _ipython. The log and security subdirectories of your\
729 .ipython or _ipython. The log and security subdirectories of your\
742 IPython directory will be used by this script for log files and\
730 IPython directory will be used by this script for log files and\
743 security files.'
731 security files.'
744 )
732 )
745 subparsers = parser.add_subparsers(
733 subparsers = parser.add_subparsers(
746 help='available cluster types. For help, do "ipcluster TYPE --help"')
734 help='available cluster types. For help, do "ipcluster TYPE --help"')
747
735
748 parser_local = subparsers.add_parser(
736 parser_local = subparsers.add_parser(
749 'local',
737 'local',
750 help='run a local cluster',
738 help='run a local cluster',
751 parents=[base_parser]
739 parents=[base_parser]
752 )
740 )
753 parser_local.set_defaults(func=main_local)
741 parser_local.set_defaults(func=main_local)
754
742
755 parser_mpirun = subparsers.add_parser(
743 parser_mpirun = subparsers.add_parser(
756 'mpirun',
744 'mpirun',
757 help='run a cluster using mpirun (mpiexec also works)',
745 help='run a cluster using mpirun (mpiexec also works)',
758 parents=[base_parser]
746 parents=[base_parser]
759 )
747 )
760 parser_mpirun.add_argument(
748 parser_mpirun.add_argument(
761 "--mpi",
749 "--mpi",
762 type=str,
750 type=str,
763 dest="mpi", # Don't put a default here to allow no MPI support
751 dest="mpi", # Don't put a default here to allow no MPI support
764 help="how to call MPI_Init (default=mpi4py)"
752 help="how to call MPI_Init (default=mpi4py)"
765 )
753 )
766 parser_mpirun.set_defaults(func=main_mpi, cmd='mpirun')
754 parser_mpirun.set_defaults(func=main_mpi, cmd='mpirun')
767
755
768 parser_mpiexec = subparsers.add_parser(
756 parser_mpiexec = subparsers.add_parser(
769 'mpiexec',
757 'mpiexec',
770 help='run a cluster using mpiexec (mpirun also works)',
758 help='run a cluster using mpiexec (mpirun also works)',
771 parents=[base_parser]
759 parents=[base_parser]
772 )
760 )
773 parser_mpiexec.add_argument(
761 parser_mpiexec.add_argument(
774 "--mpi",
762 "--mpi",
775 type=str,
763 type=str,
776 dest="mpi", # Don't put a default here to allow no MPI support
764 dest="mpi", # Don't put a default here to allow no MPI support
777 help="how to call MPI_Init (default=mpi4py)"
765 help="how to call MPI_Init (default=mpi4py)"
778 )
766 )
779 parser_mpiexec.set_defaults(func=main_mpi, cmd='mpiexec')
767 parser_mpiexec.set_defaults(func=main_mpi, cmd='mpiexec')
780
768
781 parser_pbs = subparsers.add_parser(
769 parser_pbs = subparsers.add_parser(
782 'pbs',
770 'pbs',
783 help='run a pbs cluster',
771 help='run a pbs cluster',
784 parents=[base_parser]
772 parents=[base_parser]
785 )
773 )
786 parser_pbs.add_argument(
774 parser_pbs.add_argument(
787 '--pbs-script',
775 '--pbs-script',
788 type=str,
776 type=str,
789 dest='pbsscript',
777 dest='pbsscript',
790 help='PBS script template',
778 help='PBS script template',
791 default='pbs.template'
779 default='pbs.template'
792 )
780 )
793 parser_pbs.set_defaults(func=main_pbs)
781 parser_pbs.set_defaults(func=main_pbs)
794
782
795 parser_ssh = subparsers.add_parser(
783 parser_ssh = subparsers.add_parser(
796 'ssh',
784 'ssh',
797 help='run a cluster using ssh, should have ssh-keys setup',
785 help='run a cluster using ssh, should have ssh-keys setup',
798 parents=[base_parser]
786 parents=[base_parser]
799 )
787 )
800 parser_ssh.add_argument(
788 parser_ssh.add_argument(
801 '--clusterfile',
789 '--clusterfile',
802 type=str,
790 type=str,
803 dest='clusterfile',
791 dest='clusterfile',
804 help='python file describing the cluster',
792 help='python file describing the cluster',
805 default='clusterfile.py',
793 default='clusterfile.py',
806 )
794 )
807 parser_ssh.add_argument(
795 parser_ssh.add_argument(
808 '--sshx',
796 '--sshx',
809 type=str,
797 type=str,
810 dest='sshx',
798 dest='sshx',
811 help='sshx launcher helper'
799 help='sshx launcher helper'
812 )
800 )
813 parser_ssh.set_defaults(func=main_ssh)
801 parser_ssh.set_defaults(func=main_ssh)
814
802
815 args = parser.parse_args()
803 args = parser.parse_args()
816 return args
804 return args
817
805
818 def main():
806 def main():
819 args = get_args()
807 args = get_args()
820 reactor.callWhenRunning(args.func, args)
808 reactor.callWhenRunning(args.func, args)
821 log.startLogging(sys.stdout)
809 log.startLogging(sys.stdout)
822 reactor.run()
810 reactor.run()
823
811
824 if __name__ == '__main__':
812 if __name__ == '__main__':
825 main()
813 main()
@@ -1,70 +1,97
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """ Proxy module for accessing platform specific utility functions.
2 """ Proxy module for accessing platform specific utility functions.
3
3
4 Importing this module should give you the implementations that are correct
4 Importing this module should give you the implementations that are correct
5 for your operation system, from platutils_PLATFORMNAME module.
5 for your operation system, from platutils_PLATFORMNAME module.
6 """
6 """
7
7
8 #*****************************************************************************
8 #*****************************************************************************
9 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
9 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
10 #
10 #
11 # Distributed under the terms of the BSD License. The full license is in
11 # Distributed under the terms of the BSD License. The full license is in
12 # the file COPYING, distributed as part of this software.
12 # the file COPYING, distributed as part of this software.
13 #*****************************************************************************
13 #*****************************************************************************
14
14
15 import os
15 import os
16 import sys
16 import sys
17
17
18 # Import the platform-specific implementations
18 # Import the platform-specific implementations
19 if os.name == 'posix':
19 if os.name == 'posix':
20 import platutils_posix as _platutils
20 import platutils_posix as _platutils
21 elif sys.platform == 'win32':
21 elif sys.platform == 'win32':
22 import platutils_win32 as _platutils
22 import platutils_win32 as _platutils
23 else:
23 else:
24 import platutils_dummy as _platutils
24 import platutils_dummy as _platutils
25 import warnings
25 import warnings
26 warnings.warn("Platutils not available for platform '%s', some features may be missing" %
26 warnings.warn("Platutils not available for platform '%s', some features may be missing" %
27 os.name)
27 os.name)
28 del warnings
28 del warnings
29
29
30
30
31 # Functionality that's logically common to all platforms goes here, each
31 # Functionality that's logically common to all platforms goes here, each
32 # platform-specific module only provides the bits that are OS-dependent.
32 # platform-specific module only provides the bits that are OS-dependent.
33
33
34 # XXX - I'm still not happy with a module global for this, but at least now
34 # XXX - I'm still not happy with a module global for this, but at least now
35 # there is a public, cross-platform way of toggling the term title control on
35 # there is a public, cross-platform way of toggling the term title control on
36 # and off. We should make this a stateful object later on so that each user
36 # and off. We should make this a stateful object later on so that each user
37 # can have its own instance if needed.
37 # can have its own instance if needed.
38 def toggle_set_term_title(val):
38 def toggle_set_term_title(val):
39 """Control whether set_term_title is active or not.
39 """Control whether set_term_title is active or not.
40
40
41 set_term_title() allows writing to the console titlebar. In embedded
41 set_term_title() allows writing to the console titlebar. In embedded
42 widgets this can cause problems, so this call can be used to toggle it on
42 widgets this can cause problems, so this call can be used to toggle it on
43 or off as needed.
43 or off as needed.
44
44
45 The default state of the module is for the function to be disabled.
45 The default state of the module is for the function to be disabled.
46
46
47 Parameters
47 Parameters
48 ----------
48 ----------
49 val : bool
49 val : bool
50 If True, set_term_title() actually writes to the terminal (using the
50 If True, set_term_title() actually writes to the terminal (using the
51 appropriate platform-specific module). If False, it is a no-op.
51 appropriate platform-specific module). If False, it is a no-op.
52 """
52 """
53 _platutils.ignore_termtitle = not(val)
53 _platutils.ignore_termtitle = not(val)
54
54
55
55
56 def set_term_title(title):
56 def set_term_title(title):
57 """Set terminal title using the necessary platform-dependent calls."""
57 """Set terminal title using the necessary platform-dependent calls."""
58
58
59 if _platutils.ignore_termtitle:
59 if _platutils.ignore_termtitle:
60 return
60 return
61 _platutils.set_term_title(title)
61 _platutils.set_term_title(title)
62
62
63
63
64 class FindCmdError(Exception):
65 pass
66
67 def find_cmd(cmd):
68 """Find full path to executable cmd in a cross platform manner.
69
70 This function tries to determine the full path to a command line program
71 using `which` on Unix/Linux/OS X and `win32api` on Windows. Most of the
72 time it will use the version that is first on the users `PATH`. If
73 cmd is `python` return `sys.executable`.
74
75 Parameters
76 ----------
77 cmd : str
78 The command line program to look for.
79 """
80 if cmd == 'python':
81 return sys.executable
82 try:
83 path = _platutils.find_cmd(cmd)
84 except:
85 raise FindCmdError('command could not be found: %s' % cmd)
86 # which returns empty if not found
87 if path == '':
88 raise FindCmdError('command could not be found: %s' % cmd)
89 return path
90
64 #-----------------------------------------------------------------------------
91 #-----------------------------------------------------------------------------
65 # Deprecated functions
92 # Deprecated functions
66 #-----------------------------------------------------------------------------
93 #-----------------------------------------------------------------------------
67 def freeze_term_title():
94 def freeze_term_title():
68 warnings.warn("This function is deprecated, use toggle_set_term_title()")
95 warnings.warn("This function is deprecated, use toggle_set_term_title()")
69 _platutils.ignore_termtitle = True
96 _platutils.ignore_termtitle = True
70
97
@@ -1,25 +1,29
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """ Platform specific utility functions, dummy version
2 """ Platform specific utility functions, dummy version
3
3
4 This has empty implementation of the platutils functions, used for
4 This has empty implementation of the platutils functions, used for
5 unsupported operating systems.
5 unsupported operating systems.
6
6
7 Authors
7 Authors
8 -------
8 -------
9 - Ville Vainio <vivainio@gmail.com>
9 - Ville Vainio <vivainio@gmail.com>
10 """
10 """
11
11
12 #*****************************************************************************
12 #*****************************************************************************
13 # Copyright (C) 2008-2009 The IPython Development Team
13 # Copyright (C) 2008-2009 The IPython Development Team
14 # Copyright (C) 2001-2007 Fernando Perez <fperez@colorado.edu>
14 # Copyright (C) 2001-2007 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
19
20 # This variable is part of the expected API of the module:
20 # This variable is part of the expected API of the module:
21 ignore_termtitle = True
21 ignore_termtitle = True
22
22
23 def set_term_title(*args,**kw):
23 def set_term_title(*args,**kw):
24 """Dummy no-op."""
24 """Dummy no-op."""
25 pass
25 pass
26
27 def find_cmd(cmd):
28 """Find the full path to a command using which."""
29 return os.popen('which %s' % cmd).read().strip()
@@ -1,32 +1,36
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """ Platform specific utility functions, posix version
2 """ Platform specific utility functions, posix version
3
3
4 Importing this module directly is not portable - rather, import platutils
4 Importing this module directly is not portable - rather, import platutils
5 to use these functions in platform agnostic fashion.
5 to use these functions in platform agnostic fashion.
6 """
6 """
7
7
8 #*****************************************************************************
8 #*****************************************************************************
9 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
9 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
10 #
10 #
11 # Distributed under the terms of the BSD License. The full license is in
11 # Distributed under the terms of the BSD License. The full license is in
12 # the file COPYING, distributed as part of this software.
12 # the file COPYING, distributed as part of this software.
13 #*****************************************************************************
13 #*****************************************************************************
14
14
15 import sys
15 import sys
16 import os
16 import os
17
17
18 ignore_termtitle = True
18 ignore_termtitle = True
19
19
20 def _dummy_op(*a, **b):
20 def _dummy_op(*a, **b):
21 """ A no-op function """
21 """ A no-op function """
22
22
23 def _set_term_title_xterm(title):
23 def _set_term_title_xterm(title):
24 """ Change virtual terminal title in xterm-workalikes """
24 """ Change virtual terminal title in xterm-workalikes """
25
25
26 sys.stdout.write('\033]0;%s\007' % title)
26 sys.stdout.write('\033]0;%s\007' % title)
27
27
28
28
29 if os.environ.get('TERM','') == 'xterm':
29 if os.environ.get('TERM','') == 'xterm':
30 set_term_title = _set_term_title_xterm
30 set_term_title = _set_term_title_xterm
31 else:
31 else:
32 set_term_title = _dummy_op
32 set_term_title = _dummy_op
33
34 def find_cmd(cmd):
35 """Find the full path to a command using which."""
36 return os.popen('which %s' % cmd).read().strip()
@@ -1,43 +1,56
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """ Platform specific utility functions, win32 version
2 """ Platform specific utility functions, win32 version
3
3
4 Importing this module directly is not portable - rather, import platutils
4 Importing this module directly is not portable - rather, import platutils
5 to use these functions in platform agnostic fashion.
5 to use these functions in platform agnostic fashion.
6 """
6 """
7
7
8 #*****************************************************************************
8 #*****************************************************************************
9 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
9 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
10 #
10 #
11 # Distributed under the terms of the BSD License. The full license is in
11 # Distributed under the terms of the BSD License. The full license is in
12 # the file COPYING, distributed as part of this software.
12 # the file COPYING, distributed as part of this software.
13 #*****************************************************************************
13 #*****************************************************************************
14
14
15 import os
15 import os
16
16
17 ignore_termtitle = True
17 ignore_termtitle = True
18
18
19 try:
19 try:
20 import ctypes
20 import ctypes
21
21
22 SetConsoleTitleW = ctypes.windll.kernel32.SetConsoleTitleW
22 SetConsoleTitleW = ctypes.windll.kernel32.SetConsoleTitleW
23 SetConsoleTitleW.argtypes = [ctypes.c_wchar_p]
23 SetConsoleTitleW.argtypes = [ctypes.c_wchar_p]
24
24
25 def set_term_title(title):
25 def set_term_title(title):
26 """Set terminal title using ctypes to access the Win32 APIs."""
26 """Set terminal title using ctypes to access the Win32 APIs."""
27 SetConsoleTitleW(title)
27 SetConsoleTitleW(title)
28
28
29 except ImportError:
29 except ImportError:
30 def set_term_title(title):
30 def set_term_title(title):
31 """Set terminal title using the 'title' command."""
31 """Set terminal title using the 'title' command."""
32 global ignore_termtitle
32 global ignore_termtitle
33
33
34 try:
34 try:
35 # Cannot be on network share when issuing system commands
35 # Cannot be on network share when issuing system commands
36 curr = os.getcwd()
36 curr = os.getcwd()
37 os.chdir("C:")
37 os.chdir("C:")
38 ret = os.system("title " + title)
38 ret = os.system("title " + title)
39 finally:
39 finally:
40 os.chdir(curr)
40 os.chdir(curr)
41 if ret:
41 if ret:
42 # non-zero return code signals error, don't try again
42 # non-zero return code signals error, don't try again
43 ignore_termtitle = True
43 ignore_termtitle = True
44
45 def find_cmd(cmd):
46 """Find the full path to a .bat or .exe using the win32api module."""
47 try:
48 import win32api
49 except ImportError:
50 raise ImportError('you need to have pywin32 installed for this to work')
51 else:
52 try:
53 (path, offest) = win32api.SearchPath(os.environ['PATH'],cmd + '.exe')
54 except:
55 (path, offset) = win32api.SearchPath(os.environ['PATH'],cmd + '.bat')
56 return path
General Comments 0
You need to be logged in to leave comments. Login now