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