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