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