##// END OF EJS Templates
FakeModule.py => core/fakemodule.py and updated tests and imports.
Brian Granger -
Show More

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

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