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