##// END OF EJS Templates
IPyAutocall machinery
vivainio -
Show More

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

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