##// END OF EJS Templates
- More unicode fixes, properly split user input without generating...
fperez -
Show More

The requested changes are too big and content was truncated. Show full diff

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