##// END OF EJS Templates
upstream » ipython
RSS

Clone from https://github.com/ipython/ipython.git

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