##// END OF EJS Templates
Moved Itpl.py to deathrow as we already have a copy in external.
Brian Granger -
Show More

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

@@ -1,88 +1,88 b''
1 """ 'editor' hooks for common editors that work well with ipython
1 """ 'editor' hooks for common editors that work well with ipython
2
2
3 They should honor the line number argument, at least.
3 They should honor the line number argument, at least.
4
4
5 Contributions are *very* welcome.
5 Contributions are *very* welcome.
6 """
6 """
7
7
8 from IPython.core import ipapi
8 from IPython.core import ipapi
9 ip = ipapi.get()
9 ip = ipapi.get()
10
10
11 from IPython.Itpl import itplns
11 from IPython.external.Itpl import itplns
12 import os
12 import os
13
13
14 def install_editor(run_template, wait = False):
14 def install_editor(run_template, wait = False):
15 """ Gets a template in format "myeditor bah bah $file bah bah $line"
15 """ Gets a template in format "myeditor bah bah $file bah bah $line"
16
16
17 $file will be replaced by file name, $line by line number (or 0).
17 $file will be replaced by file name, $line by line number (or 0).
18 Installs the editor that is called by IPython, instead of the default
18 Installs the editor that is called by IPython, instead of the default
19 notepad or vi.
19 notepad or vi.
20
20
21 If wait is true, wait until the user presses enter before returning,
21 If wait is true, wait until the user presses enter before returning,
22 to facilitate non-blocking editors that exit immediately after
22 to facilitate non-blocking editors that exit immediately after
23 the call.
23 the call.
24 """
24 """
25
25
26 def call_editor(self, file, line=0):
26 def call_editor(self, file, line=0):
27 if line is None:
27 if line is None:
28 line = 0
28 line = 0
29 cmd = itplns(run_template, locals())
29 cmd = itplns(run_template, locals())
30 print ">",cmd
30 print ">",cmd
31 if os.system(cmd) != 0:
31 if os.system(cmd) != 0:
32 raise ipapi.TryNext()
32 raise ipapi.TryNext()
33 if wait:
33 if wait:
34 raw_input("Press Enter when done editing:")
34 raw_input("Press Enter when done editing:")
35
35
36 ip.set_hook('editor',call_editor)
36 ip.set_hook('editor',call_editor)
37
37
38
38
39 # in these, exe is always the path/name of the executable. Useful
39 # in these, exe is always the path/name of the executable. Useful
40 # if you don't have the editor directory in your path
40 # if you don't have the editor directory in your path
41
41
42 def komodo(exe = 'komodo'):
42 def komodo(exe = 'komodo'):
43 """ Activestate Komodo [Edit] """
43 """ Activestate Komodo [Edit] """
44 install_editor(exe + ' -l $line "$file"', wait = True)
44 install_editor(exe + ' -l $line "$file"', wait = True)
45
45
46 def scite(exe = "scite"):
46 def scite(exe = "scite"):
47 """ SciTE or Sc1 """
47 """ SciTE or Sc1 """
48 install_editor(exe + ' "$file" -goto:$line')
48 install_editor(exe + ' "$file" -goto:$line')
49
49
50 def notepadplusplus(exe = 'notepad++'):
50 def notepadplusplus(exe = 'notepad++'):
51 """ Notepad++ http://notepad-plus.sourceforge.net """
51 """ Notepad++ http://notepad-plus.sourceforge.net """
52 install_editor(exe + ' -n$line "$file"')
52 install_editor(exe + ' -n$line "$file"')
53
53
54 def jed(exe = 'jed'):
54 def jed(exe = 'jed'):
55 """ JED, the lightweight emacsish editor """
55 """ JED, the lightweight emacsish editor """
56 install_editor(exe + ' +$line "$file"')
56 install_editor(exe + ' +$line "$file"')
57
57
58 def idle(exe = None):
58 def idle(exe = None):
59 """ Idle, the editor bundled with python
59 """ Idle, the editor bundled with python
60
60
61 Should be pretty smart about finding the executable.
61 Should be pretty smart about finding the executable.
62 """
62 """
63 if exe is None:
63 if exe is None:
64 import idlelib
64 import idlelib
65 p = os.path.dirname(idlelib.__file__)
65 p = os.path.dirname(idlelib.__file__)
66 exe = p + '/idle.py'
66 exe = p + '/idle.py'
67 install_editor(exe + ' "$file"')
67 install_editor(exe + ' "$file"')
68
68
69 def mate(exe = 'mate'):
69 def mate(exe = 'mate'):
70 """ TextMate, the missing editor"""
70 """ TextMate, the missing editor"""
71 install_editor(exe + ' -w -l $line "$file"')
71 install_editor(exe + ' -w -l $line "$file"')
72
72
73 # these are untested, report any problems
73 # these are untested, report any problems
74
74
75 def emacs(exe = 'emacs'):
75 def emacs(exe = 'emacs'):
76 install_editor(exe + ' +$line "$file"')
76 install_editor(exe + ' +$line "$file"')
77
77
78 def gnuclient(exe= 'gnuclient'):
78 def gnuclient(exe= 'gnuclient'):
79 install_editor(exe + ' -nw +$line "$file"')
79 install_editor(exe + ' -nw +$line "$file"')
80
80
81 def crimson_editor(exe = 'cedt.exe'):
81 def crimson_editor(exe = 'cedt.exe'):
82 install_editor(exe + ' /L:$line "$file"')
82 install_editor(exe + ' /L:$line "$file"')
83
83
84 def kate(exe = 'kate'):
84 def kate(exe = 'kate'):
85 install_editor(exe + ' -u -l $line "$file"')
85 install_editor(exe + ' -u -l $line "$file"')
86
86
87
87
88 No newline at end of file
88
@@ -1,270 +1,270 b''
1 """Shell mode for IPython.
1 """Shell mode for IPython.
2
2
3 Start ipython in shell mode by invoking "ipython -p sh"
3 Start ipython in shell mode by invoking "ipython -p sh"
4
4
5 (the old version, "ipython -p pysh" still works but this is the more "modern"
5 (the old version, "ipython -p pysh" still works but this is the more "modern"
6 shell mode and is recommended for users who don't care about pysh-mode
6 shell mode and is recommended for users who don't care about pysh-mode
7 compatibility)
7 compatibility)
8 """
8 """
9
9
10 from IPython.core import ipapi
10 from IPython.core import ipapi
11 import os,re,textwrap
11 import os,re,textwrap
12
12
13 # The import below effectively obsoletes your old-style ipythonrc[.ini],
13 # The import below effectively obsoletes your old-style ipythonrc[.ini],
14 # so consider yourself warned!
14 # so consider yourself warned!
15
15
16 import ipy_defaults
16 import ipy_defaults
17
17
18 def main():
18 def main():
19 ip = ipapi.get()
19 ip = ipapi.get()
20 o = ip.options
20 o = ip.options
21 # autocall to "full" mode (smart mode is default, I like full mode)
21 # autocall to "full" mode (smart mode is default, I like full mode)
22
22
23 o.autocall = 2
23 o.autocall = 2
24
24
25 # Jason Orendorff's path class is handy to have in user namespace
25 # Jason Orendorff's path class is handy to have in user namespace
26 # if you are doing shell-like stuff
26 # if you are doing shell-like stuff
27 try:
27 try:
28 ip.ex("from IPython.external.path import path" )
28 ip.ex("from IPython.external.path import path" )
29 except ImportError:
29 except ImportError:
30 pass
30 pass
31
31
32 # beefed up %env is handy in shell mode
32 # beefed up %env is handy in shell mode
33 import envpersist
33 import envpersist
34
34
35 # To see where mycmd resides (in path/aliases), do %which mycmd
35 # To see where mycmd resides (in path/aliases), do %which mycmd
36 import ipy_which
36 import ipy_which
37
37
38 # tab completers for hg, svn, ...
38 # tab completers for hg, svn, ...
39 import ipy_app_completers
39 import ipy_app_completers
40
40
41 # To make executables foo and bar in mybin usable without PATH change, do:
41 # To make executables foo and bar in mybin usable without PATH change, do:
42 # %rehashdir c:/mybin
42 # %rehashdir c:/mybin
43 # %store foo
43 # %store foo
44 # %store bar
44 # %store bar
45 import ipy_rehashdir
45 import ipy_rehashdir
46
46
47 # does not work without subprocess module!
47 # does not work without subprocess module!
48 #import ipy_signals
48 #import ipy_signals
49
49
50 ip.ex('import os')
50 ip.ex('import os')
51 ip.ex("def up(): os.chdir('..')")
51 ip.ex("def up(): os.chdir('..')")
52 ip.user_ns['LA'] = LastArgFinder()
52 ip.user_ns['LA'] = LastArgFinder()
53
53
54 # You can assign to _prompt_title variable
54 # You can assign to _prompt_title variable
55 # to provide some extra information for prompt
55 # to provide some extra information for prompt
56 # (e.g. the current mode, host/username...)
56 # (e.g. the current mode, host/username...)
57
57
58 ip.user_ns['_prompt_title'] = ''
58 ip.user_ns['_prompt_title'] = ''
59
59
60 # Nice prompt
60 # Nice prompt
61 o.prompt_in1= r'\C_Green${_prompt_title}\C_LightBlue[\C_LightCyan\Y2\C_LightBlue]\C_Green|\#> '
61 o.prompt_in1= r'\C_Green${_prompt_title}\C_LightBlue[\C_LightCyan\Y2\C_LightBlue]\C_Green|\#> '
62 o.prompt_in2= r'\C_Green|\C_LightGreen\D\C_Green> '
62 o.prompt_in2= r'\C_Green|\C_LightGreen\D\C_Green> '
63 o.prompt_out= '<\#> '
63 o.prompt_out= '<\#> '
64
64
65 from IPython import Release
65 from IPython import Release
66
66
67 import sys
67 import sys
68 # Non-chatty banner
68 # Non-chatty banner
69 o.banner = "IPython %s [on Py %s]\n" % (Release.version,sys.version.split(None,1)[0])
69 o.banner = "IPython %s [on Py %s]\n" % (Release.version,sys.version.split(None,1)[0])
70
70
71
71
72 ip.IP.default_option('cd','-q')
72 ip.IP.default_option('cd','-q')
73 ip.IP.default_option('macro', '-r')
73 ip.IP.default_option('macro', '-r')
74 # If you only rarely want to execute the things you %edit...
74 # If you only rarely want to execute the things you %edit...
75 #ip.IP.default_option('edit','-x')
75 #ip.IP.default_option('edit','-x')
76
76
77
77
78 o.prompts_pad_left="1"
78 o.prompts_pad_left="1"
79 # Remove all blank lines in between prompts, like a normal shell.
79 # Remove all blank lines in between prompts, like a normal shell.
80 o.separate_in="0"
80 o.separate_in="0"
81 o.separate_out="0"
81 o.separate_out="0"
82 o.separate_out2="0"
82 o.separate_out2="0"
83
83
84 # now alias all syscommands
84 # now alias all syscommands
85
85
86 db = ip.db
86 db = ip.db
87
87
88 syscmds = db.get("syscmdlist",[] )
88 syscmds = db.get("syscmdlist",[] )
89 if not syscmds:
89 if not syscmds:
90 print textwrap.dedent("""
90 print textwrap.dedent("""
91 System command list not initialized, probably the first run...
91 System command list not initialized, probably the first run...
92 running %rehashx to refresh the command list. Run %rehashx
92 running %rehashx to refresh the command list. Run %rehashx
93 again to refresh command list (after installing new software etc.)
93 again to refresh command list (after installing new software etc.)
94 """)
94 """)
95 ip.magic('rehashx')
95 ip.magic('rehashx')
96 syscmds = db.get("syscmdlist")
96 syscmds = db.get("syscmdlist")
97
97
98 # lowcase aliases on win32 only
98 # lowcase aliases on win32 only
99 if os.name == 'posix':
99 if os.name == 'posix':
100 mapper = lambda s:s
100 mapper = lambda s:s
101 else:
101 else:
102 def mapper(s): return s.lower()
102 def mapper(s): return s.lower()
103
103
104 for cmd in syscmds:
104 for cmd in syscmds:
105 # print "sys",cmd #dbg
105 # print "sys",cmd #dbg
106 noext, ext = os.path.splitext(cmd)
106 noext, ext = os.path.splitext(cmd)
107 if ext.lower() == '.exe':
107 if ext.lower() == '.exe':
108 cmd = noext
108 cmd = noext
109
109
110 key = mapper(cmd)
110 key = mapper(cmd)
111 if key not in ip.IP.alias_table:
111 if key not in ip.IP.alias_table:
112 # Dots will be removed from alias names, since ipython
112 # Dots will be removed from alias names, since ipython
113 # assumes names with dots to be python code
113 # assumes names with dots to be python code
114
114
115 ip.defalias(key.replace('.',''), cmd)
115 ip.defalias(key.replace('.',''), cmd)
116
116
117 # mglob combines 'find', recursion, exclusion... '%mglob?' to learn more
117 # mglob combines 'find', recursion, exclusion... '%mglob?' to learn more
118 ip.load("IPython.external.mglob")
118 ip.load("IPython.external.mglob")
119
119
120 # win32 is crippled w/o cygwin, try to help it a little bit
120 # win32 is crippled w/o cygwin, try to help it a little bit
121 if sys.platform == 'win32':
121 if sys.platform == 'win32':
122 if 'cygwin' in os.environ['PATH'].lower():
122 if 'cygwin' in os.environ['PATH'].lower():
123 # use the colors of cygwin ls (recommended)
123 # use the colors of cygwin ls (recommended)
124 ip.defalias('d', 'ls -F --color=auto')
124 ip.defalias('d', 'ls -F --color=auto')
125 else:
125 else:
126 # get icp, imv, imkdir, igrep, irm,...
126 # get icp, imv, imkdir, igrep, irm,...
127 ip.load('ipy_fsops')
127 ip.load('ipy_fsops')
128
128
129 # and the next best thing to real 'ls -F'
129 # and the next best thing to real 'ls -F'
130 ip.defalias('d','dir /w /og /on')
130 ip.defalias('d','dir /w /og /on')
131
131
132 ip.set_hook('input_prefilter', slash_prefilter_f)
132 ip.set_hook('input_prefilter', slash_prefilter_f)
133 extend_shell_behavior(ip)
133 extend_shell_behavior(ip)
134
134
135 class LastArgFinder:
135 class LastArgFinder:
136 """ Allow $LA to work as "last argument of previous command", like $! in bash
136 """ Allow $LA to work as "last argument of previous command", like $! in bash
137
137
138 To call this in normal IPython code, do LA()
138 To call this in normal IPython code, do LA()
139 """
139 """
140 def __call__(self, hist_idx = None):
140 def __call__(self, hist_idx = None):
141 ip = ipapi.get()
141 ip = ipapi.get()
142 if hist_idx is None:
142 if hist_idx is None:
143 return str(self)
143 return str(self)
144 return ip.IP.input_hist_raw[hist_idx].strip().split()[-1]
144 return ip.IP.input_hist_raw[hist_idx].strip().split()[-1]
145 def __str__(self):
145 def __str__(self):
146 ip = ipapi.get()
146 ip = ipapi.get()
147 for cmd in reversed(ip.IP.input_hist_raw):
147 for cmd in reversed(ip.IP.input_hist_raw):
148 parts = cmd.strip().split()
148 parts = cmd.strip().split()
149 if len(parts) < 2 or parts[-1] in ['$LA', 'LA()']:
149 if len(parts) < 2 or parts[-1] in ['$LA', 'LA()']:
150 continue
150 continue
151 return parts[-1]
151 return parts[-1]
152 return ""
152 return ""
153
153
154 def slash_prefilter_f(self,line):
154 def slash_prefilter_f(self,line):
155 """ ./foo, ~/foo and /bin/foo now run foo as system command
155 """ ./foo, ~/foo and /bin/foo now run foo as system command
156
156
157 Removes the need for doing !./foo, !~/foo or !/bin/foo
157 Removes the need for doing !./foo, !~/foo or !/bin/foo
158 """
158 """
159 from IPython.utils import genutils
159 from IPython.utils import genutils
160 if re.match('(?:[.~]|/[a-zA-Z_0-9]+)/', line):
160 if re.match('(?:[.~]|/[a-zA-Z_0-9]+)/', line):
161 return "_ip.system(" + genutils.make_quoted_expr(line)+")"
161 return "_ip.system(" + genutils.make_quoted_expr(line)+")"
162 raise ipapi.TryNext
162 raise ipapi.TryNext
163
163
164 # XXX You do not need to understand the next function!
164 # XXX You do not need to understand the next function!
165 # This should probably be moved out of profile
165 # This should probably be moved out of profile
166
166
167 def extend_shell_behavior(ip):
167 def extend_shell_behavior(ip):
168
168
169 # Instead of making signature a global variable tie it to IPSHELL.
169 # Instead of making signature a global variable tie it to IPSHELL.
170 # In future if it is required to distinguish between different
170 # In future if it is required to distinguish between different
171 # shells we can assign a signature per shell basis
171 # shells we can assign a signature per shell basis
172 ip.IP.__sig__ = 0xa005
172 ip.IP.__sig__ = 0xa005
173 # mark the IPSHELL with this signature
173 # mark the IPSHELL with this signature
174 ip.IP.user_ns['__builtins__'].__dict__['__sig__'] = ip.IP.__sig__
174 ip.IP.user_ns['__builtins__'].__dict__['__sig__'] = ip.IP.__sig__
175
175
176 from IPython.Itpl import ItplNS
176 from IPython.external.Itpl import ItplNS
177 from IPython.genutils import shell
177 from IPython.utils.genutils import shell
178 # utility to expand user variables via Itpl
178 # utility to expand user variables via Itpl
179 # xxx do something sensible with depth?
179 # xxx do something sensible with depth?
180 ip.IP.var_expand = lambda cmd, lvars=None, depth=2: \
180 ip.IP.var_expand = lambda cmd, lvars=None, depth=2: \
181 str(ItplNS(cmd, ip.IP.user_ns, get_locals()))
181 str(ItplNS(cmd, ip.IP.user_ns, get_locals()))
182
182
183 def get_locals():
183 def get_locals():
184 """ Substituting a variable through Itpl deep inside the IPSHELL stack
184 """ Substituting a variable through Itpl deep inside the IPSHELL stack
185 requires the knowledge of all the variables in scope upto the last
185 requires the knowledge of all the variables in scope upto the last
186 IPSHELL frame. This routine simply merges all the local variables
186 IPSHELL frame. This routine simply merges all the local variables
187 on the IPSHELL stack without worrying about their scope rules
187 on the IPSHELL stack without worrying about their scope rules
188 """
188 """
189 import sys
189 import sys
190 # note lambda expression constitues a function call
190 # note lambda expression constitues a function call
191 # hence fno should be incremented by one
191 # hence fno should be incremented by one
192 getsig = lambda fno: sys._getframe(fno+1).f_globals \
192 getsig = lambda fno: sys._getframe(fno+1).f_globals \
193 ['__builtins__'].__dict__['__sig__']
193 ['__builtins__'].__dict__['__sig__']
194 getlvars = lambda fno: sys._getframe(fno+1).f_locals
194 getlvars = lambda fno: sys._getframe(fno+1).f_locals
195 # trackback until we enter the IPSHELL
195 # trackback until we enter the IPSHELL
196 frame_no = 1
196 frame_no = 1
197 sig = ip.IP.__sig__
197 sig = ip.IP.__sig__
198 fsig = ~sig
198 fsig = ~sig
199 while fsig != sig :
199 while fsig != sig :
200 try:
200 try:
201 fsig = getsig(frame_no)
201 fsig = getsig(frame_no)
202 except (AttributeError, KeyError):
202 except (AttributeError, KeyError):
203 frame_no += 1
203 frame_no += 1
204 except ValueError:
204 except ValueError:
205 # stack is depleted
205 # stack is depleted
206 # call did not originate from IPSHELL
206 # call did not originate from IPSHELL
207 return {}
207 return {}
208 first_frame = frame_no
208 first_frame = frame_no
209 # walk further back until we exit from IPSHELL or deplete stack
209 # walk further back until we exit from IPSHELL or deplete stack
210 try:
210 try:
211 while(sig == getsig(frame_no+1)):
211 while(sig == getsig(frame_no+1)):
212 frame_no += 1
212 frame_no += 1
213 except (AttributeError, KeyError, ValueError):
213 except (AttributeError, KeyError, ValueError):
214 pass
214 pass
215 # merge the locals from top down hence overriding
215 # merge the locals from top down hence overriding
216 # any re-definitions of variables, functions etc.
216 # any re-definitions of variables, functions etc.
217 lvars = {}
217 lvars = {}
218 for fno in range(frame_no, first_frame-1, -1):
218 for fno in range(frame_no, first_frame-1, -1):
219 lvars.update(getlvars(fno))
219 lvars.update(getlvars(fno))
220 #print '\n'*5, first_frame, frame_no, '\n', lvars, '\n'*5 #dbg
220 #print '\n'*5, first_frame, frame_no, '\n', lvars, '\n'*5 #dbg
221 return lvars
221 return lvars
222
222
223 def _runlines(lines):
223 def _runlines(lines):
224 """Run a string of one or more lines of source.
224 """Run a string of one or more lines of source.
225
225
226 This method is capable of running a string containing multiple source
226 This method is capable of running a string containing multiple source
227 lines, as if they had been entered at the IPython prompt. Since it
227 lines, as if they had been entered at the IPython prompt. Since it
228 exposes IPython's processing machinery, the given strings can contain
228 exposes IPython's processing machinery, the given strings can contain
229 magic calls (%magic), special shell access (!cmd), etc."""
229 magic calls (%magic), special shell access (!cmd), etc."""
230
230
231 # We must start with a clean buffer, in case this is run from an
231 # We must start with a clean buffer, in case this is run from an
232 # interactive IPython session (via a magic, for example).
232 # interactive IPython session (via a magic, for example).
233 ip.IP.resetbuffer()
233 ip.IP.resetbuffer()
234 lines = lines.split('\n')
234 lines = lines.split('\n')
235 more = 0
235 more = 0
236 command = ''
236 command = ''
237 for line in lines:
237 for line in lines:
238 # skip blank lines so we don't mess up the prompt counter, but do
238 # skip blank lines so we don't mess up the prompt counter, but do
239 # NOT skip even a blank line if we are in a code block (more is
239 # NOT skip even a blank line if we are in a code block (more is
240 # true)
240 # true)
241 # if command is not empty trim the line
241 # if command is not empty trim the line
242 if command != '' :
242 if command != '' :
243 line = line.strip()
243 line = line.strip()
244 # add the broken line to the command
244 # add the broken line to the command
245 if line and line[-1] == '\\' :
245 if line and line[-1] == '\\' :
246 command += line[0:-1] + ' '
246 command += line[0:-1] + ' '
247 more = True
247 more = True
248 continue
248 continue
249 else :
249 else :
250 # add the last (current) line to the command
250 # add the last (current) line to the command
251 command += line
251 command += line
252 if command or more:
252 if command or more:
253 # push to raw history, so hist line numbers stay in sync
253 # push to raw history, so hist line numbers stay in sync
254 ip.IP.input_hist_raw.append("# " + command + "\n")
254 ip.IP.input_hist_raw.append("# " + command + "\n")
255
255
256 more = ip.IP.push(ip.IP.prefilter(command,more))
256 more = ip.IP.push(ip.IP.prefilter(command,more))
257 command = ''
257 command = ''
258 # IPython's runsource returns None if there was an error
258 # IPython's runsource returns None if there was an error
259 # compiling the code. This allows us to stop processing right
259 # compiling the code. This allows us to stop processing right
260 # away, so the user gets the error message at the right place.
260 # away, so the user gets the error message at the right place.
261 if more is None:
261 if more is None:
262 break
262 break
263 # final newline in case the input didn't have it, so that the code
263 # final newline in case the input didn't have it, so that the code
264 # actually does get executed
264 # actually does get executed
265 if more:
265 if more:
266 ip.IP.push('\n')
266 ip.IP.push('\n')
267
267
268 ip.IP.runlines = _runlines
268 ip.IP.runlines = _runlines
269
269
270 main()
270 main()
@@ -1,68 +1,68 b''
1 #!/usr/bin/env python
1 #!/usr/bin/env python
2
2
3 """ IPython extension: Render templates from variables and paste to clipbard """
3 """ IPython extension: Render templates from variables and paste to clipbard """
4
4
5 from IPython.core import ipapi
5 from IPython.core import ipapi
6
6
7 ip = ipapi.get()
7 ip = ipapi.get()
8
8
9 from string import Template
9 from string import Template
10 import sys,os
10 import sys,os
11
11
12 from IPython.Itpl import itplns
12 from IPython.external.Itpl import itplns
13
13
14 def toclip_w32(s):
14 def toclip_w32(s):
15 """ Places contents of s to clipboard
15 """ Places contents of s to clipboard
16
16
17 Needs pyvin32 to work:
17 Needs pyvin32 to work:
18 http://sourceforge.net/projects/pywin32/
18 http://sourceforge.net/projects/pywin32/
19 """
19 """
20 import win32clipboard as cl
20 import win32clipboard as cl
21 import win32con
21 import win32con
22 cl.OpenClipboard()
22 cl.OpenClipboard()
23 cl.EmptyClipboard()
23 cl.EmptyClipboard()
24 cl.SetClipboardText( s.replace('\n','\r\n' ))
24 cl.SetClipboardText( s.replace('\n','\r\n' ))
25 cl.CloseClipboard()
25 cl.CloseClipboard()
26
26
27 try:
27 try:
28 import win32clipboard
28 import win32clipboard
29 toclip = toclip_w32
29 toclip = toclip_w32
30 except ImportError:
30 except ImportError:
31 def toclip(s): pass
31 def toclip(s): pass
32
32
33
33
34 def render(tmpl):
34 def render(tmpl):
35 """ Render a template (Itpl format) from ipython variables
35 """ Render a template (Itpl format) from ipython variables
36
36
37 Example:
37 Example:
38
38
39 $ import ipy_render
39 $ import ipy_render
40 $ my_name = 'Bob' # %store this for convenience
40 $ my_name = 'Bob' # %store this for convenience
41 $ t_submission_form = "Submission report, author: $my_name" # %store also
41 $ t_submission_form = "Submission report, author: $my_name" # %store also
42 $ render t_submission_form
42 $ render t_submission_form
43
43
44 => returns "Submission report, author: Bob" and copies to clipboard on win32
44 => returns "Submission report, author: Bob" and copies to clipboard on win32
45
45
46 # if template exist as a file, read it. Note: ;f hei vaan => f("hei vaan")
46 # if template exist as a file, read it. Note: ;f hei vaan => f("hei vaan")
47 $ ;render c:/templates/greeting.txt
47 $ ;render c:/templates/greeting.txt
48
48
49 Template examples (Ka-Ping Yee's Itpl library):
49 Template examples (Ka-Ping Yee's Itpl library):
50
50
51 Here is a $string.
51 Here is a $string.
52 Here is a $module.member.
52 Here is a $module.member.
53 Here is an $object.member.
53 Here is an $object.member.
54 Here is a $functioncall(with, arguments).
54 Here is a $functioncall(with, arguments).
55 Here is an ${arbitrary + expression}.
55 Here is an ${arbitrary + expression}.
56 Here is an $array[3] member.
56 Here is an $array[3] member.
57 Here is a $dictionary['member'].
57 Here is a $dictionary['member'].
58 """
58 """
59
59
60 if os.path.isfile(tmpl):
60 if os.path.isfile(tmpl):
61 tmpl = open(tmpl).read()
61 tmpl = open(tmpl).read()
62
62
63 res = itplns(tmpl, ip.user_ns)
63 res = itplns(tmpl, ip.user_ns)
64 toclip(res)
64 toclip(res)
65 return res
65 return res
66
66
67 ip.to_user_ns('render')
67 ip.to_user_ns('render')
68 No newline at end of file
68
1 NO CONTENT: modified file
NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
@@ -1,607 +1,607 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Tools for inspecting Python objects.
2 """Tools for inspecting Python objects.
3
3
4 Uses syntax highlighting for presenting the various information elements.
4 Uses syntax highlighting for presenting the various information elements.
5
5
6 Similar in spirit to the inspect module, but all calls take a name argument to
6 Similar in spirit to the inspect module, but all calls take a name argument to
7 reference the name under which an object is being read.
7 reference the name under which an object is being read.
8 """
8 """
9
9
10 #*****************************************************************************
10 #*****************************************************************************
11 # Copyright (C) 2001-2004 Fernando Perez <fperez@colorado.edu>
11 # Copyright (C) 2001-2004 Fernando Perez <fperez@colorado.edu>
12 #
12 #
13 # Distributed under the terms of the BSD License. The full license is in
13 # Distributed under the terms of the BSD License. The full license is in
14 # the file COPYING, distributed as part of this software.
14 # the file COPYING, distributed as part of this software.
15 #*****************************************************************************
15 #*****************************************************************************
16
16
17 __all__ = ['Inspector','InspectColors']
17 __all__ = ['Inspector','InspectColors']
18
18
19 # stdlib modules
19 # stdlib modules
20 import __builtin__
20 import __builtin__
21 import StringIO
21 import StringIO
22 import inspect
22 import inspect
23 import linecache
23 import linecache
24 import os
24 import os
25 import string
25 import string
26 import sys
26 import sys
27 import types
27 import types
28
28
29 # IPython's own
29 # IPython's own
30 from IPython import PyColorize
30 from IPython import PyColorize
31 from IPython.utils.genutils import page,indent,Term
31 from IPython.utils.genutils import page,indent,Term
32 from IPython.Itpl import itpl
32 from IPython.external.Itpl import itpl
33 from IPython.wildcard import list_namespace
33 from IPython.wildcard import list_namespace
34 from IPython.utils.coloransi import *
34 from IPython.utils.coloransi import *
35
35
36 #****************************************************************************
36 #****************************************************************************
37 # HACK!!! This is a crude fix for bugs in python 2.3's inspect module. We
37 # HACK!!! This is a crude fix for bugs in python 2.3's inspect module. We
38 # simply monkeypatch inspect with code copied from python 2.4.
38 # simply monkeypatch inspect with code copied from python 2.4.
39 if sys.version_info[:2] == (2,3):
39 if sys.version_info[:2] == (2,3):
40 from inspect import ismodule, getabsfile, modulesbyfile
40 from inspect import ismodule, getabsfile, modulesbyfile
41 def getmodule(object):
41 def getmodule(object):
42 """Return the module an object was defined in, or None if not found."""
42 """Return the module an object was defined in, or None if not found."""
43 if ismodule(object):
43 if ismodule(object):
44 return object
44 return object
45 if hasattr(object, '__module__'):
45 if hasattr(object, '__module__'):
46 return sys.modules.get(object.__module__)
46 return sys.modules.get(object.__module__)
47 try:
47 try:
48 file = getabsfile(object)
48 file = getabsfile(object)
49 except TypeError:
49 except TypeError:
50 return None
50 return None
51 if file in modulesbyfile:
51 if file in modulesbyfile:
52 return sys.modules.get(modulesbyfile[file])
52 return sys.modules.get(modulesbyfile[file])
53 for module in sys.modules.values():
53 for module in sys.modules.values():
54 if hasattr(module, '__file__'):
54 if hasattr(module, '__file__'):
55 modulesbyfile[
55 modulesbyfile[
56 os.path.realpath(
56 os.path.realpath(
57 getabsfile(module))] = module.__name__
57 getabsfile(module))] = module.__name__
58 if file in modulesbyfile:
58 if file in modulesbyfile:
59 return sys.modules.get(modulesbyfile[file])
59 return sys.modules.get(modulesbyfile[file])
60 main = sys.modules['__main__']
60 main = sys.modules['__main__']
61 if not hasattr(object, '__name__'):
61 if not hasattr(object, '__name__'):
62 return None
62 return None
63 if hasattr(main, object.__name__):
63 if hasattr(main, object.__name__):
64 mainobject = getattr(main, object.__name__)
64 mainobject = getattr(main, object.__name__)
65 if mainobject is object:
65 if mainobject is object:
66 return main
66 return main
67 builtin = sys.modules['__builtin__']
67 builtin = sys.modules['__builtin__']
68 if hasattr(builtin, object.__name__):
68 if hasattr(builtin, object.__name__):
69 builtinobject = getattr(builtin, object.__name__)
69 builtinobject = getattr(builtin, object.__name__)
70 if builtinobject is object:
70 if builtinobject is object:
71 return builtin
71 return builtin
72
72
73 inspect.getmodule = getmodule
73 inspect.getmodule = getmodule
74
74
75 #****************************************************************************
75 #****************************************************************************
76 # Builtin color schemes
76 # Builtin color schemes
77
77
78 Colors = TermColors # just a shorthand
78 Colors = TermColors # just a shorthand
79
79
80 # Build a few color schemes
80 # Build a few color schemes
81 NoColor = ColorScheme(
81 NoColor = ColorScheme(
82 'NoColor',{
82 'NoColor',{
83 'header' : Colors.NoColor,
83 'header' : Colors.NoColor,
84 'normal' : Colors.NoColor # color off (usu. Colors.Normal)
84 'normal' : Colors.NoColor # color off (usu. Colors.Normal)
85 } )
85 } )
86
86
87 LinuxColors = ColorScheme(
87 LinuxColors = ColorScheme(
88 'Linux',{
88 'Linux',{
89 'header' : Colors.LightRed,
89 'header' : Colors.LightRed,
90 'normal' : Colors.Normal # color off (usu. Colors.Normal)
90 'normal' : Colors.Normal # color off (usu. Colors.Normal)
91 } )
91 } )
92
92
93 LightBGColors = ColorScheme(
93 LightBGColors = ColorScheme(
94 'LightBG',{
94 'LightBG',{
95 'header' : Colors.Red,
95 'header' : Colors.Red,
96 'normal' : Colors.Normal # color off (usu. Colors.Normal)
96 'normal' : Colors.Normal # color off (usu. Colors.Normal)
97 } )
97 } )
98
98
99 # Build table of color schemes (needed by the parser)
99 # Build table of color schemes (needed by the parser)
100 InspectColors = ColorSchemeTable([NoColor,LinuxColors,LightBGColors],
100 InspectColors = ColorSchemeTable([NoColor,LinuxColors,LightBGColors],
101 'Linux')
101 'Linux')
102
102
103 #****************************************************************************
103 #****************************************************************************
104 # Auxiliary functions
104 # Auxiliary functions
105 def getdoc(obj):
105 def getdoc(obj):
106 """Stable wrapper around inspect.getdoc.
106 """Stable wrapper around inspect.getdoc.
107
107
108 This can't crash because of attribute problems.
108 This can't crash because of attribute problems.
109
109
110 It also attempts to call a getdoc() method on the given object. This
110 It also attempts to call a getdoc() method on the given object. This
111 allows objects which provide their docstrings via non-standard mechanisms
111 allows objects which provide their docstrings via non-standard mechanisms
112 (like Pyro proxies) to still be inspected by ipython's ? system."""
112 (like Pyro proxies) to still be inspected by ipython's ? system."""
113
113
114 ds = None # default return value
114 ds = None # default return value
115 try:
115 try:
116 ds = inspect.getdoc(obj)
116 ds = inspect.getdoc(obj)
117 except:
117 except:
118 # Harden against an inspect failure, which can occur with
118 # Harden against an inspect failure, which can occur with
119 # SWIG-wrapped extensions.
119 # SWIG-wrapped extensions.
120 pass
120 pass
121 # Allow objects to offer customized documentation via a getdoc method:
121 # Allow objects to offer customized documentation via a getdoc method:
122 try:
122 try:
123 ds2 = obj.getdoc()
123 ds2 = obj.getdoc()
124 except:
124 except:
125 pass
125 pass
126 else:
126 else:
127 # if we get extra info, we add it to the normal docstring.
127 # if we get extra info, we add it to the normal docstring.
128 if ds is None:
128 if ds is None:
129 ds = ds2
129 ds = ds2
130 else:
130 else:
131 ds = '%s\n%s' % (ds,ds2)
131 ds = '%s\n%s' % (ds,ds2)
132 return ds
132 return ds
133
133
134
134
135 def getsource(obj,is_binary=False):
135 def getsource(obj,is_binary=False):
136 """Wrapper around inspect.getsource.
136 """Wrapper around inspect.getsource.
137
137
138 This can be modified by other projects to provide customized source
138 This can be modified by other projects to provide customized source
139 extraction.
139 extraction.
140
140
141 Inputs:
141 Inputs:
142
142
143 - obj: an object whose source code we will attempt to extract.
143 - obj: an object whose source code we will attempt to extract.
144
144
145 Optional inputs:
145 Optional inputs:
146
146
147 - is_binary: whether the object is known to come from a binary source.
147 - is_binary: whether the object is known to come from a binary source.
148 This implementation will skip returning any output for binary objects, but
148 This implementation will skip returning any output for binary objects, but
149 custom extractors may know how to meaningfully process them."""
149 custom extractors may know how to meaningfully process them."""
150
150
151 if is_binary:
151 if is_binary:
152 return None
152 return None
153 else:
153 else:
154 try:
154 try:
155 src = inspect.getsource(obj)
155 src = inspect.getsource(obj)
156 except TypeError:
156 except TypeError:
157 if hasattr(obj,'__class__'):
157 if hasattr(obj,'__class__'):
158 src = inspect.getsource(obj.__class__)
158 src = inspect.getsource(obj.__class__)
159 return src
159 return src
160
160
161 def getargspec(obj):
161 def getargspec(obj):
162 """Get the names and default values of a function's arguments.
162 """Get the names and default values of a function's arguments.
163
163
164 A tuple of four things is returned: (args, varargs, varkw, defaults).
164 A tuple of four things is returned: (args, varargs, varkw, defaults).
165 'args' is a list of the argument names (it may contain nested lists).
165 'args' is a list of the argument names (it may contain nested lists).
166 'varargs' and 'varkw' are the names of the * and ** arguments or None.
166 'varargs' and 'varkw' are the names of the * and ** arguments or None.
167 'defaults' is an n-tuple of the default values of the last n arguments.
167 'defaults' is an n-tuple of the default values of the last n arguments.
168
168
169 Modified version of inspect.getargspec from the Python Standard
169 Modified version of inspect.getargspec from the Python Standard
170 Library."""
170 Library."""
171
171
172 if inspect.isfunction(obj):
172 if inspect.isfunction(obj):
173 func_obj = obj
173 func_obj = obj
174 elif inspect.ismethod(obj):
174 elif inspect.ismethod(obj):
175 func_obj = obj.im_func
175 func_obj = obj.im_func
176 else:
176 else:
177 raise TypeError, 'arg is not a Python function'
177 raise TypeError, 'arg is not a Python function'
178 args, varargs, varkw = inspect.getargs(func_obj.func_code)
178 args, varargs, varkw = inspect.getargs(func_obj.func_code)
179 return args, varargs, varkw, func_obj.func_defaults
179 return args, varargs, varkw, func_obj.func_defaults
180
180
181 #****************************************************************************
181 #****************************************************************************
182 # Class definitions
182 # Class definitions
183
183
184 class myStringIO(StringIO.StringIO):
184 class myStringIO(StringIO.StringIO):
185 """Adds a writeln method to normal StringIO."""
185 """Adds a writeln method to normal StringIO."""
186 def writeln(self,*arg,**kw):
186 def writeln(self,*arg,**kw):
187 """Does a write() and then a write('\n')"""
187 """Does a write() and then a write('\n')"""
188 self.write(*arg,**kw)
188 self.write(*arg,**kw)
189 self.write('\n')
189 self.write('\n')
190
190
191
191
192 class Inspector:
192 class Inspector:
193 def __init__(self,color_table,code_color_table,scheme,
193 def __init__(self,color_table,code_color_table,scheme,
194 str_detail_level=0):
194 str_detail_level=0):
195 self.color_table = color_table
195 self.color_table = color_table
196 self.parser = PyColorize.Parser(code_color_table,out='str')
196 self.parser = PyColorize.Parser(code_color_table,out='str')
197 self.format = self.parser.format
197 self.format = self.parser.format
198 self.str_detail_level = str_detail_level
198 self.str_detail_level = str_detail_level
199 self.set_active_scheme(scheme)
199 self.set_active_scheme(scheme)
200
200
201 def __getdef(self,obj,oname=''):
201 def __getdef(self,obj,oname=''):
202 """Return the definition header for any callable object.
202 """Return the definition header for any callable object.
203
203
204 If any exception is generated, None is returned instead and the
204 If any exception is generated, None is returned instead and the
205 exception is suppressed."""
205 exception is suppressed."""
206
206
207 try:
207 try:
208 return oname + inspect.formatargspec(*getargspec(obj))
208 return oname + inspect.formatargspec(*getargspec(obj))
209 except:
209 except:
210 return None
210 return None
211
211
212 def __head(self,h):
212 def __head(self,h):
213 """Return a header string with proper colors."""
213 """Return a header string with proper colors."""
214 return '%s%s%s' % (self.color_table.active_colors.header,h,
214 return '%s%s%s' % (self.color_table.active_colors.header,h,
215 self.color_table.active_colors.normal)
215 self.color_table.active_colors.normal)
216
216
217 def set_active_scheme(self,scheme):
217 def set_active_scheme(self,scheme):
218 self.color_table.set_active_scheme(scheme)
218 self.color_table.set_active_scheme(scheme)
219 self.parser.color_table.set_active_scheme(scheme)
219 self.parser.color_table.set_active_scheme(scheme)
220
220
221 def noinfo(self,msg,oname):
221 def noinfo(self,msg,oname):
222 """Generic message when no information is found."""
222 """Generic message when no information is found."""
223 print 'No %s found' % msg,
223 print 'No %s found' % msg,
224 if oname:
224 if oname:
225 print 'for %s' % oname
225 print 'for %s' % oname
226 else:
226 else:
227 print
227 print
228
228
229 def pdef(self,obj,oname=''):
229 def pdef(self,obj,oname=''):
230 """Print the definition header for any callable object.
230 """Print the definition header for any callable object.
231
231
232 If the object is a class, print the constructor information."""
232 If the object is a class, print the constructor information."""
233
233
234 if not callable(obj):
234 if not callable(obj):
235 print 'Object is not callable.'
235 print 'Object is not callable.'
236 return
236 return
237
237
238 header = ''
238 header = ''
239
239
240 if inspect.isclass(obj):
240 if inspect.isclass(obj):
241 header = self.__head('Class constructor information:\n')
241 header = self.__head('Class constructor information:\n')
242 obj = obj.__init__
242 obj = obj.__init__
243 elif type(obj) is types.InstanceType:
243 elif type(obj) is types.InstanceType:
244 obj = obj.__call__
244 obj = obj.__call__
245
245
246 output = self.__getdef(obj,oname)
246 output = self.__getdef(obj,oname)
247 if output is None:
247 if output is None:
248 self.noinfo('definition header',oname)
248 self.noinfo('definition header',oname)
249 else:
249 else:
250 print >>Term.cout, header,self.format(output),
250 print >>Term.cout, header,self.format(output),
251
251
252 def pdoc(self,obj,oname='',formatter = None):
252 def pdoc(self,obj,oname='',formatter = None):
253 """Print the docstring for any object.
253 """Print the docstring for any object.
254
254
255 Optional:
255 Optional:
256 -formatter: a function to run the docstring through for specially
256 -formatter: a function to run the docstring through for specially
257 formatted docstrings."""
257 formatted docstrings."""
258
258
259 head = self.__head # so that itpl can find it even if private
259 head = self.__head # so that itpl can find it even if private
260 ds = getdoc(obj)
260 ds = getdoc(obj)
261 if formatter:
261 if formatter:
262 ds = formatter(ds)
262 ds = formatter(ds)
263 if inspect.isclass(obj):
263 if inspect.isclass(obj):
264 init_ds = getdoc(obj.__init__)
264 init_ds = getdoc(obj.__init__)
265 output = itpl('$head("Class Docstring:")\n'
265 output = itpl('$head("Class Docstring:")\n'
266 '$indent(ds)\n'
266 '$indent(ds)\n'
267 '$head("Constructor Docstring"):\n'
267 '$head("Constructor Docstring"):\n'
268 '$indent(init_ds)')
268 '$indent(init_ds)')
269 elif (type(obj) is types.InstanceType or isinstance(obj,object)) \
269 elif (type(obj) is types.InstanceType or isinstance(obj,object)) \
270 and hasattr(obj,'__call__'):
270 and hasattr(obj,'__call__'):
271 call_ds = getdoc(obj.__call__)
271 call_ds = getdoc(obj.__call__)
272 if call_ds:
272 if call_ds:
273 output = itpl('$head("Class Docstring:")\n$indent(ds)\n'
273 output = itpl('$head("Class Docstring:")\n$indent(ds)\n'
274 '$head("Calling Docstring:")\n$indent(call_ds)')
274 '$head("Calling Docstring:")\n$indent(call_ds)')
275 else:
275 else:
276 output = ds
276 output = ds
277 else:
277 else:
278 output = ds
278 output = ds
279 if output is None:
279 if output is None:
280 self.noinfo('documentation',oname)
280 self.noinfo('documentation',oname)
281 return
281 return
282 page(output)
282 page(output)
283
283
284 def psource(self,obj,oname=''):
284 def psource(self,obj,oname=''):
285 """Print the source code for an object."""
285 """Print the source code for an object."""
286
286
287 # Flush the source cache because inspect can return out-of-date source
287 # Flush the source cache because inspect can return out-of-date source
288 linecache.checkcache()
288 linecache.checkcache()
289 try:
289 try:
290 src = getsource(obj)
290 src = getsource(obj)
291 except:
291 except:
292 self.noinfo('source',oname)
292 self.noinfo('source',oname)
293 else:
293 else:
294 page(self.format(src))
294 page(self.format(src))
295
295
296 def pfile(self,obj,oname=''):
296 def pfile(self,obj,oname=''):
297 """Show the whole file where an object was defined."""
297 """Show the whole file where an object was defined."""
298
298
299 try:
299 try:
300 try:
300 try:
301 lineno = inspect.getsourcelines(obj)[1]
301 lineno = inspect.getsourcelines(obj)[1]
302 except TypeError:
302 except TypeError:
303 # For instances, try the class object like getsource() does
303 # For instances, try the class object like getsource() does
304 if hasattr(obj,'__class__'):
304 if hasattr(obj,'__class__'):
305 lineno = inspect.getsourcelines(obj.__class__)[1]
305 lineno = inspect.getsourcelines(obj.__class__)[1]
306 # Adjust the inspected object so getabsfile() below works
306 # Adjust the inspected object so getabsfile() below works
307 obj = obj.__class__
307 obj = obj.__class__
308 except:
308 except:
309 self.noinfo('file',oname)
309 self.noinfo('file',oname)
310 return
310 return
311
311
312 # We only reach this point if object was successfully queried
312 # We only reach this point if object was successfully queried
313
313
314 # run contents of file through pager starting at line
314 # run contents of file through pager starting at line
315 # where the object is defined
315 # where the object is defined
316 ofile = inspect.getabsfile(obj)
316 ofile = inspect.getabsfile(obj)
317
317
318 if (ofile.endswith('.so') or ofile.endswith('.dll')):
318 if (ofile.endswith('.so') or ofile.endswith('.dll')):
319 print 'File %r is binary, not printing.' % ofile
319 print 'File %r is binary, not printing.' % ofile
320 elif not os.path.isfile(ofile):
320 elif not os.path.isfile(ofile):
321 print 'File %r does not exist, not printing.' % ofile
321 print 'File %r does not exist, not printing.' % ofile
322 else:
322 else:
323 # Print only text files, not extension binaries. Note that
323 # Print only text files, not extension binaries. Note that
324 # getsourcelines returns lineno with 1-offset and page() uses
324 # getsourcelines returns lineno with 1-offset and page() uses
325 # 0-offset, so we must adjust.
325 # 0-offset, so we must adjust.
326 page(self.format(open(ofile).read()),lineno-1)
326 page(self.format(open(ofile).read()),lineno-1)
327
327
328 def pinfo(self,obj,oname='',formatter=None,info=None,detail_level=0):
328 def pinfo(self,obj,oname='',formatter=None,info=None,detail_level=0):
329 """Show detailed information about an object.
329 """Show detailed information about an object.
330
330
331 Optional arguments:
331 Optional arguments:
332
332
333 - oname: name of the variable pointing to the object.
333 - oname: name of the variable pointing to the object.
334
334
335 - formatter: special formatter for docstrings (see pdoc)
335 - formatter: special formatter for docstrings (see pdoc)
336
336
337 - info: a structure with some information fields which may have been
337 - info: a structure with some information fields which may have been
338 precomputed already.
338 precomputed already.
339
339
340 - detail_level: if set to 1, more information is given.
340 - detail_level: if set to 1, more information is given.
341 """
341 """
342
342
343 obj_type = type(obj)
343 obj_type = type(obj)
344
344
345 header = self.__head
345 header = self.__head
346 if info is None:
346 if info is None:
347 ismagic = 0
347 ismagic = 0
348 isalias = 0
348 isalias = 0
349 ospace = ''
349 ospace = ''
350 else:
350 else:
351 ismagic = info.ismagic
351 ismagic = info.ismagic
352 isalias = info.isalias
352 isalias = info.isalias
353 ospace = info.namespace
353 ospace = info.namespace
354 # Get docstring, special-casing aliases:
354 # Get docstring, special-casing aliases:
355 if isalias:
355 if isalias:
356 if not callable(obj):
356 if not callable(obj):
357 try:
357 try:
358 ds = "Alias to the system command:\n %s" % obj[1]
358 ds = "Alias to the system command:\n %s" % obj[1]
359 except:
359 except:
360 ds = "Alias: " + str(obj)
360 ds = "Alias: " + str(obj)
361 else:
361 else:
362 ds = "Alias to " + str(obj)
362 ds = "Alias to " + str(obj)
363 if obj.__doc__:
363 if obj.__doc__:
364 ds += "\nDocstring:\n" + obj.__doc__
364 ds += "\nDocstring:\n" + obj.__doc__
365 else:
365 else:
366 ds = getdoc(obj)
366 ds = getdoc(obj)
367 if ds is None:
367 if ds is None:
368 ds = '<no docstring>'
368 ds = '<no docstring>'
369 if formatter is not None:
369 if formatter is not None:
370 ds = formatter(ds)
370 ds = formatter(ds)
371
371
372 # store output in a list which gets joined with \n at the end.
372 # store output in a list which gets joined with \n at the end.
373 out = myStringIO()
373 out = myStringIO()
374
374
375 string_max = 200 # max size of strings to show (snipped if longer)
375 string_max = 200 # max size of strings to show (snipped if longer)
376 shalf = int((string_max -5)/2)
376 shalf = int((string_max -5)/2)
377
377
378 if ismagic:
378 if ismagic:
379 obj_type_name = 'Magic function'
379 obj_type_name = 'Magic function'
380 elif isalias:
380 elif isalias:
381 obj_type_name = 'System alias'
381 obj_type_name = 'System alias'
382 else:
382 else:
383 obj_type_name = obj_type.__name__
383 obj_type_name = obj_type.__name__
384 out.writeln(header('Type:\t\t')+obj_type_name)
384 out.writeln(header('Type:\t\t')+obj_type_name)
385
385
386 try:
386 try:
387 bclass = obj.__class__
387 bclass = obj.__class__
388 out.writeln(header('Base Class:\t')+str(bclass))
388 out.writeln(header('Base Class:\t')+str(bclass))
389 except: pass
389 except: pass
390
390
391 # String form, but snip if too long in ? form (full in ??)
391 # String form, but snip if too long in ? form (full in ??)
392 if detail_level >= self.str_detail_level:
392 if detail_level >= self.str_detail_level:
393 try:
393 try:
394 ostr = str(obj)
394 ostr = str(obj)
395 str_head = 'String Form:'
395 str_head = 'String Form:'
396 if not detail_level and len(ostr)>string_max:
396 if not detail_level and len(ostr)>string_max:
397 ostr = ostr[:shalf] + ' <...> ' + ostr[-shalf:]
397 ostr = ostr[:shalf] + ' <...> ' + ostr[-shalf:]
398 ostr = ("\n" + " " * len(str_head.expandtabs())).\
398 ostr = ("\n" + " " * len(str_head.expandtabs())).\
399 join(map(string.strip,ostr.split("\n")))
399 join(map(string.strip,ostr.split("\n")))
400 if ostr.find('\n') > -1:
400 if ostr.find('\n') > -1:
401 # Print multi-line strings starting at the next line.
401 # Print multi-line strings starting at the next line.
402 str_sep = '\n'
402 str_sep = '\n'
403 else:
403 else:
404 str_sep = '\t'
404 str_sep = '\t'
405 out.writeln("%s%s%s" % (header(str_head),str_sep,ostr))
405 out.writeln("%s%s%s" % (header(str_head),str_sep,ostr))
406 except:
406 except:
407 pass
407 pass
408
408
409 if ospace:
409 if ospace:
410 out.writeln(header('Namespace:\t')+ospace)
410 out.writeln(header('Namespace:\t')+ospace)
411
411
412 # Length (for strings and lists)
412 # Length (for strings and lists)
413 try:
413 try:
414 length = str(len(obj))
414 length = str(len(obj))
415 out.writeln(header('Length:\t\t')+length)
415 out.writeln(header('Length:\t\t')+length)
416 except: pass
416 except: pass
417
417
418 # Filename where object was defined
418 # Filename where object was defined
419 binary_file = False
419 binary_file = False
420 try:
420 try:
421 try:
421 try:
422 fname = inspect.getabsfile(obj)
422 fname = inspect.getabsfile(obj)
423 except TypeError:
423 except TypeError:
424 # For an instance, the file that matters is where its class was
424 # For an instance, the file that matters is where its class was
425 # declared.
425 # declared.
426 if hasattr(obj,'__class__'):
426 if hasattr(obj,'__class__'):
427 fname = inspect.getabsfile(obj.__class__)
427 fname = inspect.getabsfile(obj.__class__)
428 if fname.endswith('<string>'):
428 if fname.endswith('<string>'):
429 fname = 'Dynamically generated function. No source code available.'
429 fname = 'Dynamically generated function. No source code available.'
430 if (fname.endswith('.so') or fname.endswith('.dll')):
430 if (fname.endswith('.so') or fname.endswith('.dll')):
431 binary_file = True
431 binary_file = True
432 out.writeln(header('File:\t\t')+fname)
432 out.writeln(header('File:\t\t')+fname)
433 except:
433 except:
434 # if anything goes wrong, we don't want to show source, so it's as
434 # if anything goes wrong, we don't want to show source, so it's as
435 # if the file was binary
435 # if the file was binary
436 binary_file = True
436 binary_file = True
437
437
438 # reconstruct the function definition and print it:
438 # reconstruct the function definition and print it:
439 defln = self.__getdef(obj,oname)
439 defln = self.__getdef(obj,oname)
440 if defln:
440 if defln:
441 out.write(header('Definition:\t')+self.format(defln))
441 out.write(header('Definition:\t')+self.format(defln))
442
442
443 # Docstrings only in detail 0 mode, since source contains them (we
443 # Docstrings only in detail 0 mode, since source contains them (we
444 # avoid repetitions). If source fails, we add them back, see below.
444 # avoid repetitions). If source fails, we add them back, see below.
445 if ds and detail_level == 0:
445 if ds and detail_level == 0:
446 out.writeln(header('Docstring:\n') + indent(ds))
446 out.writeln(header('Docstring:\n') + indent(ds))
447
447
448 # Original source code for any callable
448 # Original source code for any callable
449 if detail_level:
449 if detail_level:
450 # Flush the source cache because inspect can return out-of-date
450 # Flush the source cache because inspect can return out-of-date
451 # source
451 # source
452 linecache.checkcache()
452 linecache.checkcache()
453 source_success = False
453 source_success = False
454 try:
454 try:
455 try:
455 try:
456 src = getsource(obj,binary_file)
456 src = getsource(obj,binary_file)
457 except TypeError:
457 except TypeError:
458 if hasattr(obj,'__class__'):
458 if hasattr(obj,'__class__'):
459 src = getsource(obj.__class__,binary_file)
459 src = getsource(obj.__class__,binary_file)
460 if src is not None:
460 if src is not None:
461 source = self.format(src)
461 source = self.format(src)
462 out.write(header('Source:\n')+source.rstrip())
462 out.write(header('Source:\n')+source.rstrip())
463 source_success = True
463 source_success = True
464 except Exception, msg:
464 except Exception, msg:
465 pass
465 pass
466
466
467 if ds and not source_success:
467 if ds and not source_success:
468 out.writeln(header('Docstring [source file open failed]:\n')
468 out.writeln(header('Docstring [source file open failed]:\n')
469 + indent(ds))
469 + indent(ds))
470
470
471 # Constructor docstring for classes
471 # Constructor docstring for classes
472 if inspect.isclass(obj):
472 if inspect.isclass(obj):
473 # reconstruct the function definition and print it:
473 # reconstruct the function definition and print it:
474 try:
474 try:
475 obj_init = obj.__init__
475 obj_init = obj.__init__
476 except AttributeError:
476 except AttributeError:
477 init_def = init_ds = None
477 init_def = init_ds = None
478 else:
478 else:
479 init_def = self.__getdef(obj_init,oname)
479 init_def = self.__getdef(obj_init,oname)
480 init_ds = getdoc(obj_init)
480 init_ds = getdoc(obj_init)
481 # Skip Python's auto-generated docstrings
481 # Skip Python's auto-generated docstrings
482 if init_ds and \
482 if init_ds and \
483 init_ds.startswith('x.__init__(...) initializes'):
483 init_ds.startswith('x.__init__(...) initializes'):
484 init_ds = None
484 init_ds = None
485
485
486 if init_def or init_ds:
486 if init_def or init_ds:
487 out.writeln(header('\nConstructor information:'))
487 out.writeln(header('\nConstructor information:'))
488 if init_def:
488 if init_def:
489 out.write(header('Definition:\t')+ self.format(init_def))
489 out.write(header('Definition:\t')+ self.format(init_def))
490 if init_ds:
490 if init_ds:
491 out.writeln(header('Docstring:\n') + indent(init_ds))
491 out.writeln(header('Docstring:\n') + indent(init_ds))
492 # and class docstring for instances:
492 # and class docstring for instances:
493 elif obj_type is types.InstanceType or \
493 elif obj_type is types.InstanceType or \
494 isinstance(obj,object):
494 isinstance(obj,object):
495
495
496 # First, check whether the instance docstring is identical to the
496 # First, check whether the instance docstring is identical to the
497 # class one, and print it separately if they don't coincide. In
497 # class one, and print it separately if they don't coincide. In
498 # most cases they will, but it's nice to print all the info for
498 # most cases they will, but it's nice to print all the info for
499 # objects which use instance-customized docstrings.
499 # objects which use instance-customized docstrings.
500 if ds:
500 if ds:
501 try:
501 try:
502 cls = getattr(obj,'__class__')
502 cls = getattr(obj,'__class__')
503 except:
503 except:
504 class_ds = None
504 class_ds = None
505 else:
505 else:
506 class_ds = getdoc(cls)
506 class_ds = getdoc(cls)
507 # Skip Python's auto-generated docstrings
507 # Skip Python's auto-generated docstrings
508 if class_ds and \
508 if class_ds and \
509 (class_ds.startswith('function(code, globals[,') or \
509 (class_ds.startswith('function(code, globals[,') or \
510 class_ds.startswith('instancemethod(function, instance,') or \
510 class_ds.startswith('instancemethod(function, instance,') or \
511 class_ds.startswith('module(name[,') ):
511 class_ds.startswith('module(name[,') ):
512 class_ds = None
512 class_ds = None
513 if class_ds and ds != class_ds:
513 if class_ds and ds != class_ds:
514 out.writeln(header('Class Docstring:\n') +
514 out.writeln(header('Class Docstring:\n') +
515 indent(class_ds))
515 indent(class_ds))
516
516
517 # Next, try to show constructor docstrings
517 # Next, try to show constructor docstrings
518 try:
518 try:
519 init_ds = getdoc(obj.__init__)
519 init_ds = getdoc(obj.__init__)
520 # Skip Python's auto-generated docstrings
520 # Skip Python's auto-generated docstrings
521 if init_ds and \
521 if init_ds and \
522 init_ds.startswith('x.__init__(...) initializes'):
522 init_ds.startswith('x.__init__(...) initializes'):
523 init_ds = None
523 init_ds = None
524 except AttributeError:
524 except AttributeError:
525 init_ds = None
525 init_ds = None
526 if init_ds:
526 if init_ds:
527 out.writeln(header('Constructor Docstring:\n') +
527 out.writeln(header('Constructor Docstring:\n') +
528 indent(init_ds))
528 indent(init_ds))
529
529
530 # Call form docstring for callable instances
530 # Call form docstring for callable instances
531 if hasattr(obj,'__call__'):
531 if hasattr(obj,'__call__'):
532 #out.writeln(header('Callable:\t')+'Yes')
532 #out.writeln(header('Callable:\t')+'Yes')
533 call_def = self.__getdef(obj.__call__,oname)
533 call_def = self.__getdef(obj.__call__,oname)
534 #if call_def is None:
534 #if call_def is None:
535 # out.writeln(header('Call def:\t')+
535 # out.writeln(header('Call def:\t')+
536 # 'Calling definition not available.')
536 # 'Calling definition not available.')
537 if call_def is not None:
537 if call_def is not None:
538 out.writeln(header('Call def:\t')+self.format(call_def))
538 out.writeln(header('Call def:\t')+self.format(call_def))
539 call_ds = getdoc(obj.__call__)
539 call_ds = getdoc(obj.__call__)
540 # Skip Python's auto-generated docstrings
540 # Skip Python's auto-generated docstrings
541 if call_ds and call_ds.startswith('x.__call__(...) <==> x(...)'):
541 if call_ds and call_ds.startswith('x.__call__(...) <==> x(...)'):
542 call_ds = None
542 call_ds = None
543 if call_ds:
543 if call_ds:
544 out.writeln(header('Call docstring:\n') + indent(call_ds))
544 out.writeln(header('Call docstring:\n') + indent(call_ds))
545
545
546 # Finally send to printer/pager
546 # Finally send to printer/pager
547 output = out.getvalue()
547 output = out.getvalue()
548 if output:
548 if output:
549 page(output)
549 page(output)
550 # end pinfo
550 # end pinfo
551
551
552 def psearch(self,pattern,ns_table,ns_search=[],
552 def psearch(self,pattern,ns_table,ns_search=[],
553 ignore_case=False,show_all=False):
553 ignore_case=False,show_all=False):
554 """Search namespaces with wildcards for objects.
554 """Search namespaces with wildcards for objects.
555
555
556 Arguments:
556 Arguments:
557
557
558 - pattern: string containing shell-like wildcards to use in namespace
558 - pattern: string containing shell-like wildcards to use in namespace
559 searches and optionally a type specification to narrow the search to
559 searches and optionally a type specification to narrow the search to
560 objects of that type.
560 objects of that type.
561
561
562 - ns_table: dict of name->namespaces for search.
562 - ns_table: dict of name->namespaces for search.
563
563
564 Optional arguments:
564 Optional arguments:
565
565
566 - ns_search: list of namespace names to include in search.
566 - ns_search: list of namespace names to include in search.
567
567
568 - ignore_case(False): make the search case-insensitive.
568 - ignore_case(False): make the search case-insensitive.
569
569
570 - show_all(False): show all names, including those starting with
570 - show_all(False): show all names, including those starting with
571 underscores.
571 underscores.
572 """
572 """
573 #print 'ps pattern:<%r>' % pattern # dbg
573 #print 'ps pattern:<%r>' % pattern # dbg
574
574
575 # defaults
575 # defaults
576 type_pattern = 'all'
576 type_pattern = 'all'
577 filter = ''
577 filter = ''
578
578
579 cmds = pattern.split()
579 cmds = pattern.split()
580 len_cmds = len(cmds)
580 len_cmds = len(cmds)
581 if len_cmds == 1:
581 if len_cmds == 1:
582 # Only filter pattern given
582 # Only filter pattern given
583 filter = cmds[0]
583 filter = cmds[0]
584 elif len_cmds == 2:
584 elif len_cmds == 2:
585 # Both filter and type specified
585 # Both filter and type specified
586 filter,type_pattern = cmds
586 filter,type_pattern = cmds
587 else:
587 else:
588 raise ValueError('invalid argument string for psearch: <%s>' %
588 raise ValueError('invalid argument string for psearch: <%s>' %
589 pattern)
589 pattern)
590
590
591 # filter search namespaces
591 # filter search namespaces
592 for name in ns_search:
592 for name in ns_search:
593 if name not in ns_table:
593 if name not in ns_table:
594 raise ValueError('invalid namespace <%s>. Valid names: %s' %
594 raise ValueError('invalid namespace <%s>. Valid names: %s' %
595 (name,ns_table.keys()))
595 (name,ns_table.keys()))
596
596
597 #print 'type_pattern:',type_pattern # dbg
597 #print 'type_pattern:',type_pattern # dbg
598 search_result = []
598 search_result = []
599 for ns_name in ns_search:
599 for ns_name in ns_search:
600 ns = ns_table[ns_name]
600 ns = ns_table[ns_name]
601 tmp_res = list(list_namespace(ns,type_pattern,filter,
601 tmp_res = list(list_namespace(ns,type_pattern,filter,
602 ignore_case=ignore_case,
602 ignore_case=ignore_case,
603 show_all=show_all))
603 show_all=show_all))
604 search_result.extend(tmp_res)
604 search_result.extend(tmp_res)
605 search_result.sort()
605 search_result.sort()
606
606
607 page('\n'.join(search_result))
607 page('\n'.join(search_result))
@@ -1,229 +1,229 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """sys.excepthook for IPython itself, leaves a detailed report on disk.
2 """sys.excepthook for IPython itself, leaves a detailed report on disk.
3
3
4
4
5 Authors
5 Authors
6 -------
6 -------
7 - Fernando Perez <Fernando.Perez@berkeley.edu>
7 - Fernando Perez <Fernando.Perez@berkeley.edu>
8 """
8 """
9
9
10 #*****************************************************************************
10 #*****************************************************************************
11 # Copyright (C) 2008-2009 The IPython Development Team
11 # Copyright (C) 2008-2009 The IPython Development Team
12 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
12 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
13 #
13 #
14 # Distributed under the terms of the BSD License. The full license is in
14 # Distributed under the terms of the BSD License. The full license is in
15 # the file COPYING, distributed as part of this software.
15 # the file COPYING, distributed as part of this software.
16 #*****************************************************************************
16 #*****************************************************************************
17
17
18 #****************************************************************************
18 #****************************************************************************
19 # Required modules
19 # Required modules
20
20
21 # From the standard library
21 # From the standard library
22 import os
22 import os
23 import sys
23 import sys
24 from pprint import pformat
24 from pprint import pformat
25
25
26 # Our own
26 # Our own
27 from IPython import Release
27 from IPython import Release
28 from IPython import ultraTB
28 from IPython import ultraTB
29 from IPython.Itpl import itpl
29 from IPython.external.Itpl import itpl
30
30
31 from IPython.utils.genutils import *
31 from IPython.utils.genutils import *
32
32
33 #****************************************************************************
33 #****************************************************************************
34 class CrashHandler:
34 class CrashHandler:
35 """Customizable crash handlers for IPython-based systems.
35 """Customizable crash handlers for IPython-based systems.
36
36
37 Instances of this class provide a __call__ method which can be used as a
37 Instances of this class provide a __call__ method which can be used as a
38 sys.excepthook, i.e., the __call__ signature is:
38 sys.excepthook, i.e., the __call__ signature is:
39
39
40 def __call__(self,etype, evalue, etb)
40 def __call__(self,etype, evalue, etb)
41
41
42 """
42 """
43
43
44 def __init__(self,IP,app_name,contact_name,contact_email,
44 def __init__(self,IP,app_name,contact_name,contact_email,
45 bug_tracker,crash_report_fname,
45 bug_tracker,crash_report_fname,
46 show_crash_traceback=True):
46 show_crash_traceback=True):
47 """New crash handler.
47 """New crash handler.
48
48
49 Inputs:
49 Inputs:
50
50
51 - IP: a running IPython instance, which will be queried at crash time
51 - IP: a running IPython instance, which will be queried at crash time
52 for internal information.
52 for internal information.
53
53
54 - app_name: a string containing the name of your application.
54 - app_name: a string containing the name of your application.
55
55
56 - contact_name: a string with the name of the person to contact.
56 - contact_name: a string with the name of the person to contact.
57
57
58 - contact_email: a string with the email address of the contact.
58 - contact_email: a string with the email address of the contact.
59
59
60 - bug_tracker: a string with the URL for your project's bug tracker.
60 - bug_tracker: a string with the URL for your project's bug tracker.
61
61
62 - crash_report_fname: a string with the filename for the crash report
62 - crash_report_fname: a string with the filename for the crash report
63 to be saved in. These reports are left in the ipython user directory
63 to be saved in. These reports are left in the ipython user directory
64 as determined by the running IPython instance.
64 as determined by the running IPython instance.
65
65
66 Optional inputs:
66 Optional inputs:
67
67
68 - show_crash_traceback(True): if false, don't print the crash
68 - show_crash_traceback(True): if false, don't print the crash
69 traceback on stderr, only generate the on-disk report
69 traceback on stderr, only generate the on-disk report
70
70
71
71
72 Non-argument instance attributes:
72 Non-argument instance attributes:
73
73
74 These instances contain some non-argument attributes which allow for
74 These instances contain some non-argument attributes which allow for
75 further customization of the crash handler's behavior. Please see the
75 further customization of the crash handler's behavior. Please see the
76 source for further details.
76 source for further details.
77 """
77 """
78
78
79 # apply args into instance
79 # apply args into instance
80 self.IP = IP # IPython instance
80 self.IP = IP # IPython instance
81 self.app_name = app_name
81 self.app_name = app_name
82 self.contact_name = contact_name
82 self.contact_name = contact_name
83 self.contact_email = contact_email
83 self.contact_email = contact_email
84 self.bug_tracker = bug_tracker
84 self.bug_tracker = bug_tracker
85 self.crash_report_fname = crash_report_fname
85 self.crash_report_fname = crash_report_fname
86 self.show_crash_traceback = show_crash_traceback
86 self.show_crash_traceback = show_crash_traceback
87
87
88 # Hardcoded defaults, which can be overridden either by subclasses or
88 # Hardcoded defaults, which can be overridden either by subclasses or
89 # at runtime for the instance.
89 # at runtime for the instance.
90
90
91 # Template for the user message. Subclasses which completely override
91 # Template for the user message. Subclasses which completely override
92 # this, or user apps, can modify it to suit their tastes. It gets
92 # this, or user apps, can modify it to suit their tastes. It gets
93 # expanded using itpl, so calls of the kind $self.foo are valid.
93 # expanded using itpl, so calls of the kind $self.foo are valid.
94 self.user_message_template = """
94 self.user_message_template = """
95 Oops, $self.app_name crashed. We do our best to make it stable, but...
95 Oops, $self.app_name crashed. We do our best to make it stable, but...
96
96
97 A crash report was automatically generated with the following information:
97 A crash report was automatically generated with the following information:
98 - A verbatim copy of the crash traceback.
98 - A verbatim copy of the crash traceback.
99 - A copy of your input history during this session.
99 - A copy of your input history during this session.
100 - Data on your current $self.app_name configuration.
100 - Data on your current $self.app_name configuration.
101
101
102 It was left in the file named:
102 It was left in the file named:
103 \t'$self.crash_report_fname'
103 \t'$self.crash_report_fname'
104 If you can email this file to the developers, the information in it will help
104 If you can email this file to the developers, the information in it will help
105 them in understanding and correcting the problem.
105 them in understanding and correcting the problem.
106
106
107 You can mail it to: $self.contact_name at $self.contact_email
107 You can mail it to: $self.contact_name at $self.contact_email
108 with the subject '$self.app_name Crash Report'.
108 with the subject '$self.app_name Crash Report'.
109
109
110 If you want to do it now, the following command will work (under Unix):
110 If you want to do it now, the following command will work (under Unix):
111 mail -s '$self.app_name Crash Report' $self.contact_email < $self.crash_report_fname
111 mail -s '$self.app_name Crash Report' $self.contact_email < $self.crash_report_fname
112
112
113 To ensure accurate tracking of this issue, please file a report about it at:
113 To ensure accurate tracking of this issue, please file a report about it at:
114 $self.bug_tracker
114 $self.bug_tracker
115 """
115 """
116
116
117 def __call__(self,etype, evalue, etb):
117 def __call__(self,etype, evalue, etb):
118 """Handle an exception, call for compatible with sys.excepthook"""
118 """Handle an exception, call for compatible with sys.excepthook"""
119
119
120 # Report tracebacks shouldn't use color in general (safer for users)
120 # Report tracebacks shouldn't use color in general (safer for users)
121 color_scheme = 'NoColor'
121 color_scheme = 'NoColor'
122
122
123 # Use this ONLY for developer debugging (keep commented out for release)
123 # Use this ONLY for developer debugging (keep commented out for release)
124 #color_scheme = 'Linux' # dbg
124 #color_scheme = 'Linux' # dbg
125
125
126 try:
126 try:
127 rptdir = self.IP.rc.ipythondir
127 rptdir = self.IP.rc.ipythondir
128 except:
128 except:
129 rptdir = os.getcwd()
129 rptdir = os.getcwd()
130 if not os.path.isdir(rptdir):
130 if not os.path.isdir(rptdir):
131 rptdir = os.getcwd()
131 rptdir = os.getcwd()
132 report_name = os.path.join(rptdir,self.crash_report_fname)
132 report_name = os.path.join(rptdir,self.crash_report_fname)
133 # write the report filename into the instance dict so it can get
133 # write the report filename into the instance dict so it can get
134 # properly expanded out in the user message template
134 # properly expanded out in the user message template
135 self.crash_report_fname = report_name
135 self.crash_report_fname = report_name
136 TBhandler = ultraTB.VerboseTB(color_scheme=color_scheme,
136 TBhandler = ultraTB.VerboseTB(color_scheme=color_scheme,
137 long_header=1)
137 long_header=1)
138 traceback = TBhandler.text(etype,evalue,etb,context=31)
138 traceback = TBhandler.text(etype,evalue,etb,context=31)
139
139
140 # print traceback to screen
140 # print traceback to screen
141 if self.show_crash_traceback:
141 if self.show_crash_traceback:
142 print >> sys.stderr, traceback
142 print >> sys.stderr, traceback
143
143
144 # and generate a complete report on disk
144 # and generate a complete report on disk
145 try:
145 try:
146 report = open(report_name,'w')
146 report = open(report_name,'w')
147 except:
147 except:
148 print >> sys.stderr, 'Could not create crash report on disk.'
148 print >> sys.stderr, 'Could not create crash report on disk.'
149 return
149 return
150
150
151 # Inform user on stderr of what happened
151 # Inform user on stderr of what happened
152 msg = itpl('\n'+'*'*70+'\n'+self.user_message_template)
152 msg = itpl('\n'+'*'*70+'\n'+self.user_message_template)
153 print >> sys.stderr, msg
153 print >> sys.stderr, msg
154
154
155 # Construct report on disk
155 # Construct report on disk
156 report.write(self.make_report(traceback))
156 report.write(self.make_report(traceback))
157 report.close()
157 report.close()
158 raw_input("Press enter to exit:")
158 raw_input("Press enter to exit:")
159
159
160 def make_report(self,traceback):
160 def make_report(self,traceback):
161 """Return a string containing a crash report."""
161 """Return a string containing a crash report."""
162
162
163 sec_sep = '\n\n'+'*'*75+'\n\n'
163 sec_sep = '\n\n'+'*'*75+'\n\n'
164
164
165 report = []
165 report = []
166 rpt_add = report.append
166 rpt_add = report.append
167
167
168 rpt_add('*'*75+'\n\n'+'IPython post-mortem report\n\n')
168 rpt_add('*'*75+'\n\n'+'IPython post-mortem report\n\n')
169 rpt_add('IPython version: %s \n\n' % Release.version)
169 rpt_add('IPython version: %s \n\n' % Release.version)
170 rpt_add('BZR revision : %s \n\n' % Release.revision)
170 rpt_add('BZR revision : %s \n\n' % Release.revision)
171 rpt_add('Platform info : os.name -> %s, sys.platform -> %s' %
171 rpt_add('Platform info : os.name -> %s, sys.platform -> %s' %
172 (os.name,sys.platform) )
172 (os.name,sys.platform) )
173 rpt_add(sec_sep+'Current user configuration structure:\n\n')
173 rpt_add(sec_sep+'Current user configuration structure:\n\n')
174 rpt_add(pformat(self.IP.rc.dict()))
174 rpt_add(pformat(self.IP.rc.dict()))
175 rpt_add(sec_sep+'Crash traceback:\n\n' + traceback)
175 rpt_add(sec_sep+'Crash traceback:\n\n' + traceback)
176 try:
176 try:
177 rpt_add(sec_sep+"History of session input:")
177 rpt_add(sec_sep+"History of session input:")
178 for line in self.IP.user_ns['_ih']:
178 for line in self.IP.user_ns['_ih']:
179 rpt_add(line)
179 rpt_add(line)
180 rpt_add('\n*** Last line of input (may not be in above history):\n')
180 rpt_add('\n*** Last line of input (may not be in above history):\n')
181 rpt_add(self.IP._last_input_line+'\n')
181 rpt_add(self.IP._last_input_line+'\n')
182 except:
182 except:
183 pass
183 pass
184
184
185 return ''.join(report)
185 return ''.join(report)
186
186
187 class IPythonCrashHandler(CrashHandler):
187 class IPythonCrashHandler(CrashHandler):
188 """sys.excepthook for IPython itself, leaves a detailed report on disk."""
188 """sys.excepthook for IPython itself, leaves a detailed report on disk."""
189
189
190 def __init__(self,IP):
190 def __init__(self,IP):
191
191
192 # Set here which of the IPython authors should be listed as contact
192 # Set here which of the IPython authors should be listed as contact
193 AUTHOR_CONTACT = 'Ville'
193 AUTHOR_CONTACT = 'Ville'
194
194
195 # Set argument defaults
195 # Set argument defaults
196 app_name = 'IPython'
196 app_name = 'IPython'
197 bug_tracker = 'https://bugs.launchpad.net/ipython/+filebug'
197 bug_tracker = 'https://bugs.launchpad.net/ipython/+filebug'
198 contact_name,contact_email = Release.authors[AUTHOR_CONTACT][:2]
198 contact_name,contact_email = Release.authors[AUTHOR_CONTACT][:2]
199 crash_report_fname = 'IPython_crash_report.txt'
199 crash_report_fname = 'IPython_crash_report.txt'
200 # Call parent constructor
200 # Call parent constructor
201 CrashHandler.__init__(self,IP,app_name,contact_name,contact_email,
201 CrashHandler.__init__(self,IP,app_name,contact_name,contact_email,
202 bug_tracker,crash_report_fname)
202 bug_tracker,crash_report_fname)
203
203
204 def make_report(self,traceback):
204 def make_report(self,traceback):
205 """Return a string containing a crash report."""
205 """Return a string containing a crash report."""
206
206
207 sec_sep = '\n\n'+'*'*75+'\n\n'
207 sec_sep = '\n\n'+'*'*75+'\n\n'
208
208
209 report = []
209 report = []
210 rpt_add = report.append
210 rpt_add = report.append
211
211
212 rpt_add('*'*75+'\n\n'+'IPython post-mortem report\n\n')
212 rpt_add('*'*75+'\n\n'+'IPython post-mortem report\n\n')
213 rpt_add('IPython version: %s \n\n' % Release.version)
213 rpt_add('IPython version: %s \n\n' % Release.version)
214 rpt_add('BZR revision : %s \n\n' % Release.revision)
214 rpt_add('BZR revision : %s \n\n' % Release.revision)
215 rpt_add('Platform info : os.name -> %s, sys.platform -> %s' %
215 rpt_add('Platform info : os.name -> %s, sys.platform -> %s' %
216 (os.name,sys.platform) )
216 (os.name,sys.platform) )
217 rpt_add(sec_sep+'Current user configuration structure:\n\n')
217 rpt_add(sec_sep+'Current user configuration structure:\n\n')
218 rpt_add(pformat(self.IP.rc.dict()))
218 rpt_add(pformat(self.IP.rc.dict()))
219 rpt_add(sec_sep+'Crash traceback:\n\n' + traceback)
219 rpt_add(sec_sep+'Crash traceback:\n\n' + traceback)
220 try:
220 try:
221 rpt_add(sec_sep+"History of session input:")
221 rpt_add(sec_sep+"History of session input:")
222 for line in self.IP.user_ns['_ih']:
222 for line in self.IP.user_ns['_ih']:
223 rpt_add(line)
223 rpt_add(line)
224 rpt_add('\n*** Last line of input (may not be in above history):\n')
224 rpt_add('\n*** Last line of input (may not be in above history):\n')
225 rpt_add(self.IP._last_input_line+'\n')
225 rpt_add(self.IP._last_input_line+'\n')
226 except:
226 except:
227 pass
227 pass
228
228
229 return ''.join(report)
229 return ''.join(report)
@@ -1,2864 +1,2864 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """
2 """
3 IPython -- An enhanced Interactive Python
3 IPython -- An enhanced Interactive Python
4
4
5 Requires Python 2.4 or newer.
5 Requires Python 2.4 or newer.
6
6
7 This file contains all the classes and helper functions specific to IPython.
7 This file contains all the classes and helper functions specific to IPython.
8 """
8 """
9
9
10 #*****************************************************************************
10 #*****************************************************************************
11 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
11 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
12 # Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
12 # Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
13 #
13 #
14 # Distributed under the terms of the BSD License. The full license is in
14 # Distributed under the terms of the BSD License. The full license is in
15 # the file COPYING, distributed as part of this software.
15 # the file COPYING, distributed as part of this software.
16 #
16 #
17 # Note: this code originally subclassed code.InteractiveConsole from the
17 # Note: this code originally subclassed code.InteractiveConsole from the
18 # Python standard library. Over time, all of that class has been copied
18 # Python standard library. Over time, all of that class has been copied
19 # verbatim here for modifications which could not be accomplished by
19 # verbatim here for modifications which could not be accomplished by
20 # subclassing. At this point, there are no dependencies at all on the code
20 # subclassing. At this point, there are no dependencies at all on the code
21 # module anymore (it is not even imported). The Python License (sec. 2)
21 # module anymore (it is not even imported). The Python License (sec. 2)
22 # allows for this, but it's always nice to acknowledge credit where credit is
22 # allows for this, but it's always nice to acknowledge credit where credit is
23 # due.
23 # due.
24 #*****************************************************************************
24 #*****************************************************************************
25
25
26 #****************************************************************************
26 #****************************************************************************
27 # Modules and globals
27 # Modules and globals
28
28
29 # Python standard modules
29 # Python standard modules
30 import __main__
30 import __main__
31 import __builtin__
31 import __builtin__
32 import StringIO
32 import StringIO
33 import bdb
33 import bdb
34 import codeop
34 import codeop
35 import exceptions
35 import exceptions
36 import glob
36 import glob
37 import keyword
37 import keyword
38 import new
38 import new
39 import os
39 import os
40 import re
40 import re
41 import shutil
41 import shutil
42 import string
42 import string
43 import sys
43 import sys
44 import tempfile
44 import tempfile
45
45
46 # IPython's own modules
46 # IPython's own modules
47 #import IPython
47 #import IPython
48 from IPython import OInspect,PyColorize,ultraTB
48 from IPython import OInspect,PyColorize,ultraTB
49 from IPython.core import debugger
49 from IPython.core import debugger
50 from IPython.Extensions import pickleshare
50 from IPython.Extensions import pickleshare
51 from IPython.core.fakemodule import FakeModule, init_fakemod_dict
51 from IPython.core.fakemodule import FakeModule, init_fakemod_dict
52 from IPython.Itpl import ItplNS
52 from IPython.external.Itpl import ItplNS
53 from IPython.Logger import Logger
53 from IPython.Logger import Logger
54 from IPython.Magic import Magic
54 from IPython.Magic import Magic
55 from IPython.Prompts import CachedOutput
55 from IPython.Prompts import CachedOutput
56 from IPython.utils.ipstruct import Struct
56 from IPython.utils.ipstruct import Struct
57 from IPython.lib.backgroundjobs import BackgroundJobManager
57 from IPython.lib.backgroundjobs import BackgroundJobManager
58 from IPython.utils.genutils import *
58 from IPython.utils.genutils import *
59 from IPython.strdispatch import StrDispatch
59 from IPython.strdispatch import StrDispatch
60 from IPython.core import ipapi
60 from IPython.core import ipapi
61 import IPython.core.history
61 import IPython.core.history
62 import IPython.prefilter as prefilter
62 import IPython.prefilter as prefilter
63 import IPython.shadowns
63 import IPython.shadowns
64 # Globals
64 # Globals
65
65
66 # store the builtin raw_input globally, and use this always, in case user code
66 # store the builtin raw_input globally, and use this always, in case user code
67 # overwrites it (like wx.py.PyShell does)
67 # overwrites it (like wx.py.PyShell does)
68 raw_input_original = raw_input
68 raw_input_original = raw_input
69
69
70 # compiled regexps for autoindent management
70 # compiled regexps for autoindent management
71 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
71 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
72
72
73
73
74 #****************************************************************************
74 #****************************************************************************
75 # Some utility function definitions
75 # Some utility function definitions
76
76
77 ini_spaces_re = re.compile(r'^(\s+)')
77 ini_spaces_re = re.compile(r'^(\s+)')
78
78
79 def num_ini_spaces(strng):
79 def num_ini_spaces(strng):
80 """Return the number of initial spaces in a string"""
80 """Return the number of initial spaces in a string"""
81
81
82 ini_spaces = ini_spaces_re.match(strng)
82 ini_spaces = ini_spaces_re.match(strng)
83 if ini_spaces:
83 if ini_spaces:
84 return ini_spaces.end()
84 return ini_spaces.end()
85 else:
85 else:
86 return 0
86 return 0
87
87
88 def softspace(file, newvalue):
88 def softspace(file, newvalue):
89 """Copied from code.py, to remove the dependency"""
89 """Copied from code.py, to remove the dependency"""
90
90
91 oldvalue = 0
91 oldvalue = 0
92 try:
92 try:
93 oldvalue = file.softspace
93 oldvalue = file.softspace
94 except AttributeError:
94 except AttributeError:
95 pass
95 pass
96 try:
96 try:
97 file.softspace = newvalue
97 file.softspace = newvalue
98 except (AttributeError, TypeError):
98 except (AttributeError, TypeError):
99 # "attribute-less object" or "read-only attributes"
99 # "attribute-less object" or "read-only attributes"
100 pass
100 pass
101 return oldvalue
101 return oldvalue
102
102
103
103
104 def user_setup(ipythondir,rc_suffix,mode='install',interactive=True):
104 def user_setup(ipythondir,rc_suffix,mode='install',interactive=True):
105 """Install or upgrade the user configuration directory.
105 """Install or upgrade the user configuration directory.
106
106
107 Can be called when running for the first time or to upgrade the user's
107 Can be called when running for the first time or to upgrade the user's
108 .ipython/ directory.
108 .ipython/ directory.
109
109
110 Parameters
110 Parameters
111 ----------
111 ----------
112 ipythondir : path
112 ipythondir : path
113 The directory to be used for installation/upgrade. In 'install' mode,
113 The directory to be used for installation/upgrade. In 'install' mode,
114 if this path already exists, the function exits immediately.
114 if this path already exists, the function exits immediately.
115
115
116 rc_suffix : str
116 rc_suffix : str
117 Extension for the config files. On *nix platforms it is typically the
117 Extension for the config files. On *nix platforms it is typically the
118 empty string, while Windows normally uses '.ini'.
118 empty string, while Windows normally uses '.ini'.
119
119
120 mode : str, optional
120 mode : str, optional
121 Valid modes are 'install' and 'upgrade'.
121 Valid modes are 'install' and 'upgrade'.
122
122
123 interactive : bool, optional
123 interactive : bool, optional
124 If False, do not wait for user input on any errors. Normally after
124 If False, do not wait for user input on any errors. Normally after
125 printing its status information, this function waits for the user to
125 printing its status information, this function waits for the user to
126 hit Return before proceeding. This is because the default use case is
126 hit Return before proceeding. This is because the default use case is
127 when first installing the IPython configuration, so we want the user to
127 when first installing the IPython configuration, so we want the user to
128 acknowledge the initial message, which contains some useful
128 acknowledge the initial message, which contains some useful
129 information.
129 information.
130 """
130 """
131
131
132 # For automatic use, deactivate all i/o
132 # For automatic use, deactivate all i/o
133 if interactive:
133 if interactive:
134 def wait():
134 def wait():
135 try:
135 try:
136 raw_input("Please press <RETURN> to start IPython.")
136 raw_input("Please press <RETURN> to start IPython.")
137 except EOFError:
137 except EOFError:
138 print >> Term.cout
138 print >> Term.cout
139 print '*'*70
139 print '*'*70
140
140
141 def printf(s):
141 def printf(s):
142 print s
142 print s
143 else:
143 else:
144 wait = lambda : None
144 wait = lambda : None
145 printf = lambda s : None
145 printf = lambda s : None
146
146
147 # Install mode should be re-entrant: if the install dir already exists,
147 # Install mode should be re-entrant: if the install dir already exists,
148 # bail out cleanly.
148 # bail out cleanly.
149 # XXX. This is too hasty to return. We need to check to make sure that
149 # XXX. This is too hasty to return. We need to check to make sure that
150 # all the expected config files and directories are actually there. We
150 # all the expected config files and directories are actually there. We
151 # currently have a failure mode if someone deletes a needed config file
151 # currently have a failure mode if someone deletes a needed config file
152 # but still has the ipythondir.
152 # but still has the ipythondir.
153 if mode == 'install' and os.path.isdir(ipythondir):
153 if mode == 'install' and os.path.isdir(ipythondir):
154 return
154 return
155
155
156 cwd = os.getcwd() # remember where we started
156 cwd = os.getcwd() # remember where we started
157 glb = glob.glob
157 glb = glob.glob
158
158
159 printf('*'*70)
159 printf('*'*70)
160 if mode == 'install':
160 if mode == 'install':
161 printf(
161 printf(
162 """Welcome to IPython. I will try to create a personal configuration directory
162 """Welcome to IPython. I will try to create a personal configuration directory
163 where you can customize many aspects of IPython's functionality in:\n""")
163 where you can customize many aspects of IPython's functionality in:\n""")
164 else:
164 else:
165 printf('I am going to upgrade your configuration in:')
165 printf('I am going to upgrade your configuration in:')
166
166
167 printf(ipythondir)
167 printf(ipythondir)
168
168
169 rcdirend = os.path.join('IPython','UserConfig')
169 rcdirend = os.path.join('IPython','UserConfig')
170 cfg = lambda d: os.path.join(d,rcdirend)
170 cfg = lambda d: os.path.join(d,rcdirend)
171 try:
171 try:
172 rcdir = filter(os.path.isdir,map(cfg,sys.path))[0]
172 rcdir = filter(os.path.isdir,map(cfg,sys.path))[0]
173 printf("Initializing from configuration: %s" % rcdir)
173 printf("Initializing from configuration: %s" % rcdir)
174 except IndexError:
174 except IndexError:
175 warning = """
175 warning = """
176 Installation error. IPython's directory was not found.
176 Installation error. IPython's directory was not found.
177
177
178 Check the following:
178 Check the following:
179
179
180 The ipython/IPython directory should be in a directory belonging to your
180 The ipython/IPython directory should be in a directory belonging to your
181 PYTHONPATH environment variable (that is, it should be in a directory
181 PYTHONPATH environment variable (that is, it should be in a directory
182 belonging to sys.path). You can copy it explicitly there or just link to it.
182 belonging to sys.path). You can copy it explicitly there or just link to it.
183
183
184 IPython will create a minimal default configuration for you.
184 IPython will create a minimal default configuration for you.
185
185
186 """
186 """
187 warn(warning)
187 warn(warning)
188 wait()
188 wait()
189
189
190 if sys.platform =='win32':
190 if sys.platform =='win32':
191 inif = 'ipythonrc.ini'
191 inif = 'ipythonrc.ini'
192 else:
192 else:
193 inif = 'ipythonrc'
193 inif = 'ipythonrc'
194 minimal_setup = {'ipy_user_conf.py' : 'import ipy_defaults',
194 minimal_setup = {'ipy_user_conf.py' : 'import ipy_defaults',
195 inif : '# intentionally left blank' }
195 inif : '# intentionally left blank' }
196 os.makedirs(ipythondir, mode = 0777)
196 os.makedirs(ipythondir, mode = 0777)
197 for f, cont in minimal_setup.items():
197 for f, cont in minimal_setup.items():
198 # In 2.5, this can be more cleanly done using 'with'
198 # In 2.5, this can be more cleanly done using 'with'
199 fobj = file(ipythondir + '/' + f,'w')
199 fobj = file(ipythondir + '/' + f,'w')
200 fobj.write(cont)
200 fobj.write(cont)
201 fobj.close()
201 fobj.close()
202
202
203 return
203 return
204
204
205 if mode == 'install':
205 if mode == 'install':
206 try:
206 try:
207 shutil.copytree(rcdir,ipythondir)
207 shutil.copytree(rcdir,ipythondir)
208 os.chdir(ipythondir)
208 os.chdir(ipythondir)
209 rc_files = glb("ipythonrc*")
209 rc_files = glb("ipythonrc*")
210 for rc_file in rc_files:
210 for rc_file in rc_files:
211 os.rename(rc_file,rc_file+rc_suffix)
211 os.rename(rc_file,rc_file+rc_suffix)
212 except:
212 except:
213 warning = """
213 warning = """
214
214
215 There was a problem with the installation:
215 There was a problem with the installation:
216 %s
216 %s
217 Try to correct it or contact the developers if you think it's a bug.
217 Try to correct it or contact the developers if you think it's a bug.
218 IPython will proceed with builtin defaults.""" % sys.exc_info()[1]
218 IPython will proceed with builtin defaults.""" % sys.exc_info()[1]
219 warn(warning)
219 warn(warning)
220 wait()
220 wait()
221 return
221 return
222
222
223 elif mode == 'upgrade':
223 elif mode == 'upgrade':
224 try:
224 try:
225 os.chdir(ipythondir)
225 os.chdir(ipythondir)
226 except:
226 except:
227 printf("""
227 printf("""
228 Can not upgrade: changing to directory %s failed. Details:
228 Can not upgrade: changing to directory %s failed. Details:
229 %s
229 %s
230 """ % (ipythondir,sys.exc_info()[1]) )
230 """ % (ipythondir,sys.exc_info()[1]) )
231 wait()
231 wait()
232 return
232 return
233 else:
233 else:
234 sources = glb(os.path.join(rcdir,'[A-Za-z]*'))
234 sources = glb(os.path.join(rcdir,'[A-Za-z]*'))
235 for new_full_path in sources:
235 for new_full_path in sources:
236 new_filename = os.path.basename(new_full_path)
236 new_filename = os.path.basename(new_full_path)
237 if new_filename.startswith('ipythonrc'):
237 if new_filename.startswith('ipythonrc'):
238 new_filename = new_filename + rc_suffix
238 new_filename = new_filename + rc_suffix
239 # The config directory should only contain files, skip any
239 # The config directory should only contain files, skip any
240 # directories which may be there (like CVS)
240 # directories which may be there (like CVS)
241 if os.path.isdir(new_full_path):
241 if os.path.isdir(new_full_path):
242 continue
242 continue
243 if os.path.exists(new_filename):
243 if os.path.exists(new_filename):
244 old_file = new_filename+'.old'
244 old_file = new_filename+'.old'
245 if os.path.exists(old_file):
245 if os.path.exists(old_file):
246 os.remove(old_file)
246 os.remove(old_file)
247 os.rename(new_filename,old_file)
247 os.rename(new_filename,old_file)
248 shutil.copy(new_full_path,new_filename)
248 shutil.copy(new_full_path,new_filename)
249 else:
249 else:
250 raise ValueError('unrecognized mode for install: %r' % mode)
250 raise ValueError('unrecognized mode for install: %r' % mode)
251
251
252 # Fix line-endings to those native to each platform in the config
252 # Fix line-endings to those native to each platform in the config
253 # directory.
253 # directory.
254 try:
254 try:
255 os.chdir(ipythondir)
255 os.chdir(ipythondir)
256 except:
256 except:
257 printf("""
257 printf("""
258 Problem: changing to directory %s failed.
258 Problem: changing to directory %s failed.
259 Details:
259 Details:
260 %s
260 %s
261
261
262 Some configuration files may have incorrect line endings. This should not
262 Some configuration files may have incorrect line endings. This should not
263 cause any problems during execution. """ % (ipythondir,sys.exc_info()[1]) )
263 cause any problems during execution. """ % (ipythondir,sys.exc_info()[1]) )
264 wait()
264 wait()
265 else:
265 else:
266 for fname in glb('ipythonrc*'):
266 for fname in glb('ipythonrc*'):
267 try:
267 try:
268 native_line_ends(fname,backup=0)
268 native_line_ends(fname,backup=0)
269 except IOError:
269 except IOError:
270 pass
270 pass
271
271
272 if mode == 'install':
272 if mode == 'install':
273 printf("""
273 printf("""
274 Successful installation!
274 Successful installation!
275
275
276 Please read the sections 'Initial Configuration' and 'Quick Tips' in the
276 Please read the sections 'Initial Configuration' and 'Quick Tips' in the
277 IPython manual (there are both HTML and PDF versions supplied with the
277 IPython manual (there are both HTML and PDF versions supplied with the
278 distribution) to make sure that your system environment is properly configured
278 distribution) to make sure that your system environment is properly configured
279 to take advantage of IPython's features.
279 to take advantage of IPython's features.
280
280
281 Important note: the configuration system has changed! The old system is
281 Important note: the configuration system has changed! The old system is
282 still in place, but its setting may be partly overridden by the settings in
282 still in place, but its setting may be partly overridden by the settings in
283 "~/.ipython/ipy_user_conf.py" config file. Please take a look at the file
283 "~/.ipython/ipy_user_conf.py" config file. Please take a look at the file
284 if some of the new settings bother you.
284 if some of the new settings bother you.
285
285
286 """)
286 """)
287 else:
287 else:
288 printf("""
288 printf("""
289 Successful upgrade!
289 Successful upgrade!
290
290
291 All files in your directory:
291 All files in your directory:
292 %(ipythondir)s
292 %(ipythondir)s
293 which would have been overwritten by the upgrade were backed up with a .old
293 which would have been overwritten by the upgrade were backed up with a .old
294 extension. If you had made particular customizations in those files you may
294 extension. If you had made particular customizations in those files you may
295 want to merge them back into the new files.""" % locals() )
295 want to merge them back into the new files.""" % locals() )
296 wait()
296 wait()
297 os.chdir(cwd)
297 os.chdir(cwd)
298
298
299 #****************************************************************************
299 #****************************************************************************
300 # Local use exceptions
300 # Local use exceptions
301 class SpaceInInput(exceptions.Exception): pass
301 class SpaceInInput(exceptions.Exception): pass
302
302
303
303
304 #****************************************************************************
304 #****************************************************************************
305 # Local use classes
305 # Local use classes
306 class Bunch: pass
306 class Bunch: pass
307
307
308 class Undefined: pass
308 class Undefined: pass
309
309
310 class Quitter(object):
310 class Quitter(object):
311 """Simple class to handle exit, similar to Python 2.5's.
311 """Simple class to handle exit, similar to Python 2.5's.
312
312
313 It handles exiting in an ipython-safe manner, which the one in Python 2.5
313 It handles exiting in an ipython-safe manner, which the one in Python 2.5
314 doesn't do (obviously, since it doesn't know about ipython)."""
314 doesn't do (obviously, since it doesn't know about ipython)."""
315
315
316 def __init__(self,shell,name):
316 def __init__(self,shell,name):
317 self.shell = shell
317 self.shell = shell
318 self.name = name
318 self.name = name
319
319
320 def __repr__(self):
320 def __repr__(self):
321 return 'Type %s() to exit.' % self.name
321 return 'Type %s() to exit.' % self.name
322 __str__ = __repr__
322 __str__ = __repr__
323
323
324 def __call__(self):
324 def __call__(self):
325 self.shell.exit()
325 self.shell.exit()
326
326
327 class InputList(list):
327 class InputList(list):
328 """Class to store user input.
328 """Class to store user input.
329
329
330 It's basically a list, but slices return a string instead of a list, thus
330 It's basically a list, but slices return a string instead of a list, thus
331 allowing things like (assuming 'In' is an instance):
331 allowing things like (assuming 'In' is an instance):
332
332
333 exec In[4:7]
333 exec In[4:7]
334
334
335 or
335 or
336
336
337 exec In[5:9] + In[14] + In[21:25]"""
337 exec In[5:9] + In[14] + In[21:25]"""
338
338
339 def __getslice__(self,i,j):
339 def __getslice__(self,i,j):
340 return ''.join(list.__getslice__(self,i,j))
340 return ''.join(list.__getslice__(self,i,j))
341
341
342 class SyntaxTB(ultraTB.ListTB):
342 class SyntaxTB(ultraTB.ListTB):
343 """Extension which holds some state: the last exception value"""
343 """Extension which holds some state: the last exception value"""
344
344
345 def __init__(self,color_scheme = 'NoColor'):
345 def __init__(self,color_scheme = 'NoColor'):
346 ultraTB.ListTB.__init__(self,color_scheme)
346 ultraTB.ListTB.__init__(self,color_scheme)
347 self.last_syntax_error = None
347 self.last_syntax_error = None
348
348
349 def __call__(self, etype, value, elist):
349 def __call__(self, etype, value, elist):
350 self.last_syntax_error = value
350 self.last_syntax_error = value
351 ultraTB.ListTB.__call__(self,etype,value,elist)
351 ultraTB.ListTB.__call__(self,etype,value,elist)
352
352
353 def clear_err_state(self):
353 def clear_err_state(self):
354 """Return the current error state and clear it"""
354 """Return the current error state and clear it"""
355 e = self.last_syntax_error
355 e = self.last_syntax_error
356 self.last_syntax_error = None
356 self.last_syntax_error = None
357 return e
357 return e
358
358
359 #****************************************************************************
359 #****************************************************************************
360 # Main IPython class
360 # Main IPython class
361
361
362 # FIXME: the Magic class is a mixin for now, and will unfortunately remain so
362 # FIXME: the Magic class is a mixin for now, and will unfortunately remain so
363 # until a full rewrite is made. I've cleaned all cross-class uses of
363 # until a full rewrite is made. I've cleaned all cross-class uses of
364 # attributes and methods, but too much user code out there relies on the
364 # attributes and methods, but too much user code out there relies on the
365 # equlity %foo == __IP.magic_foo, so I can't actually remove the mixin usage.
365 # equlity %foo == __IP.magic_foo, so I can't actually remove the mixin usage.
366 #
366 #
367 # But at least now, all the pieces have been separated and we could, in
367 # But at least now, all the pieces have been separated and we could, in
368 # principle, stop using the mixin. This will ease the transition to the
368 # principle, stop using the mixin. This will ease the transition to the
369 # chainsaw branch.
369 # chainsaw branch.
370
370
371 # For reference, the following is the list of 'self.foo' uses in the Magic
371 # For reference, the following is the list of 'self.foo' uses in the Magic
372 # class as of 2005-12-28. These are names we CAN'T use in the main ipython
372 # class as of 2005-12-28. These are names we CAN'T use in the main ipython
373 # class, to prevent clashes.
373 # class, to prevent clashes.
374
374
375 # ['self.__class__', 'self.__dict__', 'self._inspect', 'self._ofind',
375 # ['self.__class__', 'self.__dict__', 'self._inspect', 'self._ofind',
376 # 'self.arg_err', 'self.extract_input', 'self.format_', 'self.lsmagic',
376 # 'self.arg_err', 'self.extract_input', 'self.format_', 'self.lsmagic',
377 # 'self.magic_', 'self.options_table', 'self.parse', 'self.shell',
377 # 'self.magic_', 'self.options_table', 'self.parse', 'self.shell',
378 # 'self.value']
378 # 'self.value']
379
379
380 class InteractiveShell(object,Magic):
380 class InteractiveShell(object,Magic):
381 """An enhanced console for Python."""
381 """An enhanced console for Python."""
382
382
383 # class attribute to indicate whether the class supports threads or not.
383 # class attribute to indicate whether the class supports threads or not.
384 # Subclasses with thread support should override this as needed.
384 # Subclasses with thread support should override this as needed.
385 isthreaded = False
385 isthreaded = False
386
386
387 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
387 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
388 user_ns=None,user_global_ns=None,banner2='',
388 user_ns=None,user_global_ns=None,banner2='',
389 custom_exceptions=((),None),embedded=False):
389 custom_exceptions=((),None),embedded=False):
390
390
391 # log system
391 # log system
392 self.logger = Logger(self,logfname='ipython_log.py',logmode='rotate')
392 self.logger = Logger(self,logfname='ipython_log.py',logmode='rotate')
393
393
394 # Job manager (for jobs run as background threads)
394 # Job manager (for jobs run as background threads)
395 self.jobs = BackgroundJobManager()
395 self.jobs = BackgroundJobManager()
396
396
397 # Store the actual shell's name
397 # Store the actual shell's name
398 self.name = name
398 self.name = name
399 self.more = False
399 self.more = False
400
400
401 # We need to know whether the instance is meant for embedding, since
401 # We need to know whether the instance is meant for embedding, since
402 # global/local namespaces need to be handled differently in that case
402 # global/local namespaces need to be handled differently in that case
403 self.embedded = embedded
403 self.embedded = embedded
404 if embedded:
404 if embedded:
405 # Control variable so users can, from within the embedded instance,
405 # Control variable so users can, from within the embedded instance,
406 # permanently deactivate it.
406 # permanently deactivate it.
407 self.embedded_active = True
407 self.embedded_active = True
408
408
409 # command compiler
409 # command compiler
410 self.compile = codeop.CommandCompiler()
410 self.compile = codeop.CommandCompiler()
411
411
412 # User input buffer
412 # User input buffer
413 self.buffer = []
413 self.buffer = []
414
414
415 # Default name given in compilation of code
415 # Default name given in compilation of code
416 self.filename = '<ipython console>'
416 self.filename = '<ipython console>'
417
417
418 # Install our own quitter instead of the builtins. For python2.3-2.4,
418 # Install our own quitter instead of the builtins. For python2.3-2.4,
419 # this brings in behavior like 2.5, and for 2.5 it's identical.
419 # this brings in behavior like 2.5, and for 2.5 it's identical.
420 __builtin__.exit = Quitter(self,'exit')
420 __builtin__.exit = Quitter(self,'exit')
421 __builtin__.quit = Quitter(self,'quit')
421 __builtin__.quit = Quitter(self,'quit')
422
422
423 # Make an empty namespace, which extension writers can rely on both
423 # Make an empty namespace, which extension writers can rely on both
424 # existing and NEVER being used by ipython itself. This gives them a
424 # existing and NEVER being used by ipython itself. This gives them a
425 # convenient location for storing additional information and state
425 # convenient location for storing additional information and state
426 # their extensions may require, without fear of collisions with other
426 # their extensions may require, without fear of collisions with other
427 # ipython names that may develop later.
427 # ipython names that may develop later.
428 self.meta = Struct()
428 self.meta = Struct()
429
429
430 # Create the namespace where the user will operate. user_ns is
430 # Create the namespace where the user will operate. user_ns is
431 # normally the only one used, and it is passed to the exec calls as
431 # normally the only one used, and it is passed to the exec calls as
432 # the locals argument. But we do carry a user_global_ns namespace
432 # the locals argument. But we do carry a user_global_ns namespace
433 # given as the exec 'globals' argument, This is useful in embedding
433 # given as the exec 'globals' argument, This is useful in embedding
434 # situations where the ipython shell opens in a context where the
434 # situations where the ipython shell opens in a context where the
435 # distinction between locals and globals is meaningful. For
435 # distinction between locals and globals is meaningful. For
436 # non-embedded contexts, it is just the same object as the user_ns dict.
436 # non-embedded contexts, it is just the same object as the user_ns dict.
437
437
438 # FIXME. For some strange reason, __builtins__ is showing up at user
438 # FIXME. For some strange reason, __builtins__ is showing up at user
439 # level as a dict instead of a module. This is a manual fix, but I
439 # level as a dict instead of a module. This is a manual fix, but I
440 # should really track down where the problem is coming from. Alex
440 # should really track down where the problem is coming from. Alex
441 # Schmolck reported this problem first.
441 # Schmolck reported this problem first.
442
442
443 # A useful post by Alex Martelli on this topic:
443 # A useful post by Alex Martelli on this topic:
444 # Re: inconsistent value from __builtins__
444 # Re: inconsistent value from __builtins__
445 # Von: Alex Martelli <aleaxit@yahoo.com>
445 # Von: Alex Martelli <aleaxit@yahoo.com>
446 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
446 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
447 # Gruppen: comp.lang.python
447 # Gruppen: comp.lang.python
448
448
449 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
449 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
450 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
450 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
451 # > <type 'dict'>
451 # > <type 'dict'>
452 # > >>> print type(__builtins__)
452 # > >>> print type(__builtins__)
453 # > <type 'module'>
453 # > <type 'module'>
454 # > Is this difference in return value intentional?
454 # > Is this difference in return value intentional?
455
455
456 # Well, it's documented that '__builtins__' can be either a dictionary
456 # Well, it's documented that '__builtins__' can be either a dictionary
457 # or a module, and it's been that way for a long time. Whether it's
457 # or a module, and it's been that way for a long time. Whether it's
458 # intentional (or sensible), I don't know. In any case, the idea is
458 # intentional (or sensible), I don't know. In any case, the idea is
459 # that if you need to access the built-in namespace directly, you
459 # that if you need to access the built-in namespace directly, you
460 # should start with "import __builtin__" (note, no 's') which will
460 # should start with "import __builtin__" (note, no 's') which will
461 # definitely give you a module. Yeah, it's somewhat confusing:-(.
461 # definitely give you a module. Yeah, it's somewhat confusing:-(.
462
462
463 # These routines return properly built dicts as needed by the rest of
463 # These routines return properly built dicts as needed by the rest of
464 # the code, and can also be used by extension writers to generate
464 # the code, and can also be used by extension writers to generate
465 # properly initialized namespaces.
465 # properly initialized namespaces.
466 user_ns, user_global_ns = ipapi.make_user_namespaces(user_ns,
466 user_ns, user_global_ns = ipapi.make_user_namespaces(user_ns,
467 user_global_ns)
467 user_global_ns)
468
468
469 # Assign namespaces
469 # Assign namespaces
470 # This is the namespace where all normal user variables live
470 # This is the namespace where all normal user variables live
471 self.user_ns = user_ns
471 self.user_ns = user_ns
472 self.user_global_ns = user_global_ns
472 self.user_global_ns = user_global_ns
473
473
474 # An auxiliary namespace that checks what parts of the user_ns were
474 # An auxiliary namespace that checks what parts of the user_ns were
475 # loaded at startup, so we can list later only variables defined in
475 # loaded at startup, so we can list later only variables defined in
476 # actual interactive use. Since it is always a subset of user_ns, it
476 # actual interactive use. Since it is always a subset of user_ns, it
477 # doesn't need to be seaparately tracked in the ns_table
477 # doesn't need to be seaparately tracked in the ns_table
478 self.user_config_ns = {}
478 self.user_config_ns = {}
479
479
480 # A namespace to keep track of internal data structures to prevent
480 # A namespace to keep track of internal data structures to prevent
481 # them from cluttering user-visible stuff. Will be updated later
481 # them from cluttering user-visible stuff. Will be updated later
482 self.internal_ns = {}
482 self.internal_ns = {}
483
483
484 # Namespace of system aliases. Each entry in the alias
484 # Namespace of system aliases. Each entry in the alias
485 # table must be a 2-tuple of the form (N,name), where N is the number
485 # table must be a 2-tuple of the form (N,name), where N is the number
486 # of positional arguments of the alias.
486 # of positional arguments of the alias.
487 self.alias_table = {}
487 self.alias_table = {}
488
488
489 # Now that FakeModule produces a real module, we've run into a nasty
489 # Now that FakeModule produces a real module, we've run into a nasty
490 # problem: after script execution (via %run), the module where the user
490 # problem: after script execution (via %run), the module where the user
491 # code ran is deleted. Now that this object is a true module (needed
491 # code ran is deleted. Now that this object is a true module (needed
492 # so docetst and other tools work correctly), the Python module
492 # so docetst and other tools work correctly), the Python module
493 # teardown mechanism runs over it, and sets to None every variable
493 # teardown mechanism runs over it, and sets to None every variable
494 # present in that module. Top-level references to objects from the
494 # present in that module. Top-level references to objects from the
495 # script survive, because the user_ns is updated with them. However,
495 # script survive, because the user_ns is updated with them. However,
496 # calling functions defined in the script that use other things from
496 # calling functions defined in the script that use other things from
497 # the script will fail, because the function's closure had references
497 # the script will fail, because the function's closure had references
498 # to the original objects, which are now all None. So we must protect
498 # to the original objects, which are now all None. So we must protect
499 # these modules from deletion by keeping a cache.
499 # these modules from deletion by keeping a cache.
500 #
500 #
501 # To avoid keeping stale modules around (we only need the one from the
501 # To avoid keeping stale modules around (we only need the one from the
502 # last run), we use a dict keyed with the full path to the script, so
502 # last run), we use a dict keyed with the full path to the script, so
503 # only the last version of the module is held in the cache. Note,
503 # only the last version of the module is held in the cache. Note,
504 # however, that we must cache the module *namespace contents* (their
504 # however, that we must cache the module *namespace contents* (their
505 # __dict__). Because if we try to cache the actual modules, old ones
505 # __dict__). Because if we try to cache the actual modules, old ones
506 # (uncached) could be destroyed while still holding references (such as
506 # (uncached) could be destroyed while still holding references (such as
507 # those held by GUI objects that tend to be long-lived)>
507 # those held by GUI objects that tend to be long-lived)>
508 #
508 #
509 # The %reset command will flush this cache. See the cache_main_mod()
509 # The %reset command will flush this cache. See the cache_main_mod()
510 # and clear_main_mod_cache() methods for details on use.
510 # and clear_main_mod_cache() methods for details on use.
511
511
512 # This is the cache used for 'main' namespaces
512 # This is the cache used for 'main' namespaces
513 self._main_ns_cache = {}
513 self._main_ns_cache = {}
514 # And this is the single instance of FakeModule whose __dict__ we keep
514 # And this is the single instance of FakeModule whose __dict__ we keep
515 # copying and clearing for reuse on each %run
515 # copying and clearing for reuse on each %run
516 self._user_main_module = FakeModule()
516 self._user_main_module = FakeModule()
517
517
518 # A table holding all the namespaces IPython deals with, so that
518 # A table holding all the namespaces IPython deals with, so that
519 # introspection facilities can search easily.
519 # introspection facilities can search easily.
520 self.ns_table = {'user':user_ns,
520 self.ns_table = {'user':user_ns,
521 'user_global':user_global_ns,
521 'user_global':user_global_ns,
522 'alias':self.alias_table,
522 'alias':self.alias_table,
523 'internal':self.internal_ns,
523 'internal':self.internal_ns,
524 'builtin':__builtin__.__dict__
524 'builtin':__builtin__.__dict__
525 }
525 }
526
526
527 # Similarly, track all namespaces where references can be held and that
527 # Similarly, track all namespaces where references can be held and that
528 # we can safely clear (so it can NOT include builtin). This one can be
528 # we can safely clear (so it can NOT include builtin). This one can be
529 # a simple list.
529 # a simple list.
530 self.ns_refs_table = [ user_ns, user_global_ns, self.user_config_ns,
530 self.ns_refs_table = [ user_ns, user_global_ns, self.user_config_ns,
531 self.alias_table, self.internal_ns,
531 self.alias_table, self.internal_ns,
532 self._main_ns_cache ]
532 self._main_ns_cache ]
533
533
534 # We need to insert into sys.modules something that looks like a
534 # We need to insert into sys.modules something that looks like a
535 # module but which accesses the IPython namespace, for shelve and
535 # module but which accesses the IPython namespace, for shelve and
536 # pickle to work interactively. Normally they rely on getting
536 # pickle to work interactively. Normally they rely on getting
537 # everything out of __main__, but for embedding purposes each IPython
537 # everything out of __main__, but for embedding purposes each IPython
538 # instance has its own private namespace, so we can't go shoving
538 # instance has its own private namespace, so we can't go shoving
539 # everything into __main__.
539 # everything into __main__.
540
540
541 # note, however, that we should only do this for non-embedded
541 # note, however, that we should only do this for non-embedded
542 # ipythons, which really mimic the __main__.__dict__ with their own
542 # ipythons, which really mimic the __main__.__dict__ with their own
543 # namespace. Embedded instances, on the other hand, should not do
543 # namespace. Embedded instances, on the other hand, should not do
544 # this because they need to manage the user local/global namespaces
544 # this because they need to manage the user local/global namespaces
545 # only, but they live within a 'normal' __main__ (meaning, they
545 # only, but they live within a 'normal' __main__ (meaning, they
546 # shouldn't overtake the execution environment of the script they're
546 # shouldn't overtake the execution environment of the script they're
547 # embedded in).
547 # embedded in).
548
548
549 if not embedded:
549 if not embedded:
550 try:
550 try:
551 main_name = self.user_ns['__name__']
551 main_name = self.user_ns['__name__']
552 except KeyError:
552 except KeyError:
553 raise KeyError,'user_ns dictionary MUST have a "__name__" key'
553 raise KeyError,'user_ns dictionary MUST have a "__name__" key'
554 else:
554 else:
555 #print "pickle hack in place" # dbg
555 #print "pickle hack in place" # dbg
556 #print 'main_name:',main_name # dbg
556 #print 'main_name:',main_name # dbg
557 sys.modules[main_name] = FakeModule(self.user_ns)
557 sys.modules[main_name] = FakeModule(self.user_ns)
558
558
559 # List of input with multi-line handling.
559 # List of input with multi-line handling.
560 self.input_hist = InputList()
560 self.input_hist = InputList()
561 # This one will hold the 'raw' input history, without any
561 # This one will hold the 'raw' input history, without any
562 # pre-processing. This will allow users to retrieve the input just as
562 # pre-processing. This will allow users to retrieve the input just as
563 # it was exactly typed in by the user, with %hist -r.
563 # it was exactly typed in by the user, with %hist -r.
564 self.input_hist_raw = InputList()
564 self.input_hist_raw = InputList()
565
565
566 # list of visited directories
566 # list of visited directories
567 try:
567 try:
568 self.dir_hist = [os.getcwd()]
568 self.dir_hist = [os.getcwd()]
569 except OSError:
569 except OSError:
570 self.dir_hist = []
570 self.dir_hist = []
571
571
572 # dict of output history
572 # dict of output history
573 self.output_hist = {}
573 self.output_hist = {}
574
574
575 # Get system encoding at startup time. Certain terminals (like Emacs
575 # Get system encoding at startup time. Certain terminals (like Emacs
576 # under Win32 have it set to None, and we need to have a known valid
576 # under Win32 have it set to None, and we need to have a known valid
577 # encoding to use in the raw_input() method
577 # encoding to use in the raw_input() method
578 try:
578 try:
579 self.stdin_encoding = sys.stdin.encoding or 'ascii'
579 self.stdin_encoding = sys.stdin.encoding or 'ascii'
580 except AttributeError:
580 except AttributeError:
581 self.stdin_encoding = 'ascii'
581 self.stdin_encoding = 'ascii'
582
582
583 # dict of things NOT to alias (keywords, builtins and some magics)
583 # dict of things NOT to alias (keywords, builtins and some magics)
584 no_alias = {}
584 no_alias = {}
585 no_alias_magics = ['cd','popd','pushd','dhist','alias','unalias']
585 no_alias_magics = ['cd','popd','pushd','dhist','alias','unalias']
586 for key in keyword.kwlist + no_alias_magics:
586 for key in keyword.kwlist + no_alias_magics:
587 no_alias[key] = 1
587 no_alias[key] = 1
588 no_alias.update(__builtin__.__dict__)
588 no_alias.update(__builtin__.__dict__)
589 self.no_alias = no_alias
589 self.no_alias = no_alias
590
590
591 # Object variable to store code object waiting execution. This is
591 # Object variable to store code object waiting execution. This is
592 # used mainly by the multithreaded shells, but it can come in handy in
592 # used mainly by the multithreaded shells, but it can come in handy in
593 # other situations. No need to use a Queue here, since it's a single
593 # other situations. No need to use a Queue here, since it's a single
594 # item which gets cleared once run.
594 # item which gets cleared once run.
595 self.code_to_run = None
595 self.code_to_run = None
596
596
597 # escapes for automatic behavior on the command line
597 # escapes for automatic behavior on the command line
598 self.ESC_SHELL = '!'
598 self.ESC_SHELL = '!'
599 self.ESC_SH_CAP = '!!'
599 self.ESC_SH_CAP = '!!'
600 self.ESC_HELP = '?'
600 self.ESC_HELP = '?'
601 self.ESC_MAGIC = '%'
601 self.ESC_MAGIC = '%'
602 self.ESC_QUOTE = ','
602 self.ESC_QUOTE = ','
603 self.ESC_QUOTE2 = ';'
603 self.ESC_QUOTE2 = ';'
604 self.ESC_PAREN = '/'
604 self.ESC_PAREN = '/'
605
605
606 # And their associated handlers
606 # And their associated handlers
607 self.esc_handlers = {self.ESC_PAREN : self.handle_auto,
607 self.esc_handlers = {self.ESC_PAREN : self.handle_auto,
608 self.ESC_QUOTE : self.handle_auto,
608 self.ESC_QUOTE : self.handle_auto,
609 self.ESC_QUOTE2 : self.handle_auto,
609 self.ESC_QUOTE2 : self.handle_auto,
610 self.ESC_MAGIC : self.handle_magic,
610 self.ESC_MAGIC : self.handle_magic,
611 self.ESC_HELP : self.handle_help,
611 self.ESC_HELP : self.handle_help,
612 self.ESC_SHELL : self.handle_shell_escape,
612 self.ESC_SHELL : self.handle_shell_escape,
613 self.ESC_SH_CAP : self.handle_shell_escape,
613 self.ESC_SH_CAP : self.handle_shell_escape,
614 }
614 }
615
615
616 # class initializations
616 # class initializations
617 Magic.__init__(self,self)
617 Magic.__init__(self,self)
618
618
619 # Python source parser/formatter for syntax highlighting
619 # Python source parser/formatter for syntax highlighting
620 pyformat = PyColorize.Parser().format
620 pyformat = PyColorize.Parser().format
621 self.pycolorize = lambda src: pyformat(src,'str',self.rc['colors'])
621 self.pycolorize = lambda src: pyformat(src,'str',self.rc['colors'])
622
622
623 # hooks holds pointers used for user-side customizations
623 # hooks holds pointers used for user-side customizations
624 self.hooks = Struct()
624 self.hooks = Struct()
625
625
626 self.strdispatchers = {}
626 self.strdispatchers = {}
627
627
628 # Set all default hooks, defined in the IPython.hooks module.
628 # Set all default hooks, defined in the IPython.hooks module.
629 import IPython.core.hooks
629 import IPython.core.hooks
630 hooks = IPython.core.hooks
630 hooks = IPython.core.hooks
631 for hook_name in hooks.__all__:
631 for hook_name in hooks.__all__:
632 # default hooks have priority 100, i.e. low; user hooks should have
632 # default hooks have priority 100, i.e. low; user hooks should have
633 # 0-100 priority
633 # 0-100 priority
634 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
634 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
635 #print "bound hook",hook_name
635 #print "bound hook",hook_name
636
636
637 # Flag to mark unconditional exit
637 # Flag to mark unconditional exit
638 self.exit_now = False
638 self.exit_now = False
639
639
640 self.usage_min = """\
640 self.usage_min = """\
641 An enhanced console for Python.
641 An enhanced console for Python.
642 Some of its features are:
642 Some of its features are:
643 - Readline support if the readline library is present.
643 - Readline support if the readline library is present.
644 - Tab completion in the local namespace.
644 - Tab completion in the local namespace.
645 - Logging of input, see command-line options.
645 - Logging of input, see command-line options.
646 - System shell escape via ! , eg !ls.
646 - System shell escape via ! , eg !ls.
647 - Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)
647 - Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)
648 - Keeps track of locally defined variables via %who, %whos.
648 - Keeps track of locally defined variables via %who, %whos.
649 - Show object information with a ? eg ?x or x? (use ?? for more info).
649 - Show object information with a ? eg ?x or x? (use ?? for more info).
650 """
650 """
651 if usage: self.usage = usage
651 if usage: self.usage = usage
652 else: self.usage = self.usage_min
652 else: self.usage = self.usage_min
653
653
654 # Storage
654 # Storage
655 self.rc = rc # This will hold all configuration information
655 self.rc = rc # This will hold all configuration information
656 self.pager = 'less'
656 self.pager = 'less'
657 # temporary files used for various purposes. Deleted at exit.
657 # temporary files used for various purposes. Deleted at exit.
658 self.tempfiles = []
658 self.tempfiles = []
659
659
660 # Keep track of readline usage (later set by init_readline)
660 # Keep track of readline usage (later set by init_readline)
661 self.has_readline = False
661 self.has_readline = False
662
662
663 # template for logfile headers. It gets resolved at runtime by the
663 # template for logfile headers. It gets resolved at runtime by the
664 # logstart method.
664 # logstart method.
665 self.loghead_tpl = \
665 self.loghead_tpl = \
666 """#log# Automatic Logger file. *** THIS MUST BE THE FIRST LINE ***
666 """#log# Automatic Logger file. *** THIS MUST BE THE FIRST LINE ***
667 #log# DO NOT CHANGE THIS LINE OR THE TWO BELOW
667 #log# DO NOT CHANGE THIS LINE OR THE TWO BELOW
668 #log# opts = %s
668 #log# opts = %s
669 #log# args = %s
669 #log# args = %s
670 #log# It is safe to make manual edits below here.
670 #log# It is safe to make manual edits below here.
671 #log#-----------------------------------------------------------------------
671 #log#-----------------------------------------------------------------------
672 """
672 """
673 # for pushd/popd management
673 # for pushd/popd management
674 try:
674 try:
675 self.home_dir = get_home_dir()
675 self.home_dir = get_home_dir()
676 except HomeDirError,msg:
676 except HomeDirError,msg:
677 fatal(msg)
677 fatal(msg)
678
678
679 self.dir_stack = []
679 self.dir_stack = []
680
680
681 # Functions to call the underlying shell.
681 # Functions to call the underlying shell.
682
682
683 # The first is similar to os.system, but it doesn't return a value,
683 # The first is similar to os.system, but it doesn't return a value,
684 # and it allows interpolation of variables in the user's namespace.
684 # and it allows interpolation of variables in the user's namespace.
685 self.system = lambda cmd: \
685 self.system = lambda cmd: \
686 self.hooks.shell_hook(self.var_expand(cmd,depth=2))
686 self.hooks.shell_hook(self.var_expand(cmd,depth=2))
687
687
688 # These are for getoutput and getoutputerror:
688 # These are for getoutput and getoutputerror:
689 self.getoutput = lambda cmd: \
689 self.getoutput = lambda cmd: \
690 getoutput(self.var_expand(cmd,depth=2),
690 getoutput(self.var_expand(cmd,depth=2),
691 header=self.rc.system_header,
691 header=self.rc.system_header,
692 verbose=self.rc.system_verbose)
692 verbose=self.rc.system_verbose)
693
693
694 self.getoutputerror = lambda cmd: \
694 self.getoutputerror = lambda cmd: \
695 getoutputerror(self.var_expand(cmd,depth=2),
695 getoutputerror(self.var_expand(cmd,depth=2),
696 header=self.rc.system_header,
696 header=self.rc.system_header,
697 verbose=self.rc.system_verbose)
697 verbose=self.rc.system_verbose)
698
698
699
699
700 # keep track of where we started running (mainly for crash post-mortem)
700 # keep track of where we started running (mainly for crash post-mortem)
701 self.starting_dir = os.getcwd()
701 self.starting_dir = os.getcwd()
702
702
703 # Various switches which can be set
703 # Various switches which can be set
704 self.CACHELENGTH = 5000 # this is cheap, it's just text
704 self.CACHELENGTH = 5000 # this is cheap, it's just text
705 self.BANNER = "Python %(version)s on %(platform)s\n" % sys.__dict__
705 self.BANNER = "Python %(version)s on %(platform)s\n" % sys.__dict__
706 self.banner2 = banner2
706 self.banner2 = banner2
707
707
708 # TraceBack handlers:
708 # TraceBack handlers:
709
709
710 # Syntax error handler.
710 # Syntax error handler.
711 self.SyntaxTB = SyntaxTB(color_scheme='NoColor')
711 self.SyntaxTB = SyntaxTB(color_scheme='NoColor')
712
712
713 # The interactive one is initialized with an offset, meaning we always
713 # The interactive one is initialized with an offset, meaning we always
714 # want to remove the topmost item in the traceback, which is our own
714 # want to remove the topmost item in the traceback, which is our own
715 # internal code. Valid modes: ['Plain','Context','Verbose']
715 # internal code. Valid modes: ['Plain','Context','Verbose']
716 self.InteractiveTB = ultraTB.AutoFormattedTB(mode = 'Plain',
716 self.InteractiveTB = ultraTB.AutoFormattedTB(mode = 'Plain',
717 color_scheme='NoColor',
717 color_scheme='NoColor',
718 tb_offset = 1)
718 tb_offset = 1)
719
719
720 # IPython itself shouldn't crash. This will produce a detailed
720 # IPython itself shouldn't crash. This will produce a detailed
721 # post-mortem if it does. But we only install the crash handler for
721 # post-mortem if it does. But we only install the crash handler for
722 # non-threaded shells, the threaded ones use a normal verbose reporter
722 # non-threaded shells, the threaded ones use a normal verbose reporter
723 # and lose the crash handler. This is because exceptions in the main
723 # and lose the crash handler. This is because exceptions in the main
724 # thread (such as in GUI code) propagate directly to sys.excepthook,
724 # thread (such as in GUI code) propagate directly to sys.excepthook,
725 # and there's no point in printing crash dumps for every user exception.
725 # and there's no point in printing crash dumps for every user exception.
726 if self.isthreaded:
726 if self.isthreaded:
727 ipCrashHandler = ultraTB.FormattedTB()
727 ipCrashHandler = ultraTB.FormattedTB()
728 else:
728 else:
729 from IPython.core import crashhandler
729 from IPython.core import crashhandler
730 ipCrashHandler = crashhandler.IPythonCrashHandler(self)
730 ipCrashHandler = crashhandler.IPythonCrashHandler(self)
731 self.set_crash_handler(ipCrashHandler)
731 self.set_crash_handler(ipCrashHandler)
732
732
733 # and add any custom exception handlers the user may have specified
733 # and add any custom exception handlers the user may have specified
734 self.set_custom_exc(*custom_exceptions)
734 self.set_custom_exc(*custom_exceptions)
735
735
736 # indentation management
736 # indentation management
737 self.autoindent = False
737 self.autoindent = False
738 self.indent_current_nsp = 0
738 self.indent_current_nsp = 0
739
739
740 # Make some aliases automatically
740 # Make some aliases automatically
741 # Prepare list of shell aliases to auto-define
741 # Prepare list of shell aliases to auto-define
742 if os.name == 'posix':
742 if os.name == 'posix':
743 auto_alias = ('mkdir mkdir', 'rmdir rmdir',
743 auto_alias = ('mkdir mkdir', 'rmdir rmdir',
744 'mv mv -i','rm rm -i','cp cp -i',
744 'mv mv -i','rm rm -i','cp cp -i',
745 'cat cat','less less','clear clear',
745 'cat cat','less less','clear clear',
746 # a better ls
746 # a better ls
747 'ls ls -F',
747 'ls ls -F',
748 # long ls
748 # long ls
749 'll ls -lF')
749 'll ls -lF')
750 # Extra ls aliases with color, which need special treatment on BSD
750 # Extra ls aliases with color, which need special treatment on BSD
751 # variants
751 # variants
752 ls_extra = ( # color ls
752 ls_extra = ( # color ls
753 'lc ls -F -o --color',
753 'lc ls -F -o --color',
754 # ls normal files only
754 # ls normal files only
755 'lf ls -F -o --color %l | grep ^-',
755 'lf ls -F -o --color %l | grep ^-',
756 # ls symbolic links
756 # ls symbolic links
757 'lk ls -F -o --color %l | grep ^l',
757 'lk ls -F -o --color %l | grep ^l',
758 # directories or links to directories,
758 # directories or links to directories,
759 'ldir ls -F -o --color %l | grep /$',
759 'ldir ls -F -o --color %l | grep /$',
760 # things which are executable
760 # things which are executable
761 'lx ls -F -o --color %l | grep ^-..x',
761 'lx ls -F -o --color %l | grep ^-..x',
762 )
762 )
763 # The BSDs don't ship GNU ls, so they don't understand the
763 # The BSDs don't ship GNU ls, so they don't understand the
764 # --color switch out of the box
764 # --color switch out of the box
765 if 'bsd' in sys.platform:
765 if 'bsd' in sys.platform:
766 ls_extra = ( # ls normal files only
766 ls_extra = ( # ls normal files only
767 'lf ls -lF | grep ^-',
767 'lf ls -lF | grep ^-',
768 # ls symbolic links
768 # ls symbolic links
769 'lk ls -lF | grep ^l',
769 'lk ls -lF | grep ^l',
770 # directories or links to directories,
770 # directories or links to directories,
771 'ldir ls -lF | grep /$',
771 'ldir ls -lF | grep /$',
772 # things which are executable
772 # things which are executable
773 'lx ls -lF | grep ^-..x',
773 'lx ls -lF | grep ^-..x',
774 )
774 )
775 auto_alias = auto_alias + ls_extra
775 auto_alias = auto_alias + ls_extra
776 elif os.name in ['nt','dos']:
776 elif os.name in ['nt','dos']:
777 auto_alias = ('ls dir /on',
777 auto_alias = ('ls dir /on',
778 'ddir dir /ad /on', 'ldir dir /ad /on',
778 'ddir dir /ad /on', 'ldir dir /ad /on',
779 'mkdir mkdir','rmdir rmdir','echo echo',
779 'mkdir mkdir','rmdir rmdir','echo echo',
780 'ren ren','cls cls','copy copy')
780 'ren ren','cls cls','copy copy')
781 else:
781 else:
782 auto_alias = ()
782 auto_alias = ()
783 self.auto_alias = [s.split(None,1) for s in auto_alias]
783 self.auto_alias = [s.split(None,1) for s in auto_alias]
784
784
785 # Produce a public API instance
785 # Produce a public API instance
786 self.api = ipapi.IPApi(self)
786 self.api = ipapi.IPApi(self)
787
787
788 # Initialize all user-visible namespaces
788 # Initialize all user-visible namespaces
789 self.init_namespaces()
789 self.init_namespaces()
790
790
791 # Call the actual (public) initializer
791 # Call the actual (public) initializer
792 self.init_auto_alias()
792 self.init_auto_alias()
793
793
794 # track which builtins we add, so we can clean up later
794 # track which builtins we add, so we can clean up later
795 self.builtins_added = {}
795 self.builtins_added = {}
796 # This method will add the necessary builtins for operation, but
796 # This method will add the necessary builtins for operation, but
797 # tracking what it did via the builtins_added dict.
797 # tracking what it did via the builtins_added dict.
798
798
799 #TODO: remove this, redundant
799 #TODO: remove this, redundant
800 self.add_builtins()
800 self.add_builtins()
801 # end __init__
801 # end __init__
802
802
803 def var_expand(self,cmd,depth=0):
803 def var_expand(self,cmd,depth=0):
804 """Expand python variables in a string.
804 """Expand python variables in a string.
805
805
806 The depth argument indicates how many frames above the caller should
806 The depth argument indicates how many frames above the caller should
807 be walked to look for the local namespace where to expand variables.
807 be walked to look for the local namespace where to expand variables.
808
808
809 The global namespace for expansion is always the user's interactive
809 The global namespace for expansion is always the user's interactive
810 namespace.
810 namespace.
811 """
811 """
812
812
813 return str(ItplNS(cmd,
813 return str(ItplNS(cmd,
814 self.user_ns, # globals
814 self.user_ns, # globals
815 # Skip our own frame in searching for locals:
815 # Skip our own frame in searching for locals:
816 sys._getframe(depth+1).f_locals # locals
816 sys._getframe(depth+1).f_locals # locals
817 ))
817 ))
818
818
819 def pre_config_initialization(self):
819 def pre_config_initialization(self):
820 """Pre-configuration init method
820 """Pre-configuration init method
821
821
822 This is called before the configuration files are processed to
822 This is called before the configuration files are processed to
823 prepare the services the config files might need.
823 prepare the services the config files might need.
824
824
825 self.rc already has reasonable default values at this point.
825 self.rc already has reasonable default values at this point.
826 """
826 """
827 rc = self.rc
827 rc = self.rc
828 try:
828 try:
829 self.db = pickleshare.PickleShareDB(rc.ipythondir + "/db")
829 self.db = pickleshare.PickleShareDB(rc.ipythondir + "/db")
830 except exceptions.UnicodeDecodeError:
830 except exceptions.UnicodeDecodeError:
831 print "Your ipythondir can't be decoded to unicode!"
831 print "Your ipythondir can't be decoded to unicode!"
832 print "Please set HOME environment variable to something that"
832 print "Please set HOME environment variable to something that"
833 print r"only has ASCII characters, e.g. c:\home"
833 print r"only has ASCII characters, e.g. c:\home"
834 print "Now it is",rc.ipythondir
834 print "Now it is",rc.ipythondir
835 sys.exit()
835 sys.exit()
836 self.shadowhist = IPython.core.history.ShadowHist(self.db)
836 self.shadowhist = IPython.core.history.ShadowHist(self.db)
837
837
838 def post_config_initialization(self):
838 def post_config_initialization(self):
839 """Post configuration init method
839 """Post configuration init method
840
840
841 This is called after the configuration files have been processed to
841 This is called after the configuration files have been processed to
842 'finalize' the initialization."""
842 'finalize' the initialization."""
843
843
844 rc = self.rc
844 rc = self.rc
845
845
846 # Object inspector
846 # Object inspector
847 self.inspector = OInspect.Inspector(OInspect.InspectColors,
847 self.inspector = OInspect.Inspector(OInspect.InspectColors,
848 PyColorize.ANSICodeColors,
848 PyColorize.ANSICodeColors,
849 'NoColor',
849 'NoColor',
850 rc.object_info_string_level)
850 rc.object_info_string_level)
851
851
852 self.rl_next_input = None
852 self.rl_next_input = None
853 self.rl_do_indent = False
853 self.rl_do_indent = False
854 # Load readline proper
854 # Load readline proper
855 if rc.readline:
855 if rc.readline:
856 self.init_readline()
856 self.init_readline()
857
857
858 # local shortcut, this is used a LOT
858 # local shortcut, this is used a LOT
859 self.log = self.logger.log
859 self.log = self.logger.log
860
860
861 # Initialize cache, set in/out prompts and printing system
861 # Initialize cache, set in/out prompts and printing system
862 self.outputcache = CachedOutput(self,
862 self.outputcache = CachedOutput(self,
863 rc.cache_size,
863 rc.cache_size,
864 rc.pprint,
864 rc.pprint,
865 input_sep = rc.separate_in,
865 input_sep = rc.separate_in,
866 output_sep = rc.separate_out,
866 output_sep = rc.separate_out,
867 output_sep2 = rc.separate_out2,
867 output_sep2 = rc.separate_out2,
868 ps1 = rc.prompt_in1,
868 ps1 = rc.prompt_in1,
869 ps2 = rc.prompt_in2,
869 ps2 = rc.prompt_in2,
870 ps_out = rc.prompt_out,
870 ps_out = rc.prompt_out,
871 pad_left = rc.prompts_pad_left)
871 pad_left = rc.prompts_pad_left)
872
872
873 # user may have over-ridden the default print hook:
873 # user may have over-ridden the default print hook:
874 try:
874 try:
875 self.outputcache.__class__.display = self.hooks.display
875 self.outputcache.__class__.display = self.hooks.display
876 except AttributeError:
876 except AttributeError:
877 pass
877 pass
878
878
879 # I don't like assigning globally to sys, because it means when
879 # I don't like assigning globally to sys, because it means when
880 # embedding instances, each embedded instance overrides the previous
880 # embedding instances, each embedded instance overrides the previous
881 # choice. But sys.displayhook seems to be called internally by exec,
881 # choice. But sys.displayhook seems to be called internally by exec,
882 # so I don't see a way around it. We first save the original and then
882 # so I don't see a way around it. We first save the original and then
883 # overwrite it.
883 # overwrite it.
884 self.sys_displayhook = sys.displayhook
884 self.sys_displayhook = sys.displayhook
885 sys.displayhook = self.outputcache
885 sys.displayhook = self.outputcache
886
886
887 # Do a proper resetting of doctest, including the necessary displayhook
887 # Do a proper resetting of doctest, including the necessary displayhook
888 # monkeypatching
888 # monkeypatching
889 try:
889 try:
890 doctest_reload()
890 doctest_reload()
891 except ImportError:
891 except ImportError:
892 warn("doctest module does not exist.")
892 warn("doctest module does not exist.")
893
893
894 # Set user colors (don't do it in the constructor above so that it
894 # Set user colors (don't do it in the constructor above so that it
895 # doesn't crash if colors option is invalid)
895 # doesn't crash if colors option is invalid)
896 self.magic_colors(rc.colors)
896 self.magic_colors(rc.colors)
897
897
898 # Set calling of pdb on exceptions
898 # Set calling of pdb on exceptions
899 self.call_pdb = rc.pdb
899 self.call_pdb = rc.pdb
900
900
901 # Load user aliases
901 # Load user aliases
902 for alias in rc.alias:
902 for alias in rc.alias:
903 self.magic_alias(alias)
903 self.magic_alias(alias)
904
904
905 self.hooks.late_startup_hook()
905 self.hooks.late_startup_hook()
906
906
907 for cmd in self.rc.autoexec:
907 for cmd in self.rc.autoexec:
908 #print "autoexec>",cmd #dbg
908 #print "autoexec>",cmd #dbg
909 self.api.runlines(cmd)
909 self.api.runlines(cmd)
910
910
911 batchrun = False
911 batchrun = False
912 for batchfile in [path(arg) for arg in self.rc.args
912 for batchfile in [path(arg) for arg in self.rc.args
913 if arg.lower().endswith('.ipy')]:
913 if arg.lower().endswith('.ipy')]:
914 if not batchfile.isfile():
914 if not batchfile.isfile():
915 print "No such batch file:", batchfile
915 print "No such batch file:", batchfile
916 continue
916 continue
917 self.api.runlines(batchfile.text())
917 self.api.runlines(batchfile.text())
918 batchrun = True
918 batchrun = True
919 # without -i option, exit after running the batch file
919 # without -i option, exit after running the batch file
920 if batchrun and not self.rc.interact:
920 if batchrun and not self.rc.interact:
921 self.ask_exit()
921 self.ask_exit()
922
922
923 def init_namespaces(self):
923 def init_namespaces(self):
924 """Initialize all user-visible namespaces to their minimum defaults.
924 """Initialize all user-visible namespaces to their minimum defaults.
925
925
926 Certain history lists are also initialized here, as they effectively
926 Certain history lists are also initialized here, as they effectively
927 act as user namespaces.
927 act as user namespaces.
928
928
929 Note
929 Note
930 ----
930 ----
931 All data structures here are only filled in, they are NOT reset by this
931 All data structures here are only filled in, they are NOT reset by this
932 method. If they were not empty before, data will simply be added to
932 method. If they were not empty before, data will simply be added to
933 therm.
933 therm.
934 """
934 """
935 # The user namespace MUST have a pointer to the shell itself.
935 # The user namespace MUST have a pointer to the shell itself.
936 self.user_ns[self.name] = self
936 self.user_ns[self.name] = self
937
937
938 # Store the public api instance
938 # Store the public api instance
939 self.user_ns['_ip'] = self.api
939 self.user_ns['_ip'] = self.api
940
940
941 # make global variables for user access to the histories
941 # make global variables for user access to the histories
942 self.user_ns['_ih'] = self.input_hist
942 self.user_ns['_ih'] = self.input_hist
943 self.user_ns['_oh'] = self.output_hist
943 self.user_ns['_oh'] = self.output_hist
944 self.user_ns['_dh'] = self.dir_hist
944 self.user_ns['_dh'] = self.dir_hist
945
945
946 # user aliases to input and output histories
946 # user aliases to input and output histories
947 self.user_ns['In'] = self.input_hist
947 self.user_ns['In'] = self.input_hist
948 self.user_ns['Out'] = self.output_hist
948 self.user_ns['Out'] = self.output_hist
949
949
950 self.user_ns['_sh'] = IPython.shadowns
950 self.user_ns['_sh'] = IPython.shadowns
951
951
952 # Fill the history zero entry, user counter starts at 1
952 # Fill the history zero entry, user counter starts at 1
953 self.input_hist.append('\n')
953 self.input_hist.append('\n')
954 self.input_hist_raw.append('\n')
954 self.input_hist_raw.append('\n')
955
955
956 def add_builtins(self):
956 def add_builtins(self):
957 """Store ipython references into the builtin namespace.
957 """Store ipython references into the builtin namespace.
958
958
959 Some parts of ipython operate via builtins injected here, which hold a
959 Some parts of ipython operate via builtins injected here, which hold a
960 reference to IPython itself."""
960 reference to IPython itself."""
961
961
962 # TODO: deprecate all of these, they are unsafe
962 # TODO: deprecate all of these, they are unsafe
963 builtins_new = dict(__IPYTHON__ = self,
963 builtins_new = dict(__IPYTHON__ = self,
964 ip_set_hook = self.set_hook,
964 ip_set_hook = self.set_hook,
965 jobs = self.jobs,
965 jobs = self.jobs,
966 ipmagic = wrap_deprecated(self.ipmagic,'_ip.magic()'),
966 ipmagic = wrap_deprecated(self.ipmagic,'_ip.magic()'),
967 ipalias = wrap_deprecated(self.ipalias),
967 ipalias = wrap_deprecated(self.ipalias),
968 ipsystem = wrap_deprecated(self.ipsystem,'_ip.system()'),
968 ipsystem = wrap_deprecated(self.ipsystem,'_ip.system()'),
969 #_ip = self.api
969 #_ip = self.api
970 )
970 )
971 for biname,bival in builtins_new.items():
971 for biname,bival in builtins_new.items():
972 try:
972 try:
973 # store the orignal value so we can restore it
973 # store the orignal value so we can restore it
974 self.builtins_added[biname] = __builtin__.__dict__[biname]
974 self.builtins_added[biname] = __builtin__.__dict__[biname]
975 except KeyError:
975 except KeyError:
976 # or mark that it wasn't defined, and we'll just delete it at
976 # or mark that it wasn't defined, and we'll just delete it at
977 # cleanup
977 # cleanup
978 self.builtins_added[biname] = Undefined
978 self.builtins_added[biname] = Undefined
979 __builtin__.__dict__[biname] = bival
979 __builtin__.__dict__[biname] = bival
980
980
981 # Keep in the builtins a flag for when IPython is active. We set it
981 # Keep in the builtins a flag for when IPython is active. We set it
982 # with setdefault so that multiple nested IPythons don't clobber one
982 # with setdefault so that multiple nested IPythons don't clobber one
983 # another. Each will increase its value by one upon being activated,
983 # another. Each will increase its value by one upon being activated,
984 # which also gives us a way to determine the nesting level.
984 # which also gives us a way to determine the nesting level.
985 __builtin__.__dict__.setdefault('__IPYTHON__active',0)
985 __builtin__.__dict__.setdefault('__IPYTHON__active',0)
986
986
987 def clean_builtins(self):
987 def clean_builtins(self):
988 """Remove any builtins which might have been added by add_builtins, or
988 """Remove any builtins which might have been added by add_builtins, or
989 restore overwritten ones to their previous values."""
989 restore overwritten ones to their previous values."""
990 for biname,bival in self.builtins_added.items():
990 for biname,bival in self.builtins_added.items():
991 if bival is Undefined:
991 if bival is Undefined:
992 del __builtin__.__dict__[biname]
992 del __builtin__.__dict__[biname]
993 else:
993 else:
994 __builtin__.__dict__[biname] = bival
994 __builtin__.__dict__[biname] = bival
995 self.builtins_added.clear()
995 self.builtins_added.clear()
996
996
997 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
997 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
998 """set_hook(name,hook) -> sets an internal IPython hook.
998 """set_hook(name,hook) -> sets an internal IPython hook.
999
999
1000 IPython exposes some of its internal API as user-modifiable hooks. By
1000 IPython exposes some of its internal API as user-modifiable hooks. By
1001 adding your function to one of these hooks, you can modify IPython's
1001 adding your function to one of these hooks, you can modify IPython's
1002 behavior to call at runtime your own routines."""
1002 behavior to call at runtime your own routines."""
1003
1003
1004 # At some point in the future, this should validate the hook before it
1004 # At some point in the future, this should validate the hook before it
1005 # accepts it. Probably at least check that the hook takes the number
1005 # accepts it. Probably at least check that the hook takes the number
1006 # of args it's supposed to.
1006 # of args it's supposed to.
1007
1007
1008 f = new.instancemethod(hook,self,self.__class__)
1008 f = new.instancemethod(hook,self,self.__class__)
1009
1009
1010 # check if the hook is for strdispatcher first
1010 # check if the hook is for strdispatcher first
1011 if str_key is not None:
1011 if str_key is not None:
1012 sdp = self.strdispatchers.get(name, StrDispatch())
1012 sdp = self.strdispatchers.get(name, StrDispatch())
1013 sdp.add_s(str_key, f, priority )
1013 sdp.add_s(str_key, f, priority )
1014 self.strdispatchers[name] = sdp
1014 self.strdispatchers[name] = sdp
1015 return
1015 return
1016 if re_key is not None:
1016 if re_key is not None:
1017 sdp = self.strdispatchers.get(name, StrDispatch())
1017 sdp = self.strdispatchers.get(name, StrDispatch())
1018 sdp.add_re(re.compile(re_key), f, priority )
1018 sdp.add_re(re.compile(re_key), f, priority )
1019 self.strdispatchers[name] = sdp
1019 self.strdispatchers[name] = sdp
1020 return
1020 return
1021
1021
1022 dp = getattr(self.hooks, name, None)
1022 dp = getattr(self.hooks, name, None)
1023 if name not in IPython.core.hooks.__all__:
1023 if name not in IPython.core.hooks.__all__:
1024 print "Warning! Hook '%s' is not one of %s" % (name, IPython.core.hooks.__all__ )
1024 print "Warning! Hook '%s' is not one of %s" % (name, IPython.core.hooks.__all__ )
1025 if not dp:
1025 if not dp:
1026 dp = IPython.core.hooks.CommandChainDispatcher()
1026 dp = IPython.core.hooks.CommandChainDispatcher()
1027
1027
1028 try:
1028 try:
1029 dp.add(f,priority)
1029 dp.add(f,priority)
1030 except AttributeError:
1030 except AttributeError:
1031 # it was not commandchain, plain old func - replace
1031 # it was not commandchain, plain old func - replace
1032 dp = f
1032 dp = f
1033
1033
1034 setattr(self.hooks,name, dp)
1034 setattr(self.hooks,name, dp)
1035
1035
1036
1036
1037 #setattr(self.hooks,name,new.instancemethod(hook,self,self.__class__))
1037 #setattr(self.hooks,name,new.instancemethod(hook,self,self.__class__))
1038
1038
1039 def set_crash_handler(self,crashHandler):
1039 def set_crash_handler(self,crashHandler):
1040 """Set the IPython crash handler.
1040 """Set the IPython crash handler.
1041
1041
1042 This must be a callable with a signature suitable for use as
1042 This must be a callable with a signature suitable for use as
1043 sys.excepthook."""
1043 sys.excepthook."""
1044
1044
1045 # Install the given crash handler as the Python exception hook
1045 # Install the given crash handler as the Python exception hook
1046 sys.excepthook = crashHandler
1046 sys.excepthook = crashHandler
1047
1047
1048 # The instance will store a pointer to this, so that runtime code
1048 # The instance will store a pointer to this, so that runtime code
1049 # (such as magics) can access it. This is because during the
1049 # (such as magics) can access it. This is because during the
1050 # read-eval loop, it gets temporarily overwritten (to deal with GUI
1050 # read-eval loop, it gets temporarily overwritten (to deal with GUI
1051 # frameworks).
1051 # frameworks).
1052 self.sys_excepthook = sys.excepthook
1052 self.sys_excepthook = sys.excepthook
1053
1053
1054
1054
1055 def set_custom_exc(self,exc_tuple,handler):
1055 def set_custom_exc(self,exc_tuple,handler):
1056 """set_custom_exc(exc_tuple,handler)
1056 """set_custom_exc(exc_tuple,handler)
1057
1057
1058 Set a custom exception handler, which will be called if any of the
1058 Set a custom exception handler, which will be called if any of the
1059 exceptions in exc_tuple occur in the mainloop (specifically, in the
1059 exceptions in exc_tuple occur in the mainloop (specifically, in the
1060 runcode() method.
1060 runcode() method.
1061
1061
1062 Inputs:
1062 Inputs:
1063
1063
1064 - exc_tuple: a *tuple* of valid exceptions to call the defined
1064 - exc_tuple: a *tuple* of valid exceptions to call the defined
1065 handler for. It is very important that you use a tuple, and NOT A
1065 handler for. It is very important that you use a tuple, and NOT A
1066 LIST here, because of the way Python's except statement works. If
1066 LIST here, because of the way Python's except statement works. If
1067 you only want to trap a single exception, use a singleton tuple:
1067 you only want to trap a single exception, use a singleton tuple:
1068
1068
1069 exc_tuple == (MyCustomException,)
1069 exc_tuple == (MyCustomException,)
1070
1070
1071 - handler: this must be defined as a function with the following
1071 - handler: this must be defined as a function with the following
1072 basic interface: def my_handler(self,etype,value,tb).
1072 basic interface: def my_handler(self,etype,value,tb).
1073
1073
1074 This will be made into an instance method (via new.instancemethod)
1074 This will be made into an instance method (via new.instancemethod)
1075 of IPython itself, and it will be called if any of the exceptions
1075 of IPython itself, and it will be called if any of the exceptions
1076 listed in the exc_tuple are caught. If the handler is None, an
1076 listed in the exc_tuple are caught. If the handler is None, an
1077 internal basic one is used, which just prints basic info.
1077 internal basic one is used, which just prints basic info.
1078
1078
1079 WARNING: by putting in your own exception handler into IPython's main
1079 WARNING: by putting in your own exception handler into IPython's main
1080 execution loop, you run a very good chance of nasty crashes. This
1080 execution loop, you run a very good chance of nasty crashes. This
1081 facility should only be used if you really know what you are doing."""
1081 facility should only be used if you really know what you are doing."""
1082
1082
1083 assert type(exc_tuple)==type(()) , \
1083 assert type(exc_tuple)==type(()) , \
1084 "The custom exceptions must be given AS A TUPLE."
1084 "The custom exceptions must be given AS A TUPLE."
1085
1085
1086 def dummy_handler(self,etype,value,tb):
1086 def dummy_handler(self,etype,value,tb):
1087 print '*** Simple custom exception handler ***'
1087 print '*** Simple custom exception handler ***'
1088 print 'Exception type :',etype
1088 print 'Exception type :',etype
1089 print 'Exception value:',value
1089 print 'Exception value:',value
1090 print 'Traceback :',tb
1090 print 'Traceback :',tb
1091 print 'Source code :','\n'.join(self.buffer)
1091 print 'Source code :','\n'.join(self.buffer)
1092
1092
1093 if handler is None: handler = dummy_handler
1093 if handler is None: handler = dummy_handler
1094
1094
1095 self.CustomTB = new.instancemethod(handler,self,self.__class__)
1095 self.CustomTB = new.instancemethod(handler,self,self.__class__)
1096 self.custom_exceptions = exc_tuple
1096 self.custom_exceptions = exc_tuple
1097
1097
1098 def set_custom_completer(self,completer,pos=0):
1098 def set_custom_completer(self,completer,pos=0):
1099 """set_custom_completer(completer,pos=0)
1099 """set_custom_completer(completer,pos=0)
1100
1100
1101 Adds a new custom completer function.
1101 Adds a new custom completer function.
1102
1102
1103 The position argument (defaults to 0) is the index in the completers
1103 The position argument (defaults to 0) is the index in the completers
1104 list where you want the completer to be inserted."""
1104 list where you want the completer to be inserted."""
1105
1105
1106 newcomp = new.instancemethod(completer,self.Completer,
1106 newcomp = new.instancemethod(completer,self.Completer,
1107 self.Completer.__class__)
1107 self.Completer.__class__)
1108 self.Completer.matchers.insert(pos,newcomp)
1108 self.Completer.matchers.insert(pos,newcomp)
1109
1109
1110 def set_completer(self):
1110 def set_completer(self):
1111 """reset readline's completer to be our own."""
1111 """reset readline's completer to be our own."""
1112 self.readline.set_completer(self.Completer.complete)
1112 self.readline.set_completer(self.Completer.complete)
1113
1113
1114 def _get_call_pdb(self):
1114 def _get_call_pdb(self):
1115 return self._call_pdb
1115 return self._call_pdb
1116
1116
1117 def _set_call_pdb(self,val):
1117 def _set_call_pdb(self,val):
1118
1118
1119 if val not in (0,1,False,True):
1119 if val not in (0,1,False,True):
1120 raise ValueError,'new call_pdb value must be boolean'
1120 raise ValueError,'new call_pdb value must be boolean'
1121
1121
1122 # store value in instance
1122 # store value in instance
1123 self._call_pdb = val
1123 self._call_pdb = val
1124
1124
1125 # notify the actual exception handlers
1125 # notify the actual exception handlers
1126 self.InteractiveTB.call_pdb = val
1126 self.InteractiveTB.call_pdb = val
1127 if self.isthreaded:
1127 if self.isthreaded:
1128 try:
1128 try:
1129 self.sys_excepthook.call_pdb = val
1129 self.sys_excepthook.call_pdb = val
1130 except:
1130 except:
1131 warn('Failed to activate pdb for threaded exception handler')
1131 warn('Failed to activate pdb for threaded exception handler')
1132
1132
1133 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
1133 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
1134 'Control auto-activation of pdb at exceptions')
1134 'Control auto-activation of pdb at exceptions')
1135
1135
1136 # These special functions get installed in the builtin namespace, to
1136 # These special functions get installed in the builtin namespace, to
1137 # provide programmatic (pure python) access to magics, aliases and system
1137 # provide programmatic (pure python) access to magics, aliases and system
1138 # calls. This is important for logging, user scripting, and more.
1138 # calls. This is important for logging, user scripting, and more.
1139
1139
1140 # We are basically exposing, via normal python functions, the three
1140 # We are basically exposing, via normal python functions, the three
1141 # mechanisms in which ipython offers special call modes (magics for
1141 # mechanisms in which ipython offers special call modes (magics for
1142 # internal control, aliases for direct system access via pre-selected
1142 # internal control, aliases for direct system access via pre-selected
1143 # names, and !cmd for calling arbitrary system commands).
1143 # names, and !cmd for calling arbitrary system commands).
1144
1144
1145 def ipmagic(self,arg_s):
1145 def ipmagic(self,arg_s):
1146 """Call a magic function by name.
1146 """Call a magic function by name.
1147
1147
1148 Input: a string containing the name of the magic function to call and any
1148 Input: a string containing the name of the magic function to call and any
1149 additional arguments to be passed to the magic.
1149 additional arguments to be passed to the magic.
1150
1150
1151 ipmagic('name -opt foo bar') is equivalent to typing at the ipython
1151 ipmagic('name -opt foo bar') is equivalent to typing at the ipython
1152 prompt:
1152 prompt:
1153
1153
1154 In[1]: %name -opt foo bar
1154 In[1]: %name -opt foo bar
1155
1155
1156 To call a magic without arguments, simply use ipmagic('name').
1156 To call a magic without arguments, simply use ipmagic('name').
1157
1157
1158 This provides a proper Python function to call IPython's magics in any
1158 This provides a proper Python function to call IPython's magics in any
1159 valid Python code you can type at the interpreter, including loops and
1159 valid Python code you can type at the interpreter, including loops and
1160 compound statements. It is added by IPython to the Python builtin
1160 compound statements. It is added by IPython to the Python builtin
1161 namespace upon initialization."""
1161 namespace upon initialization."""
1162
1162
1163 args = arg_s.split(' ',1)
1163 args = arg_s.split(' ',1)
1164 magic_name = args[0]
1164 magic_name = args[0]
1165 magic_name = magic_name.lstrip(self.ESC_MAGIC)
1165 magic_name = magic_name.lstrip(self.ESC_MAGIC)
1166
1166
1167 try:
1167 try:
1168 magic_args = args[1]
1168 magic_args = args[1]
1169 except IndexError:
1169 except IndexError:
1170 magic_args = ''
1170 magic_args = ''
1171 fn = getattr(self,'magic_'+magic_name,None)
1171 fn = getattr(self,'magic_'+magic_name,None)
1172 if fn is None:
1172 if fn is None:
1173 error("Magic function `%s` not found." % magic_name)
1173 error("Magic function `%s` not found." % magic_name)
1174 else:
1174 else:
1175 magic_args = self.var_expand(magic_args,1)
1175 magic_args = self.var_expand(magic_args,1)
1176 return fn(magic_args)
1176 return fn(magic_args)
1177
1177
1178 def ipalias(self,arg_s):
1178 def ipalias(self,arg_s):
1179 """Call an alias by name.
1179 """Call an alias by name.
1180
1180
1181 Input: a string containing the name of the alias to call and any
1181 Input: a string containing the name of the alias to call and any
1182 additional arguments to be passed to the magic.
1182 additional arguments to be passed to the magic.
1183
1183
1184 ipalias('name -opt foo bar') is equivalent to typing at the ipython
1184 ipalias('name -opt foo bar') is equivalent to typing at the ipython
1185 prompt:
1185 prompt:
1186
1186
1187 In[1]: name -opt foo bar
1187 In[1]: name -opt foo bar
1188
1188
1189 To call an alias without arguments, simply use ipalias('name').
1189 To call an alias without arguments, simply use ipalias('name').
1190
1190
1191 This provides a proper Python function to call IPython's aliases in any
1191 This provides a proper Python function to call IPython's aliases in any
1192 valid Python code you can type at the interpreter, including loops and
1192 valid Python code you can type at the interpreter, including loops and
1193 compound statements. It is added by IPython to the Python builtin
1193 compound statements. It is added by IPython to the Python builtin
1194 namespace upon initialization."""
1194 namespace upon initialization."""
1195
1195
1196 args = arg_s.split(' ',1)
1196 args = arg_s.split(' ',1)
1197 alias_name = args[0]
1197 alias_name = args[0]
1198 try:
1198 try:
1199 alias_args = args[1]
1199 alias_args = args[1]
1200 except IndexError:
1200 except IndexError:
1201 alias_args = ''
1201 alias_args = ''
1202 if alias_name in self.alias_table:
1202 if alias_name in self.alias_table:
1203 self.call_alias(alias_name,alias_args)
1203 self.call_alias(alias_name,alias_args)
1204 else:
1204 else:
1205 error("Alias `%s` not found." % alias_name)
1205 error("Alias `%s` not found." % alias_name)
1206
1206
1207 def ipsystem(self,arg_s):
1207 def ipsystem(self,arg_s):
1208 """Make a system call, using IPython."""
1208 """Make a system call, using IPython."""
1209
1209
1210 self.system(arg_s)
1210 self.system(arg_s)
1211
1211
1212 def complete(self,text):
1212 def complete(self,text):
1213 """Return a sorted list of all possible completions on text.
1213 """Return a sorted list of all possible completions on text.
1214
1214
1215 Inputs:
1215 Inputs:
1216
1216
1217 - text: a string of text to be completed on.
1217 - text: a string of text to be completed on.
1218
1218
1219 This is a wrapper around the completion mechanism, similar to what
1219 This is a wrapper around the completion mechanism, similar to what
1220 readline does at the command line when the TAB key is hit. By
1220 readline does at the command line when the TAB key is hit. By
1221 exposing it as a method, it can be used by other non-readline
1221 exposing it as a method, it can be used by other non-readline
1222 environments (such as GUIs) for text completion.
1222 environments (such as GUIs) for text completion.
1223
1223
1224 Simple usage example:
1224 Simple usage example:
1225
1225
1226 In [7]: x = 'hello'
1226 In [7]: x = 'hello'
1227
1227
1228 In [8]: x
1228 In [8]: x
1229 Out[8]: 'hello'
1229 Out[8]: 'hello'
1230
1230
1231 In [9]: print x
1231 In [9]: print x
1232 hello
1232 hello
1233
1233
1234 In [10]: _ip.IP.complete('x.l')
1234 In [10]: _ip.IP.complete('x.l')
1235 Out[10]: ['x.ljust', 'x.lower', 'x.lstrip']
1235 Out[10]: ['x.ljust', 'x.lower', 'x.lstrip']
1236 """
1236 """
1237
1237
1238 complete = self.Completer.complete
1238 complete = self.Completer.complete
1239 state = 0
1239 state = 0
1240 # use a dict so we get unique keys, since ipyhton's multiple
1240 # use a dict so we get unique keys, since ipyhton's multiple
1241 # completers can return duplicates. When we make 2.4 a requirement,
1241 # completers can return duplicates. When we make 2.4 a requirement,
1242 # start using sets instead, which are faster.
1242 # start using sets instead, which are faster.
1243 comps = {}
1243 comps = {}
1244 while True:
1244 while True:
1245 newcomp = complete(text,state,line_buffer=text)
1245 newcomp = complete(text,state,line_buffer=text)
1246 if newcomp is None:
1246 if newcomp is None:
1247 break
1247 break
1248 comps[newcomp] = 1
1248 comps[newcomp] = 1
1249 state += 1
1249 state += 1
1250 outcomps = comps.keys()
1250 outcomps = comps.keys()
1251 outcomps.sort()
1251 outcomps.sort()
1252 #print "T:",text,"OC:",outcomps # dbg
1252 #print "T:",text,"OC:",outcomps # dbg
1253 #print "vars:",self.user_ns.keys()
1253 #print "vars:",self.user_ns.keys()
1254 return outcomps
1254 return outcomps
1255
1255
1256 def set_completer_frame(self, frame=None):
1256 def set_completer_frame(self, frame=None):
1257 if frame:
1257 if frame:
1258 self.Completer.namespace = frame.f_locals
1258 self.Completer.namespace = frame.f_locals
1259 self.Completer.global_namespace = frame.f_globals
1259 self.Completer.global_namespace = frame.f_globals
1260 else:
1260 else:
1261 self.Completer.namespace = self.user_ns
1261 self.Completer.namespace = self.user_ns
1262 self.Completer.global_namespace = self.user_global_ns
1262 self.Completer.global_namespace = self.user_global_ns
1263
1263
1264 def init_auto_alias(self):
1264 def init_auto_alias(self):
1265 """Define some aliases automatically.
1265 """Define some aliases automatically.
1266
1266
1267 These are ALL parameter-less aliases"""
1267 These are ALL parameter-less aliases"""
1268
1268
1269 for alias,cmd in self.auto_alias:
1269 for alias,cmd in self.auto_alias:
1270 self.getapi().defalias(alias,cmd)
1270 self.getapi().defalias(alias,cmd)
1271
1271
1272
1272
1273 def alias_table_validate(self,verbose=0):
1273 def alias_table_validate(self,verbose=0):
1274 """Update information about the alias table.
1274 """Update information about the alias table.
1275
1275
1276 In particular, make sure no Python keywords/builtins are in it."""
1276 In particular, make sure no Python keywords/builtins are in it."""
1277
1277
1278 no_alias = self.no_alias
1278 no_alias = self.no_alias
1279 for k in self.alias_table.keys():
1279 for k in self.alias_table.keys():
1280 if k in no_alias:
1280 if k in no_alias:
1281 del self.alias_table[k]
1281 del self.alias_table[k]
1282 if verbose:
1282 if verbose:
1283 print ("Deleting alias <%s>, it's a Python "
1283 print ("Deleting alias <%s>, it's a Python "
1284 "keyword or builtin." % k)
1284 "keyword or builtin." % k)
1285
1285
1286 def set_autoindent(self,value=None):
1286 def set_autoindent(self,value=None):
1287 """Set the autoindent flag, checking for readline support.
1287 """Set the autoindent flag, checking for readline support.
1288
1288
1289 If called with no arguments, it acts as a toggle."""
1289 If called with no arguments, it acts as a toggle."""
1290
1290
1291 if not self.has_readline:
1291 if not self.has_readline:
1292 if os.name == 'posix':
1292 if os.name == 'posix':
1293 warn("The auto-indent feature requires the readline library")
1293 warn("The auto-indent feature requires the readline library")
1294 self.autoindent = 0
1294 self.autoindent = 0
1295 return
1295 return
1296 if value is None:
1296 if value is None:
1297 self.autoindent = not self.autoindent
1297 self.autoindent = not self.autoindent
1298 else:
1298 else:
1299 self.autoindent = value
1299 self.autoindent = value
1300
1300
1301 def rc_set_toggle(self,rc_field,value=None):
1301 def rc_set_toggle(self,rc_field,value=None):
1302 """Set or toggle a field in IPython's rc config. structure.
1302 """Set or toggle a field in IPython's rc config. structure.
1303
1303
1304 If called with no arguments, it acts as a toggle.
1304 If called with no arguments, it acts as a toggle.
1305
1305
1306 If called with a non-existent field, the resulting AttributeError
1306 If called with a non-existent field, the resulting AttributeError
1307 exception will propagate out."""
1307 exception will propagate out."""
1308
1308
1309 rc_val = getattr(self.rc,rc_field)
1309 rc_val = getattr(self.rc,rc_field)
1310 if value is None:
1310 if value is None:
1311 value = not rc_val
1311 value = not rc_val
1312 setattr(self.rc,rc_field,value)
1312 setattr(self.rc,rc_field,value)
1313
1313
1314 def user_setup(self,ipythondir,rc_suffix,mode='install'):
1314 def user_setup(self,ipythondir,rc_suffix,mode='install'):
1315 """Install the user configuration directory.
1315 """Install the user configuration directory.
1316
1316
1317 Note
1317 Note
1318 ----
1318 ----
1319 DEPRECATED: use the top-level user_setup() function instead.
1319 DEPRECATED: use the top-level user_setup() function instead.
1320 """
1320 """
1321 return user_setup(ipythondir,rc_suffix,mode)
1321 return user_setup(ipythondir,rc_suffix,mode)
1322
1322
1323 def atexit_operations(self):
1323 def atexit_operations(self):
1324 """This will be executed at the time of exit.
1324 """This will be executed at the time of exit.
1325
1325
1326 Saving of persistent data should be performed here. """
1326 Saving of persistent data should be performed here. """
1327
1327
1328 #print '*** IPython exit cleanup ***' # dbg
1328 #print '*** IPython exit cleanup ***' # dbg
1329 # input history
1329 # input history
1330 self.savehist()
1330 self.savehist()
1331
1331
1332 # Cleanup all tempfiles left around
1332 # Cleanup all tempfiles left around
1333 for tfile in self.tempfiles:
1333 for tfile in self.tempfiles:
1334 try:
1334 try:
1335 os.unlink(tfile)
1335 os.unlink(tfile)
1336 except OSError:
1336 except OSError:
1337 pass
1337 pass
1338
1338
1339 # Clear all user namespaces to release all references cleanly.
1339 # Clear all user namespaces to release all references cleanly.
1340 self.reset()
1340 self.reset()
1341
1341
1342 # Run user hooks
1342 # Run user hooks
1343 self.hooks.shutdown_hook()
1343 self.hooks.shutdown_hook()
1344
1344
1345 def reset(self):
1345 def reset(self):
1346 """Clear all internal namespaces.
1346 """Clear all internal namespaces.
1347
1347
1348 Note that this is much more aggressive than %reset, since it clears
1348 Note that this is much more aggressive than %reset, since it clears
1349 fully all namespaces, as well as all input/output lists.
1349 fully all namespaces, as well as all input/output lists.
1350 """
1350 """
1351 for ns in self.ns_refs_table:
1351 for ns in self.ns_refs_table:
1352 ns.clear()
1352 ns.clear()
1353
1353
1354 # Clear input and output histories
1354 # Clear input and output histories
1355 self.input_hist[:] = []
1355 self.input_hist[:] = []
1356 self.input_hist_raw[:] = []
1356 self.input_hist_raw[:] = []
1357 self.output_hist.clear()
1357 self.output_hist.clear()
1358 # Restore the user namespaces to minimal usability
1358 # Restore the user namespaces to minimal usability
1359 self.init_namespaces()
1359 self.init_namespaces()
1360
1360
1361 def savehist(self):
1361 def savehist(self):
1362 """Save input history to a file (via readline library)."""
1362 """Save input history to a file (via readline library)."""
1363
1363
1364 if not self.has_readline:
1364 if not self.has_readline:
1365 return
1365 return
1366
1366
1367 try:
1367 try:
1368 self.readline.write_history_file(self.histfile)
1368 self.readline.write_history_file(self.histfile)
1369 except:
1369 except:
1370 print 'Unable to save IPython command history to file: ' + \
1370 print 'Unable to save IPython command history to file: ' + \
1371 `self.histfile`
1371 `self.histfile`
1372
1372
1373 def reloadhist(self):
1373 def reloadhist(self):
1374 """Reload the input history from disk file."""
1374 """Reload the input history from disk file."""
1375
1375
1376 if self.has_readline:
1376 if self.has_readline:
1377 try:
1377 try:
1378 self.readline.clear_history()
1378 self.readline.clear_history()
1379 self.readline.read_history_file(self.shell.histfile)
1379 self.readline.read_history_file(self.shell.histfile)
1380 except AttributeError:
1380 except AttributeError:
1381 pass
1381 pass
1382
1382
1383
1383
1384 def history_saving_wrapper(self, func):
1384 def history_saving_wrapper(self, func):
1385 """ Wrap func for readline history saving
1385 """ Wrap func for readline history saving
1386
1386
1387 Convert func into callable that saves & restores
1387 Convert func into callable that saves & restores
1388 history around the call """
1388 history around the call """
1389
1389
1390 if not self.has_readline:
1390 if not self.has_readline:
1391 return func
1391 return func
1392
1392
1393 def wrapper():
1393 def wrapper():
1394 self.savehist()
1394 self.savehist()
1395 try:
1395 try:
1396 func()
1396 func()
1397 finally:
1397 finally:
1398 readline.read_history_file(self.histfile)
1398 readline.read_history_file(self.histfile)
1399 return wrapper
1399 return wrapper
1400
1400
1401 def pre_readline(self):
1401 def pre_readline(self):
1402 """readline hook to be used at the start of each line.
1402 """readline hook to be used at the start of each line.
1403
1403
1404 Currently it handles auto-indent only."""
1404 Currently it handles auto-indent only."""
1405
1405
1406 #debugx('self.indent_current_nsp','pre_readline:')
1406 #debugx('self.indent_current_nsp','pre_readline:')
1407
1407
1408 if self.rl_do_indent:
1408 if self.rl_do_indent:
1409 self.readline.insert_text(self.indent_current_str())
1409 self.readline.insert_text(self.indent_current_str())
1410 if self.rl_next_input is not None:
1410 if self.rl_next_input is not None:
1411 self.readline.insert_text(self.rl_next_input)
1411 self.readline.insert_text(self.rl_next_input)
1412 self.rl_next_input = None
1412 self.rl_next_input = None
1413
1413
1414 def init_readline(self):
1414 def init_readline(self):
1415 """Command history completion/saving/reloading."""
1415 """Command history completion/saving/reloading."""
1416
1416
1417
1417
1418 import IPython.rlineimpl as readline
1418 import IPython.rlineimpl as readline
1419
1419
1420 if not readline.have_readline:
1420 if not readline.have_readline:
1421 self.has_readline = 0
1421 self.has_readline = 0
1422 self.readline = None
1422 self.readline = None
1423 # no point in bugging windows users with this every time:
1423 # no point in bugging windows users with this every time:
1424 warn('Readline services not available on this platform.')
1424 warn('Readline services not available on this platform.')
1425 else:
1425 else:
1426 sys.modules['readline'] = readline
1426 sys.modules['readline'] = readline
1427 import atexit
1427 import atexit
1428 from IPython.core.completer import IPCompleter
1428 from IPython.core.completer import IPCompleter
1429 self.Completer = IPCompleter(self,
1429 self.Completer = IPCompleter(self,
1430 self.user_ns,
1430 self.user_ns,
1431 self.user_global_ns,
1431 self.user_global_ns,
1432 self.rc.readline_omit__names,
1432 self.rc.readline_omit__names,
1433 self.alias_table)
1433 self.alias_table)
1434 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1434 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1435 self.strdispatchers['complete_command'] = sdisp
1435 self.strdispatchers['complete_command'] = sdisp
1436 self.Completer.custom_completers = sdisp
1436 self.Completer.custom_completers = sdisp
1437 # Platform-specific configuration
1437 # Platform-specific configuration
1438 if os.name == 'nt':
1438 if os.name == 'nt':
1439 self.readline_startup_hook = readline.set_pre_input_hook
1439 self.readline_startup_hook = readline.set_pre_input_hook
1440 else:
1440 else:
1441 self.readline_startup_hook = readline.set_startup_hook
1441 self.readline_startup_hook = readline.set_startup_hook
1442
1442
1443 # Load user's initrc file (readline config)
1443 # Load user's initrc file (readline config)
1444 # Or if libedit is used, load editrc.
1444 # Or if libedit is used, load editrc.
1445 inputrc_name = os.environ.get('INPUTRC')
1445 inputrc_name = os.environ.get('INPUTRC')
1446 if inputrc_name is None:
1446 if inputrc_name is None:
1447 home_dir = get_home_dir()
1447 home_dir = get_home_dir()
1448 if home_dir is not None:
1448 if home_dir is not None:
1449 inputrc_name = '.inputrc'
1449 inputrc_name = '.inputrc'
1450 if readline.uses_libedit:
1450 if readline.uses_libedit:
1451 inputrc_name = '.editrc'
1451 inputrc_name = '.editrc'
1452 inputrc_name = os.path.join(home_dir, inputrc_name)
1452 inputrc_name = os.path.join(home_dir, inputrc_name)
1453 if os.path.isfile(inputrc_name):
1453 if os.path.isfile(inputrc_name):
1454 try:
1454 try:
1455 readline.read_init_file(inputrc_name)
1455 readline.read_init_file(inputrc_name)
1456 except:
1456 except:
1457 warn('Problems reading readline initialization file <%s>'
1457 warn('Problems reading readline initialization file <%s>'
1458 % inputrc_name)
1458 % inputrc_name)
1459
1459
1460 self.has_readline = 1
1460 self.has_readline = 1
1461 self.readline = readline
1461 self.readline = readline
1462 # save this in sys so embedded copies can restore it properly
1462 # save this in sys so embedded copies can restore it properly
1463 sys.ipcompleter = self.Completer.complete
1463 sys.ipcompleter = self.Completer.complete
1464 self.set_completer()
1464 self.set_completer()
1465
1465
1466 # Configure readline according to user's prefs
1466 # Configure readline according to user's prefs
1467 # This is only done if GNU readline is being used. If libedit
1467 # This is only done if GNU readline is being used. If libedit
1468 # is being used (as on Leopard) the readline config is
1468 # is being used (as on Leopard) the readline config is
1469 # not run as the syntax for libedit is different.
1469 # not run as the syntax for libedit is different.
1470 if not readline.uses_libedit:
1470 if not readline.uses_libedit:
1471 for rlcommand in self.rc.readline_parse_and_bind:
1471 for rlcommand in self.rc.readline_parse_and_bind:
1472 #print "loading rl:",rlcommand # dbg
1472 #print "loading rl:",rlcommand # dbg
1473 readline.parse_and_bind(rlcommand)
1473 readline.parse_and_bind(rlcommand)
1474
1474
1475 # Remove some chars from the delimiters list. If we encounter
1475 # Remove some chars from the delimiters list. If we encounter
1476 # unicode chars, discard them.
1476 # unicode chars, discard them.
1477 delims = readline.get_completer_delims().encode("ascii", "ignore")
1477 delims = readline.get_completer_delims().encode("ascii", "ignore")
1478 delims = delims.translate(string._idmap,
1478 delims = delims.translate(string._idmap,
1479 self.rc.readline_remove_delims)
1479 self.rc.readline_remove_delims)
1480 readline.set_completer_delims(delims)
1480 readline.set_completer_delims(delims)
1481 # otherwise we end up with a monster history after a while:
1481 # otherwise we end up with a monster history after a while:
1482 readline.set_history_length(1000)
1482 readline.set_history_length(1000)
1483 try:
1483 try:
1484 #print '*** Reading readline history' # dbg
1484 #print '*** Reading readline history' # dbg
1485 readline.read_history_file(self.histfile)
1485 readline.read_history_file(self.histfile)
1486 except IOError:
1486 except IOError:
1487 pass # It doesn't exist yet.
1487 pass # It doesn't exist yet.
1488
1488
1489 atexit.register(self.atexit_operations)
1489 atexit.register(self.atexit_operations)
1490 del atexit
1490 del atexit
1491
1491
1492 # Configure auto-indent for all platforms
1492 # Configure auto-indent for all platforms
1493 self.set_autoindent(self.rc.autoindent)
1493 self.set_autoindent(self.rc.autoindent)
1494
1494
1495 def ask_yes_no(self,prompt,default=True):
1495 def ask_yes_no(self,prompt,default=True):
1496 if self.rc.quiet:
1496 if self.rc.quiet:
1497 return True
1497 return True
1498 return ask_yes_no(prompt,default)
1498 return ask_yes_no(prompt,default)
1499
1499
1500 def new_main_mod(self,ns=None):
1500 def new_main_mod(self,ns=None):
1501 """Return a new 'main' module object for user code execution.
1501 """Return a new 'main' module object for user code execution.
1502 """
1502 """
1503 main_mod = self._user_main_module
1503 main_mod = self._user_main_module
1504 init_fakemod_dict(main_mod,ns)
1504 init_fakemod_dict(main_mod,ns)
1505 return main_mod
1505 return main_mod
1506
1506
1507 def cache_main_mod(self,ns,fname):
1507 def cache_main_mod(self,ns,fname):
1508 """Cache a main module's namespace.
1508 """Cache a main module's namespace.
1509
1509
1510 When scripts are executed via %run, we must keep a reference to the
1510 When scripts are executed via %run, we must keep a reference to the
1511 namespace of their __main__ module (a FakeModule instance) around so
1511 namespace of their __main__ module (a FakeModule instance) around so
1512 that Python doesn't clear it, rendering objects defined therein
1512 that Python doesn't clear it, rendering objects defined therein
1513 useless.
1513 useless.
1514
1514
1515 This method keeps said reference in a private dict, keyed by the
1515 This method keeps said reference in a private dict, keyed by the
1516 absolute path of the module object (which corresponds to the script
1516 absolute path of the module object (which corresponds to the script
1517 path). This way, for multiple executions of the same script we only
1517 path). This way, for multiple executions of the same script we only
1518 keep one copy of the namespace (the last one), thus preventing memory
1518 keep one copy of the namespace (the last one), thus preventing memory
1519 leaks from old references while allowing the objects from the last
1519 leaks from old references while allowing the objects from the last
1520 execution to be accessible.
1520 execution to be accessible.
1521
1521
1522 Note: we can not allow the actual FakeModule instances to be deleted,
1522 Note: we can not allow the actual FakeModule instances to be deleted,
1523 because of how Python tears down modules (it hard-sets all their
1523 because of how Python tears down modules (it hard-sets all their
1524 references to None without regard for reference counts). This method
1524 references to None without regard for reference counts). This method
1525 must therefore make a *copy* of the given namespace, to allow the
1525 must therefore make a *copy* of the given namespace, to allow the
1526 original module's __dict__ to be cleared and reused.
1526 original module's __dict__ to be cleared and reused.
1527
1527
1528
1528
1529 Parameters
1529 Parameters
1530 ----------
1530 ----------
1531 ns : a namespace (a dict, typically)
1531 ns : a namespace (a dict, typically)
1532
1532
1533 fname : str
1533 fname : str
1534 Filename associated with the namespace.
1534 Filename associated with the namespace.
1535
1535
1536 Examples
1536 Examples
1537 --------
1537 --------
1538
1538
1539 In [10]: import IPython
1539 In [10]: import IPython
1540
1540
1541 In [11]: _ip.IP.cache_main_mod(IPython.__dict__,IPython.__file__)
1541 In [11]: _ip.IP.cache_main_mod(IPython.__dict__,IPython.__file__)
1542
1542
1543 In [12]: IPython.__file__ in _ip.IP._main_ns_cache
1543 In [12]: IPython.__file__ in _ip.IP._main_ns_cache
1544 Out[12]: True
1544 Out[12]: True
1545 """
1545 """
1546 self._main_ns_cache[os.path.abspath(fname)] = ns.copy()
1546 self._main_ns_cache[os.path.abspath(fname)] = ns.copy()
1547
1547
1548 def clear_main_mod_cache(self):
1548 def clear_main_mod_cache(self):
1549 """Clear the cache of main modules.
1549 """Clear the cache of main modules.
1550
1550
1551 Mainly for use by utilities like %reset.
1551 Mainly for use by utilities like %reset.
1552
1552
1553 Examples
1553 Examples
1554 --------
1554 --------
1555
1555
1556 In [15]: import IPython
1556 In [15]: import IPython
1557
1557
1558 In [16]: _ip.IP.cache_main_mod(IPython.__dict__,IPython.__file__)
1558 In [16]: _ip.IP.cache_main_mod(IPython.__dict__,IPython.__file__)
1559
1559
1560 In [17]: len(_ip.IP._main_ns_cache) > 0
1560 In [17]: len(_ip.IP._main_ns_cache) > 0
1561 Out[17]: True
1561 Out[17]: True
1562
1562
1563 In [18]: _ip.IP.clear_main_mod_cache()
1563 In [18]: _ip.IP.clear_main_mod_cache()
1564
1564
1565 In [19]: len(_ip.IP._main_ns_cache) == 0
1565 In [19]: len(_ip.IP._main_ns_cache) == 0
1566 Out[19]: True
1566 Out[19]: True
1567 """
1567 """
1568 self._main_ns_cache.clear()
1568 self._main_ns_cache.clear()
1569
1569
1570 def _should_recompile(self,e):
1570 def _should_recompile(self,e):
1571 """Utility routine for edit_syntax_error"""
1571 """Utility routine for edit_syntax_error"""
1572
1572
1573 if e.filename in ('<ipython console>','<input>','<string>',
1573 if e.filename in ('<ipython console>','<input>','<string>',
1574 '<console>','<BackgroundJob compilation>',
1574 '<console>','<BackgroundJob compilation>',
1575 None):
1575 None):
1576
1576
1577 return False
1577 return False
1578 try:
1578 try:
1579 if (self.rc.autoedit_syntax and
1579 if (self.rc.autoedit_syntax and
1580 not self.ask_yes_no('Return to editor to correct syntax error? '
1580 not self.ask_yes_no('Return to editor to correct syntax error? '
1581 '[Y/n] ','y')):
1581 '[Y/n] ','y')):
1582 return False
1582 return False
1583 except EOFError:
1583 except EOFError:
1584 return False
1584 return False
1585
1585
1586 def int0(x):
1586 def int0(x):
1587 try:
1587 try:
1588 return int(x)
1588 return int(x)
1589 except TypeError:
1589 except TypeError:
1590 return 0
1590 return 0
1591 # always pass integer line and offset values to editor hook
1591 # always pass integer line and offset values to editor hook
1592 try:
1592 try:
1593 self.hooks.fix_error_editor(e.filename,
1593 self.hooks.fix_error_editor(e.filename,
1594 int0(e.lineno),int0(e.offset),e.msg)
1594 int0(e.lineno),int0(e.offset),e.msg)
1595 except ipapi.TryNext:
1595 except ipapi.TryNext:
1596 warn('Could not open editor')
1596 warn('Could not open editor')
1597 return False
1597 return False
1598 return True
1598 return True
1599
1599
1600 def edit_syntax_error(self):
1600 def edit_syntax_error(self):
1601 """The bottom half of the syntax error handler called in the main loop.
1601 """The bottom half of the syntax error handler called in the main loop.
1602
1602
1603 Loop until syntax error is fixed or user cancels.
1603 Loop until syntax error is fixed or user cancels.
1604 """
1604 """
1605
1605
1606 while self.SyntaxTB.last_syntax_error:
1606 while self.SyntaxTB.last_syntax_error:
1607 # copy and clear last_syntax_error
1607 # copy and clear last_syntax_error
1608 err = self.SyntaxTB.clear_err_state()
1608 err = self.SyntaxTB.clear_err_state()
1609 if not self._should_recompile(err):
1609 if not self._should_recompile(err):
1610 return
1610 return
1611 try:
1611 try:
1612 # may set last_syntax_error again if a SyntaxError is raised
1612 # may set last_syntax_error again if a SyntaxError is raised
1613 self.safe_execfile(err.filename,self.user_ns)
1613 self.safe_execfile(err.filename,self.user_ns)
1614 except:
1614 except:
1615 self.showtraceback()
1615 self.showtraceback()
1616 else:
1616 else:
1617 try:
1617 try:
1618 f = file(err.filename)
1618 f = file(err.filename)
1619 try:
1619 try:
1620 sys.displayhook(f.read())
1620 sys.displayhook(f.read())
1621 finally:
1621 finally:
1622 f.close()
1622 f.close()
1623 except:
1623 except:
1624 self.showtraceback()
1624 self.showtraceback()
1625
1625
1626 def showsyntaxerror(self, filename=None):
1626 def showsyntaxerror(self, filename=None):
1627 """Display the syntax error that just occurred.
1627 """Display the syntax error that just occurred.
1628
1628
1629 This doesn't display a stack trace because there isn't one.
1629 This doesn't display a stack trace because there isn't one.
1630
1630
1631 If a filename is given, it is stuffed in the exception instead
1631 If a filename is given, it is stuffed in the exception instead
1632 of what was there before (because Python's parser always uses
1632 of what was there before (because Python's parser always uses
1633 "<string>" when reading from a string).
1633 "<string>" when reading from a string).
1634 """
1634 """
1635 etype, value, last_traceback = sys.exc_info()
1635 etype, value, last_traceback = sys.exc_info()
1636
1636
1637 # See note about these variables in showtraceback() below
1637 # See note about these variables in showtraceback() below
1638 sys.last_type = etype
1638 sys.last_type = etype
1639 sys.last_value = value
1639 sys.last_value = value
1640 sys.last_traceback = last_traceback
1640 sys.last_traceback = last_traceback
1641
1641
1642 if filename and etype is SyntaxError:
1642 if filename and etype is SyntaxError:
1643 # Work hard to stuff the correct filename in the exception
1643 # Work hard to stuff the correct filename in the exception
1644 try:
1644 try:
1645 msg, (dummy_filename, lineno, offset, line) = value
1645 msg, (dummy_filename, lineno, offset, line) = value
1646 except:
1646 except:
1647 # Not the format we expect; leave it alone
1647 # Not the format we expect; leave it alone
1648 pass
1648 pass
1649 else:
1649 else:
1650 # Stuff in the right filename
1650 # Stuff in the right filename
1651 try:
1651 try:
1652 # Assume SyntaxError is a class exception
1652 # Assume SyntaxError is a class exception
1653 value = SyntaxError(msg, (filename, lineno, offset, line))
1653 value = SyntaxError(msg, (filename, lineno, offset, line))
1654 except:
1654 except:
1655 # If that failed, assume SyntaxError is a string
1655 # If that failed, assume SyntaxError is a string
1656 value = msg, (filename, lineno, offset, line)
1656 value = msg, (filename, lineno, offset, line)
1657 self.SyntaxTB(etype,value,[])
1657 self.SyntaxTB(etype,value,[])
1658
1658
1659 def debugger(self,force=False):
1659 def debugger(self,force=False):
1660 """Call the pydb/pdb debugger.
1660 """Call the pydb/pdb debugger.
1661
1661
1662 Keywords:
1662 Keywords:
1663
1663
1664 - force(False): by default, this routine checks the instance call_pdb
1664 - force(False): by default, this routine checks the instance call_pdb
1665 flag and does not actually invoke the debugger if the flag is false.
1665 flag and does not actually invoke the debugger if the flag is false.
1666 The 'force' option forces the debugger to activate even if the flag
1666 The 'force' option forces the debugger to activate even if the flag
1667 is false.
1667 is false.
1668 """
1668 """
1669
1669
1670 if not (force or self.call_pdb):
1670 if not (force or self.call_pdb):
1671 return
1671 return
1672
1672
1673 if not hasattr(sys,'last_traceback'):
1673 if not hasattr(sys,'last_traceback'):
1674 error('No traceback has been produced, nothing to debug.')
1674 error('No traceback has been produced, nothing to debug.')
1675 return
1675 return
1676
1676
1677 # use pydb if available
1677 # use pydb if available
1678 if debugger.has_pydb:
1678 if debugger.has_pydb:
1679 from pydb import pm
1679 from pydb import pm
1680 else:
1680 else:
1681 # fallback to our internal debugger
1681 # fallback to our internal debugger
1682 pm = lambda : self.InteractiveTB.debugger(force=True)
1682 pm = lambda : self.InteractiveTB.debugger(force=True)
1683 self.history_saving_wrapper(pm)()
1683 self.history_saving_wrapper(pm)()
1684
1684
1685 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None):
1685 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None):
1686 """Display the exception that just occurred.
1686 """Display the exception that just occurred.
1687
1687
1688 If nothing is known about the exception, this is the method which
1688 If nothing is known about the exception, this is the method which
1689 should be used throughout the code for presenting user tracebacks,
1689 should be used throughout the code for presenting user tracebacks,
1690 rather than directly invoking the InteractiveTB object.
1690 rather than directly invoking the InteractiveTB object.
1691
1691
1692 A specific showsyntaxerror() also exists, but this method can take
1692 A specific showsyntaxerror() also exists, but this method can take
1693 care of calling it if needed, so unless you are explicitly catching a
1693 care of calling it if needed, so unless you are explicitly catching a
1694 SyntaxError exception, don't try to analyze the stack manually and
1694 SyntaxError exception, don't try to analyze the stack manually and
1695 simply call this method."""
1695 simply call this method."""
1696
1696
1697
1697
1698 # Though this won't be called by syntax errors in the input line,
1698 # Though this won't be called by syntax errors in the input line,
1699 # there may be SyntaxError cases whith imported code.
1699 # there may be SyntaxError cases whith imported code.
1700
1700
1701 try:
1701 try:
1702 if exc_tuple is None:
1702 if exc_tuple is None:
1703 etype, value, tb = sys.exc_info()
1703 etype, value, tb = sys.exc_info()
1704 else:
1704 else:
1705 etype, value, tb = exc_tuple
1705 etype, value, tb = exc_tuple
1706
1706
1707 if etype is SyntaxError:
1707 if etype is SyntaxError:
1708 self.showsyntaxerror(filename)
1708 self.showsyntaxerror(filename)
1709 elif etype is ipapi.UsageError:
1709 elif etype is ipapi.UsageError:
1710 print "UsageError:", value
1710 print "UsageError:", value
1711 else:
1711 else:
1712 # WARNING: these variables are somewhat deprecated and not
1712 # WARNING: these variables are somewhat deprecated and not
1713 # necessarily safe to use in a threaded environment, but tools
1713 # necessarily safe to use in a threaded environment, but tools
1714 # like pdb depend on their existence, so let's set them. If we
1714 # like pdb depend on their existence, so let's set them. If we
1715 # find problems in the field, we'll need to revisit their use.
1715 # find problems in the field, we'll need to revisit their use.
1716 sys.last_type = etype
1716 sys.last_type = etype
1717 sys.last_value = value
1717 sys.last_value = value
1718 sys.last_traceback = tb
1718 sys.last_traceback = tb
1719
1719
1720 if etype in self.custom_exceptions:
1720 if etype in self.custom_exceptions:
1721 self.CustomTB(etype,value,tb)
1721 self.CustomTB(etype,value,tb)
1722 else:
1722 else:
1723 self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)
1723 self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)
1724 if self.InteractiveTB.call_pdb and self.has_readline:
1724 if self.InteractiveTB.call_pdb and self.has_readline:
1725 # pdb mucks up readline, fix it back
1725 # pdb mucks up readline, fix it back
1726 self.set_completer()
1726 self.set_completer()
1727 except KeyboardInterrupt:
1727 except KeyboardInterrupt:
1728 self.write("\nKeyboardInterrupt\n")
1728 self.write("\nKeyboardInterrupt\n")
1729
1729
1730 def mainloop(self,banner=None):
1730 def mainloop(self,banner=None):
1731 """Creates the local namespace and starts the mainloop.
1731 """Creates the local namespace and starts the mainloop.
1732
1732
1733 If an optional banner argument is given, it will override the
1733 If an optional banner argument is given, it will override the
1734 internally created default banner."""
1734 internally created default banner."""
1735
1735
1736 if self.rc.c: # Emulate Python's -c option
1736 if self.rc.c: # Emulate Python's -c option
1737 self.exec_init_cmd()
1737 self.exec_init_cmd()
1738 if banner is None:
1738 if banner is None:
1739 if not self.rc.banner:
1739 if not self.rc.banner:
1740 banner = ''
1740 banner = ''
1741 # banner is string? Use it directly!
1741 # banner is string? Use it directly!
1742 elif isinstance(self.rc.banner,basestring):
1742 elif isinstance(self.rc.banner,basestring):
1743 banner = self.rc.banner
1743 banner = self.rc.banner
1744 else:
1744 else:
1745 banner = self.BANNER+self.banner2
1745 banner = self.BANNER+self.banner2
1746
1746
1747 # if you run stuff with -c <cmd>, raw hist is not updated
1747 # if you run stuff with -c <cmd>, raw hist is not updated
1748 # ensure that it's in sync
1748 # ensure that it's in sync
1749 if len(self.input_hist) != len (self.input_hist_raw):
1749 if len(self.input_hist) != len (self.input_hist_raw):
1750 self.input_hist_raw = InputList(self.input_hist)
1750 self.input_hist_raw = InputList(self.input_hist)
1751
1751
1752 while 1:
1752 while 1:
1753 try:
1753 try:
1754 self.interact(banner)
1754 self.interact(banner)
1755 #self.interact_with_readline()
1755 #self.interact_with_readline()
1756
1756
1757 # XXX for testing of a readline-decoupled repl loop, call
1757 # XXX for testing of a readline-decoupled repl loop, call
1758 # interact_with_readline above
1758 # interact_with_readline above
1759
1759
1760 break
1760 break
1761 except KeyboardInterrupt:
1761 except KeyboardInterrupt:
1762 # this should not be necessary, but KeyboardInterrupt
1762 # this should not be necessary, but KeyboardInterrupt
1763 # handling seems rather unpredictable...
1763 # handling seems rather unpredictable...
1764 self.write("\nKeyboardInterrupt in interact()\n")
1764 self.write("\nKeyboardInterrupt in interact()\n")
1765
1765
1766 def exec_init_cmd(self):
1766 def exec_init_cmd(self):
1767 """Execute a command given at the command line.
1767 """Execute a command given at the command line.
1768
1768
1769 This emulates Python's -c option."""
1769 This emulates Python's -c option."""
1770
1770
1771 #sys.argv = ['-c']
1771 #sys.argv = ['-c']
1772 self.push(self.prefilter(self.rc.c, False))
1772 self.push(self.prefilter(self.rc.c, False))
1773 if not self.rc.interact:
1773 if not self.rc.interact:
1774 self.ask_exit()
1774 self.ask_exit()
1775
1775
1776 def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):
1776 def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):
1777 """Embeds IPython into a running python program.
1777 """Embeds IPython into a running python program.
1778
1778
1779 Input:
1779 Input:
1780
1780
1781 - header: An optional header message can be specified.
1781 - header: An optional header message can be specified.
1782
1782
1783 - local_ns, global_ns: working namespaces. If given as None, the
1783 - local_ns, global_ns: working namespaces. If given as None, the
1784 IPython-initialized one is updated with __main__.__dict__, so that
1784 IPython-initialized one is updated with __main__.__dict__, so that
1785 program variables become visible but user-specific configuration
1785 program variables become visible but user-specific configuration
1786 remains possible.
1786 remains possible.
1787
1787
1788 - stack_depth: specifies how many levels in the stack to go to
1788 - stack_depth: specifies how many levels in the stack to go to
1789 looking for namespaces (when local_ns and global_ns are None). This
1789 looking for namespaces (when local_ns and global_ns are None). This
1790 allows an intermediate caller to make sure that this function gets
1790 allows an intermediate caller to make sure that this function gets
1791 the namespace from the intended level in the stack. By default (0)
1791 the namespace from the intended level in the stack. By default (0)
1792 it will get its locals and globals from the immediate caller.
1792 it will get its locals and globals from the immediate caller.
1793
1793
1794 Warning: it's possible to use this in a program which is being run by
1794 Warning: it's possible to use this in a program which is being run by
1795 IPython itself (via %run), but some funny things will happen (a few
1795 IPython itself (via %run), but some funny things will happen (a few
1796 globals get overwritten). In the future this will be cleaned up, as
1796 globals get overwritten). In the future this will be cleaned up, as
1797 there is no fundamental reason why it can't work perfectly."""
1797 there is no fundamental reason why it can't work perfectly."""
1798
1798
1799 # Get locals and globals from caller
1799 # Get locals and globals from caller
1800 if local_ns is None or global_ns is None:
1800 if local_ns is None or global_ns is None:
1801 call_frame = sys._getframe(stack_depth).f_back
1801 call_frame = sys._getframe(stack_depth).f_back
1802
1802
1803 if local_ns is None:
1803 if local_ns is None:
1804 local_ns = call_frame.f_locals
1804 local_ns = call_frame.f_locals
1805 if global_ns is None:
1805 if global_ns is None:
1806 global_ns = call_frame.f_globals
1806 global_ns = call_frame.f_globals
1807
1807
1808 # Update namespaces and fire up interpreter
1808 # Update namespaces and fire up interpreter
1809
1809
1810 # The global one is easy, we can just throw it in
1810 # The global one is easy, we can just throw it in
1811 self.user_global_ns = global_ns
1811 self.user_global_ns = global_ns
1812
1812
1813 # but the user/local one is tricky: ipython needs it to store internal
1813 # but the user/local one is tricky: ipython needs it to store internal
1814 # data, but we also need the locals. We'll copy locals in the user
1814 # data, but we also need the locals. We'll copy locals in the user
1815 # one, but will track what got copied so we can delete them at exit.
1815 # one, but will track what got copied so we can delete them at exit.
1816 # This is so that a later embedded call doesn't see locals from a
1816 # This is so that a later embedded call doesn't see locals from a
1817 # previous call (which most likely existed in a separate scope).
1817 # previous call (which most likely existed in a separate scope).
1818 local_varnames = local_ns.keys()
1818 local_varnames = local_ns.keys()
1819 self.user_ns.update(local_ns)
1819 self.user_ns.update(local_ns)
1820 #self.user_ns['local_ns'] = local_ns # dbg
1820 #self.user_ns['local_ns'] = local_ns # dbg
1821
1821
1822 # Patch for global embedding to make sure that things don't overwrite
1822 # Patch for global embedding to make sure that things don't overwrite
1823 # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
1823 # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
1824 # FIXME. Test this a bit more carefully (the if.. is new)
1824 # FIXME. Test this a bit more carefully (the if.. is new)
1825 if local_ns is None and global_ns is None:
1825 if local_ns is None and global_ns is None:
1826 self.user_global_ns.update(__main__.__dict__)
1826 self.user_global_ns.update(__main__.__dict__)
1827
1827
1828 # make sure the tab-completer has the correct frame information, so it
1828 # make sure the tab-completer has the correct frame information, so it
1829 # actually completes using the frame's locals/globals
1829 # actually completes using the frame's locals/globals
1830 self.set_completer_frame()
1830 self.set_completer_frame()
1831
1831
1832 # before activating the interactive mode, we need to make sure that
1832 # before activating the interactive mode, we need to make sure that
1833 # all names in the builtin namespace needed by ipython point to
1833 # all names in the builtin namespace needed by ipython point to
1834 # ourselves, and not to other instances.
1834 # ourselves, and not to other instances.
1835 self.add_builtins()
1835 self.add_builtins()
1836
1836
1837 self.interact(header)
1837 self.interact(header)
1838
1838
1839 # now, purge out the user namespace from anything we might have added
1839 # now, purge out the user namespace from anything we might have added
1840 # from the caller's local namespace
1840 # from the caller's local namespace
1841 delvar = self.user_ns.pop
1841 delvar = self.user_ns.pop
1842 for var in local_varnames:
1842 for var in local_varnames:
1843 delvar(var,None)
1843 delvar(var,None)
1844 # and clean builtins we may have overridden
1844 # and clean builtins we may have overridden
1845 self.clean_builtins()
1845 self.clean_builtins()
1846
1846
1847 def interact_prompt(self):
1847 def interact_prompt(self):
1848 """ Print the prompt (in read-eval-print loop)
1848 """ Print the prompt (in read-eval-print loop)
1849
1849
1850 Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not
1850 Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not
1851 used in standard IPython flow.
1851 used in standard IPython flow.
1852 """
1852 """
1853 if self.more:
1853 if self.more:
1854 try:
1854 try:
1855 prompt = self.hooks.generate_prompt(True)
1855 prompt = self.hooks.generate_prompt(True)
1856 except:
1856 except:
1857 self.showtraceback()
1857 self.showtraceback()
1858 if self.autoindent:
1858 if self.autoindent:
1859 self.rl_do_indent = True
1859 self.rl_do_indent = True
1860
1860
1861 else:
1861 else:
1862 try:
1862 try:
1863 prompt = self.hooks.generate_prompt(False)
1863 prompt = self.hooks.generate_prompt(False)
1864 except:
1864 except:
1865 self.showtraceback()
1865 self.showtraceback()
1866 self.write(prompt)
1866 self.write(prompt)
1867
1867
1868 def interact_handle_input(self,line):
1868 def interact_handle_input(self,line):
1869 """ Handle the input line (in read-eval-print loop)
1869 """ Handle the input line (in read-eval-print loop)
1870
1870
1871 Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not
1871 Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not
1872 used in standard IPython flow.
1872 used in standard IPython flow.
1873 """
1873 """
1874 if line.lstrip() == line:
1874 if line.lstrip() == line:
1875 self.shadowhist.add(line.strip())
1875 self.shadowhist.add(line.strip())
1876 lineout = self.prefilter(line,self.more)
1876 lineout = self.prefilter(line,self.more)
1877
1877
1878 if line.strip():
1878 if line.strip():
1879 if self.more:
1879 if self.more:
1880 self.input_hist_raw[-1] += '%s\n' % line
1880 self.input_hist_raw[-1] += '%s\n' % line
1881 else:
1881 else:
1882 self.input_hist_raw.append('%s\n' % line)
1882 self.input_hist_raw.append('%s\n' % line)
1883
1883
1884
1884
1885 self.more = self.push(lineout)
1885 self.more = self.push(lineout)
1886 if (self.SyntaxTB.last_syntax_error and
1886 if (self.SyntaxTB.last_syntax_error and
1887 self.rc.autoedit_syntax):
1887 self.rc.autoedit_syntax):
1888 self.edit_syntax_error()
1888 self.edit_syntax_error()
1889
1889
1890 def interact_with_readline(self):
1890 def interact_with_readline(self):
1891 """ Demo of using interact_handle_input, interact_prompt
1891 """ Demo of using interact_handle_input, interact_prompt
1892
1892
1893 This is the main read-eval-print loop. If you need to implement your own (e.g. for GUI),
1893 This is the main read-eval-print loop. If you need to implement your own (e.g. for GUI),
1894 it should work like this.
1894 it should work like this.
1895 """
1895 """
1896 self.readline_startup_hook(self.pre_readline)
1896 self.readline_startup_hook(self.pre_readline)
1897 while not self.exit_now:
1897 while not self.exit_now:
1898 self.interact_prompt()
1898 self.interact_prompt()
1899 if self.more:
1899 if self.more:
1900 self.rl_do_indent = True
1900 self.rl_do_indent = True
1901 else:
1901 else:
1902 self.rl_do_indent = False
1902 self.rl_do_indent = False
1903 line = raw_input_original().decode(self.stdin_encoding)
1903 line = raw_input_original().decode(self.stdin_encoding)
1904 self.interact_handle_input(line)
1904 self.interact_handle_input(line)
1905
1905
1906
1906
1907 def interact(self, banner=None):
1907 def interact(self, banner=None):
1908 """Closely emulate the interactive Python console.
1908 """Closely emulate the interactive Python console.
1909
1909
1910 The optional banner argument specify the banner to print
1910 The optional banner argument specify the banner to print
1911 before the first interaction; by default it prints a banner
1911 before the first interaction; by default it prints a banner
1912 similar to the one printed by the real Python interpreter,
1912 similar to the one printed by the real Python interpreter,
1913 followed by the current class name in parentheses (so as not
1913 followed by the current class name in parentheses (so as not
1914 to confuse this with the real interpreter -- since it's so
1914 to confuse this with the real interpreter -- since it's so
1915 close!).
1915 close!).
1916
1916
1917 """
1917 """
1918
1918
1919 if self.exit_now:
1919 if self.exit_now:
1920 # batch run -> do not interact
1920 # batch run -> do not interact
1921 return
1921 return
1922 cprt = 'Type "copyright", "credits" or "license" for more information.'
1922 cprt = 'Type "copyright", "credits" or "license" for more information.'
1923 if banner is None:
1923 if banner is None:
1924 self.write("Python %s on %s\n%s\n(%s)\n" %
1924 self.write("Python %s on %s\n%s\n(%s)\n" %
1925 (sys.version, sys.platform, cprt,
1925 (sys.version, sys.platform, cprt,
1926 self.__class__.__name__))
1926 self.__class__.__name__))
1927 else:
1927 else:
1928 self.write(banner)
1928 self.write(banner)
1929
1929
1930 more = 0
1930 more = 0
1931
1931
1932 # Mark activity in the builtins
1932 # Mark activity in the builtins
1933 __builtin__.__dict__['__IPYTHON__active'] += 1
1933 __builtin__.__dict__['__IPYTHON__active'] += 1
1934
1934
1935 if self.has_readline:
1935 if self.has_readline:
1936 self.readline_startup_hook(self.pre_readline)
1936 self.readline_startup_hook(self.pre_readline)
1937 # exit_now is set by a call to %Exit or %Quit, through the
1937 # exit_now is set by a call to %Exit or %Quit, through the
1938 # ask_exit callback.
1938 # ask_exit callback.
1939
1939
1940 while not self.exit_now:
1940 while not self.exit_now:
1941 self.hooks.pre_prompt_hook()
1941 self.hooks.pre_prompt_hook()
1942 if more:
1942 if more:
1943 try:
1943 try:
1944 prompt = self.hooks.generate_prompt(True)
1944 prompt = self.hooks.generate_prompt(True)
1945 except:
1945 except:
1946 self.showtraceback()
1946 self.showtraceback()
1947 if self.autoindent:
1947 if self.autoindent:
1948 self.rl_do_indent = True
1948 self.rl_do_indent = True
1949
1949
1950 else:
1950 else:
1951 try:
1951 try:
1952 prompt = self.hooks.generate_prompt(False)
1952 prompt = self.hooks.generate_prompt(False)
1953 except:
1953 except:
1954 self.showtraceback()
1954 self.showtraceback()
1955 try:
1955 try:
1956 line = self.raw_input(prompt,more)
1956 line = self.raw_input(prompt,more)
1957 if self.exit_now:
1957 if self.exit_now:
1958 # quick exit on sys.std[in|out] close
1958 # quick exit on sys.std[in|out] close
1959 break
1959 break
1960 if self.autoindent:
1960 if self.autoindent:
1961 self.rl_do_indent = False
1961 self.rl_do_indent = False
1962
1962
1963 except KeyboardInterrupt:
1963 except KeyboardInterrupt:
1964 #double-guard against keyboardinterrupts during kbdint handling
1964 #double-guard against keyboardinterrupts during kbdint handling
1965 try:
1965 try:
1966 self.write('\nKeyboardInterrupt\n')
1966 self.write('\nKeyboardInterrupt\n')
1967 self.resetbuffer()
1967 self.resetbuffer()
1968 # keep cache in sync with the prompt counter:
1968 # keep cache in sync with the prompt counter:
1969 self.outputcache.prompt_count -= 1
1969 self.outputcache.prompt_count -= 1
1970
1970
1971 if self.autoindent:
1971 if self.autoindent:
1972 self.indent_current_nsp = 0
1972 self.indent_current_nsp = 0
1973 more = 0
1973 more = 0
1974 except KeyboardInterrupt:
1974 except KeyboardInterrupt:
1975 pass
1975 pass
1976 except EOFError:
1976 except EOFError:
1977 if self.autoindent:
1977 if self.autoindent:
1978 self.rl_do_indent = False
1978 self.rl_do_indent = False
1979 self.readline_startup_hook(None)
1979 self.readline_startup_hook(None)
1980 self.write('\n')
1980 self.write('\n')
1981 self.exit()
1981 self.exit()
1982 except bdb.BdbQuit:
1982 except bdb.BdbQuit:
1983 warn('The Python debugger has exited with a BdbQuit exception.\n'
1983 warn('The Python debugger has exited with a BdbQuit exception.\n'
1984 'Because of how pdb handles the stack, it is impossible\n'
1984 'Because of how pdb handles the stack, it is impossible\n'
1985 'for IPython to properly format this particular exception.\n'
1985 'for IPython to properly format this particular exception.\n'
1986 'IPython will resume normal operation.')
1986 'IPython will resume normal operation.')
1987 except:
1987 except:
1988 # exceptions here are VERY RARE, but they can be triggered
1988 # exceptions here are VERY RARE, but they can be triggered
1989 # asynchronously by signal handlers, for example.
1989 # asynchronously by signal handlers, for example.
1990 self.showtraceback()
1990 self.showtraceback()
1991 else:
1991 else:
1992 more = self.push(line)
1992 more = self.push(line)
1993 if (self.SyntaxTB.last_syntax_error and
1993 if (self.SyntaxTB.last_syntax_error and
1994 self.rc.autoedit_syntax):
1994 self.rc.autoedit_syntax):
1995 self.edit_syntax_error()
1995 self.edit_syntax_error()
1996
1996
1997 # We are off again...
1997 # We are off again...
1998 __builtin__.__dict__['__IPYTHON__active'] -= 1
1998 __builtin__.__dict__['__IPYTHON__active'] -= 1
1999
1999
2000 def excepthook(self, etype, value, tb):
2000 def excepthook(self, etype, value, tb):
2001 """One more defense for GUI apps that call sys.excepthook.
2001 """One more defense for GUI apps that call sys.excepthook.
2002
2002
2003 GUI frameworks like wxPython trap exceptions and call
2003 GUI frameworks like wxPython trap exceptions and call
2004 sys.excepthook themselves. I guess this is a feature that
2004 sys.excepthook themselves. I guess this is a feature that
2005 enables them to keep running after exceptions that would
2005 enables them to keep running after exceptions that would
2006 otherwise kill their mainloop. This is a bother for IPython
2006 otherwise kill their mainloop. This is a bother for IPython
2007 which excepts to catch all of the program exceptions with a try:
2007 which excepts to catch all of the program exceptions with a try:
2008 except: statement.
2008 except: statement.
2009
2009
2010 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
2010 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
2011 any app directly invokes sys.excepthook, it will look to the user like
2011 any app directly invokes sys.excepthook, it will look to the user like
2012 IPython crashed. In order to work around this, we can disable the
2012 IPython crashed. In order to work around this, we can disable the
2013 CrashHandler and replace it with this excepthook instead, which prints a
2013 CrashHandler and replace it with this excepthook instead, which prints a
2014 regular traceback using our InteractiveTB. In this fashion, apps which
2014 regular traceback using our InteractiveTB. In this fashion, apps which
2015 call sys.excepthook will generate a regular-looking exception from
2015 call sys.excepthook will generate a regular-looking exception from
2016 IPython, and the CrashHandler will only be triggered by real IPython
2016 IPython, and the CrashHandler will only be triggered by real IPython
2017 crashes.
2017 crashes.
2018
2018
2019 This hook should be used sparingly, only in places which are not likely
2019 This hook should be used sparingly, only in places which are not likely
2020 to be true IPython errors.
2020 to be true IPython errors.
2021 """
2021 """
2022 self.showtraceback((etype,value,tb),tb_offset=0)
2022 self.showtraceback((etype,value,tb),tb_offset=0)
2023
2023
2024 def expand_aliases(self,fn,rest):
2024 def expand_aliases(self,fn,rest):
2025 """ Expand multiple levels of aliases:
2025 """ Expand multiple levels of aliases:
2026
2026
2027 if:
2027 if:
2028
2028
2029 alias foo bar /tmp
2029 alias foo bar /tmp
2030 alias baz foo
2030 alias baz foo
2031
2031
2032 then:
2032 then:
2033
2033
2034 baz huhhahhei -> bar /tmp huhhahhei
2034 baz huhhahhei -> bar /tmp huhhahhei
2035
2035
2036 """
2036 """
2037 line = fn + " " + rest
2037 line = fn + " " + rest
2038
2038
2039 done = set()
2039 done = set()
2040 while 1:
2040 while 1:
2041 pre,fn,rest = prefilter.splitUserInput(line,
2041 pre,fn,rest = prefilter.splitUserInput(line,
2042 prefilter.shell_line_split)
2042 prefilter.shell_line_split)
2043 if fn in self.alias_table:
2043 if fn in self.alias_table:
2044 if fn in done:
2044 if fn in done:
2045 warn("Cyclic alias definition, repeated '%s'" % fn)
2045 warn("Cyclic alias definition, repeated '%s'" % fn)
2046 return ""
2046 return ""
2047 done.add(fn)
2047 done.add(fn)
2048
2048
2049 l2 = self.transform_alias(fn,rest)
2049 l2 = self.transform_alias(fn,rest)
2050 # dir -> dir
2050 # dir -> dir
2051 # print "alias",line, "->",l2 #dbg
2051 # print "alias",line, "->",l2 #dbg
2052 if l2 == line:
2052 if l2 == line:
2053 break
2053 break
2054 # ls -> ls -F should not recurse forever
2054 # ls -> ls -F should not recurse forever
2055 if l2.split(None,1)[0] == line.split(None,1)[0]:
2055 if l2.split(None,1)[0] == line.split(None,1)[0]:
2056 line = l2
2056 line = l2
2057 break
2057 break
2058
2058
2059 line=l2
2059 line=l2
2060
2060
2061
2061
2062 # print "al expand to",line #dbg
2062 # print "al expand to",line #dbg
2063 else:
2063 else:
2064 break
2064 break
2065
2065
2066 return line
2066 return line
2067
2067
2068 def transform_alias(self, alias,rest=''):
2068 def transform_alias(self, alias,rest=''):
2069 """ Transform alias to system command string.
2069 """ Transform alias to system command string.
2070 """
2070 """
2071 trg = self.alias_table[alias]
2071 trg = self.alias_table[alias]
2072
2072
2073 nargs,cmd = trg
2073 nargs,cmd = trg
2074 # print trg #dbg
2074 # print trg #dbg
2075 if ' ' in cmd and os.path.isfile(cmd):
2075 if ' ' in cmd and os.path.isfile(cmd):
2076 cmd = '"%s"' % cmd
2076 cmd = '"%s"' % cmd
2077
2077
2078 # Expand the %l special to be the user's input line
2078 # Expand the %l special to be the user's input line
2079 if cmd.find('%l') >= 0:
2079 if cmd.find('%l') >= 0:
2080 cmd = cmd.replace('%l',rest)
2080 cmd = cmd.replace('%l',rest)
2081 rest = ''
2081 rest = ''
2082 if nargs==0:
2082 if nargs==0:
2083 # Simple, argument-less aliases
2083 # Simple, argument-less aliases
2084 cmd = '%s %s' % (cmd,rest)
2084 cmd = '%s %s' % (cmd,rest)
2085 else:
2085 else:
2086 # Handle aliases with positional arguments
2086 # Handle aliases with positional arguments
2087 args = rest.split(None,nargs)
2087 args = rest.split(None,nargs)
2088 if len(args)< nargs:
2088 if len(args)< nargs:
2089 error('Alias <%s> requires %s arguments, %s given.' %
2089 error('Alias <%s> requires %s arguments, %s given.' %
2090 (alias,nargs,len(args)))
2090 (alias,nargs,len(args)))
2091 return None
2091 return None
2092 cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))
2092 cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))
2093 # Now call the macro, evaluating in the user's namespace
2093 # Now call the macro, evaluating in the user's namespace
2094 #print 'new command: <%r>' % cmd # dbg
2094 #print 'new command: <%r>' % cmd # dbg
2095 return cmd
2095 return cmd
2096
2096
2097 def call_alias(self,alias,rest=''):
2097 def call_alias(self,alias,rest=''):
2098 """Call an alias given its name and the rest of the line.
2098 """Call an alias given its name and the rest of the line.
2099
2099
2100 This is only used to provide backwards compatibility for users of
2100 This is only used to provide backwards compatibility for users of
2101 ipalias(), use of which is not recommended for anymore."""
2101 ipalias(), use of which is not recommended for anymore."""
2102
2102
2103 # Now call the macro, evaluating in the user's namespace
2103 # Now call the macro, evaluating in the user's namespace
2104 cmd = self.transform_alias(alias, rest)
2104 cmd = self.transform_alias(alias, rest)
2105 try:
2105 try:
2106 self.system(cmd)
2106 self.system(cmd)
2107 except:
2107 except:
2108 self.showtraceback()
2108 self.showtraceback()
2109
2109
2110 def indent_current_str(self):
2110 def indent_current_str(self):
2111 """return the current level of indentation as a string"""
2111 """return the current level of indentation as a string"""
2112 return self.indent_current_nsp * ' '
2112 return self.indent_current_nsp * ' '
2113
2113
2114 def autoindent_update(self,line):
2114 def autoindent_update(self,line):
2115 """Keep track of the indent level."""
2115 """Keep track of the indent level."""
2116
2116
2117 #debugx('line')
2117 #debugx('line')
2118 #debugx('self.indent_current_nsp')
2118 #debugx('self.indent_current_nsp')
2119 if self.autoindent:
2119 if self.autoindent:
2120 if line:
2120 if line:
2121 inisp = num_ini_spaces(line)
2121 inisp = num_ini_spaces(line)
2122 if inisp < self.indent_current_nsp:
2122 if inisp < self.indent_current_nsp:
2123 self.indent_current_nsp = inisp
2123 self.indent_current_nsp = inisp
2124
2124
2125 if line[-1] == ':':
2125 if line[-1] == ':':
2126 self.indent_current_nsp += 4
2126 self.indent_current_nsp += 4
2127 elif dedent_re.match(line):
2127 elif dedent_re.match(line):
2128 self.indent_current_nsp -= 4
2128 self.indent_current_nsp -= 4
2129 else:
2129 else:
2130 self.indent_current_nsp = 0
2130 self.indent_current_nsp = 0
2131
2131
2132 def runlines(self,lines):
2132 def runlines(self,lines):
2133 """Run a string of one or more lines of source.
2133 """Run a string of one or more lines of source.
2134
2134
2135 This method is capable of running a string containing multiple source
2135 This method is capable of running a string containing multiple source
2136 lines, as if they had been entered at the IPython prompt. Since it
2136 lines, as if they had been entered at the IPython prompt. Since it
2137 exposes IPython's processing machinery, the given strings can contain
2137 exposes IPython's processing machinery, the given strings can contain
2138 magic calls (%magic), special shell access (!cmd), etc."""
2138 magic calls (%magic), special shell access (!cmd), etc."""
2139
2139
2140 # We must start with a clean buffer, in case this is run from an
2140 # We must start with a clean buffer, in case this is run from an
2141 # interactive IPython session (via a magic, for example).
2141 # interactive IPython session (via a magic, for example).
2142 self.resetbuffer()
2142 self.resetbuffer()
2143 lines = lines.split('\n')
2143 lines = lines.split('\n')
2144 more = 0
2144 more = 0
2145
2145
2146 for line in lines:
2146 for line in lines:
2147 # skip blank lines so we don't mess up the prompt counter, but do
2147 # skip blank lines so we don't mess up the prompt counter, but do
2148 # NOT skip even a blank line if we are in a code block (more is
2148 # NOT skip even a blank line if we are in a code block (more is
2149 # true)
2149 # true)
2150
2150
2151 if line or more:
2151 if line or more:
2152 # push to raw history, so hist line numbers stay in sync
2152 # push to raw history, so hist line numbers stay in sync
2153 self.input_hist_raw.append("# " + line + "\n")
2153 self.input_hist_raw.append("# " + line + "\n")
2154 more = self.push(self.prefilter(line,more))
2154 more = self.push(self.prefilter(line,more))
2155 # IPython's runsource returns None if there was an error
2155 # IPython's runsource returns None if there was an error
2156 # compiling the code. This allows us to stop processing right
2156 # compiling the code. This allows us to stop processing right
2157 # away, so the user gets the error message at the right place.
2157 # away, so the user gets the error message at the right place.
2158 if more is None:
2158 if more is None:
2159 break
2159 break
2160 else:
2160 else:
2161 self.input_hist_raw.append("\n")
2161 self.input_hist_raw.append("\n")
2162 # final newline in case the input didn't have it, so that the code
2162 # final newline in case the input didn't have it, so that the code
2163 # actually does get executed
2163 # actually does get executed
2164 if more:
2164 if more:
2165 self.push('\n')
2165 self.push('\n')
2166
2166
2167 def runsource(self, source, filename='<input>', symbol='single'):
2167 def runsource(self, source, filename='<input>', symbol='single'):
2168 """Compile and run some source in the interpreter.
2168 """Compile and run some source in the interpreter.
2169
2169
2170 Arguments are as for compile_command().
2170 Arguments are as for compile_command().
2171
2171
2172 One several things can happen:
2172 One several things can happen:
2173
2173
2174 1) The input is incorrect; compile_command() raised an
2174 1) The input is incorrect; compile_command() raised an
2175 exception (SyntaxError or OverflowError). A syntax traceback
2175 exception (SyntaxError or OverflowError). A syntax traceback
2176 will be printed by calling the showsyntaxerror() method.
2176 will be printed by calling the showsyntaxerror() method.
2177
2177
2178 2) The input is incomplete, and more input is required;
2178 2) The input is incomplete, and more input is required;
2179 compile_command() returned None. Nothing happens.
2179 compile_command() returned None. Nothing happens.
2180
2180
2181 3) The input is complete; compile_command() returned a code
2181 3) The input is complete; compile_command() returned a code
2182 object. The code is executed by calling self.runcode() (which
2182 object. The code is executed by calling self.runcode() (which
2183 also handles run-time exceptions, except for SystemExit).
2183 also handles run-time exceptions, except for SystemExit).
2184
2184
2185 The return value is:
2185 The return value is:
2186
2186
2187 - True in case 2
2187 - True in case 2
2188
2188
2189 - False in the other cases, unless an exception is raised, where
2189 - False in the other cases, unless an exception is raised, where
2190 None is returned instead. This can be used by external callers to
2190 None is returned instead. This can be used by external callers to
2191 know whether to continue feeding input or not.
2191 know whether to continue feeding input or not.
2192
2192
2193 The return value can be used to decide whether to use sys.ps1 or
2193 The return value can be used to decide whether to use sys.ps1 or
2194 sys.ps2 to prompt the next line."""
2194 sys.ps2 to prompt the next line."""
2195
2195
2196 # if the source code has leading blanks, add 'if 1:\n' to it
2196 # if the source code has leading blanks, add 'if 1:\n' to it
2197 # this allows execution of indented pasted code. It is tempting
2197 # this allows execution of indented pasted code. It is tempting
2198 # to add '\n' at the end of source to run commands like ' a=1'
2198 # to add '\n' at the end of source to run commands like ' a=1'
2199 # directly, but this fails for more complicated scenarios
2199 # directly, but this fails for more complicated scenarios
2200 source=source.encode(self.stdin_encoding)
2200 source=source.encode(self.stdin_encoding)
2201 if source[:1] in [' ', '\t']:
2201 if source[:1] in [' ', '\t']:
2202 source = 'if 1:\n%s' % source
2202 source = 'if 1:\n%s' % source
2203
2203
2204 try:
2204 try:
2205 code = self.compile(source,filename,symbol)
2205 code = self.compile(source,filename,symbol)
2206 except (OverflowError, SyntaxError, ValueError, TypeError, MemoryError):
2206 except (OverflowError, SyntaxError, ValueError, TypeError, MemoryError):
2207 # Case 1
2207 # Case 1
2208 self.showsyntaxerror(filename)
2208 self.showsyntaxerror(filename)
2209 return None
2209 return None
2210
2210
2211 if code is None:
2211 if code is None:
2212 # Case 2
2212 # Case 2
2213 return True
2213 return True
2214
2214
2215 # Case 3
2215 # Case 3
2216 # We store the code object so that threaded shells and
2216 # We store the code object so that threaded shells and
2217 # custom exception handlers can access all this info if needed.
2217 # custom exception handlers can access all this info if needed.
2218 # The source corresponding to this can be obtained from the
2218 # The source corresponding to this can be obtained from the
2219 # buffer attribute as '\n'.join(self.buffer).
2219 # buffer attribute as '\n'.join(self.buffer).
2220 self.code_to_run = code
2220 self.code_to_run = code
2221 # now actually execute the code object
2221 # now actually execute the code object
2222 if self.runcode(code) == 0:
2222 if self.runcode(code) == 0:
2223 return False
2223 return False
2224 else:
2224 else:
2225 return None
2225 return None
2226
2226
2227 def runcode(self,code_obj):
2227 def runcode(self,code_obj):
2228 """Execute a code object.
2228 """Execute a code object.
2229
2229
2230 When an exception occurs, self.showtraceback() is called to display a
2230 When an exception occurs, self.showtraceback() is called to display a
2231 traceback.
2231 traceback.
2232
2232
2233 Return value: a flag indicating whether the code to be run completed
2233 Return value: a flag indicating whether the code to be run completed
2234 successfully:
2234 successfully:
2235
2235
2236 - 0: successful execution.
2236 - 0: successful execution.
2237 - 1: an error occurred.
2237 - 1: an error occurred.
2238 """
2238 """
2239
2239
2240 # Set our own excepthook in case the user code tries to call it
2240 # Set our own excepthook in case the user code tries to call it
2241 # directly, so that the IPython crash handler doesn't get triggered
2241 # directly, so that the IPython crash handler doesn't get triggered
2242 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2242 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2243
2243
2244 # we save the original sys.excepthook in the instance, in case config
2244 # we save the original sys.excepthook in the instance, in case config
2245 # code (such as magics) needs access to it.
2245 # code (such as magics) needs access to it.
2246 self.sys_excepthook = old_excepthook
2246 self.sys_excepthook = old_excepthook
2247 outflag = 1 # happens in more places, so it's easier as default
2247 outflag = 1 # happens in more places, so it's easier as default
2248 try:
2248 try:
2249 try:
2249 try:
2250 self.hooks.pre_runcode_hook()
2250 self.hooks.pre_runcode_hook()
2251 exec code_obj in self.user_global_ns, self.user_ns
2251 exec code_obj in self.user_global_ns, self.user_ns
2252 finally:
2252 finally:
2253 # Reset our crash handler in place
2253 # Reset our crash handler in place
2254 sys.excepthook = old_excepthook
2254 sys.excepthook = old_excepthook
2255 except SystemExit:
2255 except SystemExit:
2256 self.resetbuffer()
2256 self.resetbuffer()
2257 self.showtraceback()
2257 self.showtraceback()
2258 warn("Type %exit or %quit to exit IPython "
2258 warn("Type %exit or %quit to exit IPython "
2259 "(%Exit or %Quit do so unconditionally).",level=1)
2259 "(%Exit or %Quit do so unconditionally).",level=1)
2260 except self.custom_exceptions:
2260 except self.custom_exceptions:
2261 etype,value,tb = sys.exc_info()
2261 etype,value,tb = sys.exc_info()
2262 self.CustomTB(etype,value,tb)
2262 self.CustomTB(etype,value,tb)
2263 except:
2263 except:
2264 self.showtraceback()
2264 self.showtraceback()
2265 else:
2265 else:
2266 outflag = 0
2266 outflag = 0
2267 if softspace(sys.stdout, 0):
2267 if softspace(sys.stdout, 0):
2268 print
2268 print
2269 # Flush out code object which has been run (and source)
2269 # Flush out code object which has been run (and source)
2270 self.code_to_run = None
2270 self.code_to_run = None
2271 return outflag
2271 return outflag
2272
2272
2273 def push(self, line):
2273 def push(self, line):
2274 """Push a line to the interpreter.
2274 """Push a line to the interpreter.
2275
2275
2276 The line should not have a trailing newline; it may have
2276 The line should not have a trailing newline; it may have
2277 internal newlines. The line is appended to a buffer and the
2277 internal newlines. The line is appended to a buffer and the
2278 interpreter's runsource() method is called with the
2278 interpreter's runsource() method is called with the
2279 concatenated contents of the buffer as source. If this
2279 concatenated contents of the buffer as source. If this
2280 indicates that the command was executed or invalid, the buffer
2280 indicates that the command was executed or invalid, the buffer
2281 is reset; otherwise, the command is incomplete, and the buffer
2281 is reset; otherwise, the command is incomplete, and the buffer
2282 is left as it was after the line was appended. The return
2282 is left as it was after the line was appended. The return
2283 value is 1 if more input is required, 0 if the line was dealt
2283 value is 1 if more input is required, 0 if the line was dealt
2284 with in some way (this is the same as runsource()).
2284 with in some way (this is the same as runsource()).
2285 """
2285 """
2286
2286
2287 # autoindent management should be done here, and not in the
2287 # autoindent management should be done here, and not in the
2288 # interactive loop, since that one is only seen by keyboard input. We
2288 # interactive loop, since that one is only seen by keyboard input. We
2289 # need this done correctly even for code run via runlines (which uses
2289 # need this done correctly even for code run via runlines (which uses
2290 # push).
2290 # push).
2291
2291
2292 #print 'push line: <%s>' % line # dbg
2292 #print 'push line: <%s>' % line # dbg
2293 for subline in line.splitlines():
2293 for subline in line.splitlines():
2294 self.autoindent_update(subline)
2294 self.autoindent_update(subline)
2295 self.buffer.append(line)
2295 self.buffer.append(line)
2296 more = self.runsource('\n'.join(self.buffer), self.filename)
2296 more = self.runsource('\n'.join(self.buffer), self.filename)
2297 if not more:
2297 if not more:
2298 self.resetbuffer()
2298 self.resetbuffer()
2299 return more
2299 return more
2300
2300
2301 def split_user_input(self, line):
2301 def split_user_input(self, line):
2302 # This is really a hold-over to support ipapi and some extensions
2302 # This is really a hold-over to support ipapi and some extensions
2303 return prefilter.splitUserInput(line)
2303 return prefilter.splitUserInput(line)
2304
2304
2305 def resetbuffer(self):
2305 def resetbuffer(self):
2306 """Reset the input buffer."""
2306 """Reset the input buffer."""
2307 self.buffer[:] = []
2307 self.buffer[:] = []
2308
2308
2309 def raw_input(self,prompt='',continue_prompt=False):
2309 def raw_input(self,prompt='',continue_prompt=False):
2310 """Write a prompt and read a line.
2310 """Write a prompt and read a line.
2311
2311
2312 The returned line does not include the trailing newline.
2312 The returned line does not include the trailing newline.
2313 When the user enters the EOF key sequence, EOFError is raised.
2313 When the user enters the EOF key sequence, EOFError is raised.
2314
2314
2315 Optional inputs:
2315 Optional inputs:
2316
2316
2317 - prompt(''): a string to be printed to prompt the user.
2317 - prompt(''): a string to be printed to prompt the user.
2318
2318
2319 - continue_prompt(False): whether this line is the first one or a
2319 - continue_prompt(False): whether this line is the first one or a
2320 continuation in a sequence of inputs.
2320 continuation in a sequence of inputs.
2321 """
2321 """
2322
2322
2323 # Code run by the user may have modified the readline completer state.
2323 # Code run by the user may have modified the readline completer state.
2324 # We must ensure that our completer is back in place.
2324 # We must ensure that our completer is back in place.
2325 if self.has_readline:
2325 if self.has_readline:
2326 self.set_completer()
2326 self.set_completer()
2327
2327
2328 try:
2328 try:
2329 line = raw_input_original(prompt).decode(self.stdin_encoding)
2329 line = raw_input_original(prompt).decode(self.stdin_encoding)
2330 except ValueError:
2330 except ValueError:
2331 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
2331 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
2332 " or sys.stdout.close()!\nExiting IPython!")
2332 " or sys.stdout.close()!\nExiting IPython!")
2333 self.ask_exit()
2333 self.ask_exit()
2334 return ""
2334 return ""
2335
2335
2336 # Try to be reasonably smart about not re-indenting pasted input more
2336 # Try to be reasonably smart about not re-indenting pasted input more
2337 # than necessary. We do this by trimming out the auto-indent initial
2337 # than necessary. We do this by trimming out the auto-indent initial
2338 # spaces, if the user's actual input started itself with whitespace.
2338 # spaces, if the user's actual input started itself with whitespace.
2339 #debugx('self.buffer[-1]')
2339 #debugx('self.buffer[-1]')
2340
2340
2341 if self.autoindent:
2341 if self.autoindent:
2342 if num_ini_spaces(line) > self.indent_current_nsp:
2342 if num_ini_spaces(line) > self.indent_current_nsp:
2343 line = line[self.indent_current_nsp:]
2343 line = line[self.indent_current_nsp:]
2344 self.indent_current_nsp = 0
2344 self.indent_current_nsp = 0
2345
2345
2346 # store the unfiltered input before the user has any chance to modify
2346 # store the unfiltered input before the user has any chance to modify
2347 # it.
2347 # it.
2348 if line.strip():
2348 if line.strip():
2349 if continue_prompt:
2349 if continue_prompt:
2350 self.input_hist_raw[-1] += '%s\n' % line
2350 self.input_hist_raw[-1] += '%s\n' % line
2351 if self.has_readline: # and some config option is set?
2351 if self.has_readline: # and some config option is set?
2352 try:
2352 try:
2353 histlen = self.readline.get_current_history_length()
2353 histlen = self.readline.get_current_history_length()
2354 if histlen > 1:
2354 if histlen > 1:
2355 newhist = self.input_hist_raw[-1].rstrip()
2355 newhist = self.input_hist_raw[-1].rstrip()
2356 self.readline.remove_history_item(histlen-1)
2356 self.readline.remove_history_item(histlen-1)
2357 self.readline.replace_history_item(histlen-2,
2357 self.readline.replace_history_item(histlen-2,
2358 newhist.encode(self.stdin_encoding))
2358 newhist.encode(self.stdin_encoding))
2359 except AttributeError:
2359 except AttributeError:
2360 pass # re{move,place}_history_item are new in 2.4.
2360 pass # re{move,place}_history_item are new in 2.4.
2361 else:
2361 else:
2362 self.input_hist_raw.append('%s\n' % line)
2362 self.input_hist_raw.append('%s\n' % line)
2363 # only entries starting at first column go to shadow history
2363 # only entries starting at first column go to shadow history
2364 if line.lstrip() == line:
2364 if line.lstrip() == line:
2365 self.shadowhist.add(line.strip())
2365 self.shadowhist.add(line.strip())
2366 elif not continue_prompt:
2366 elif not continue_prompt:
2367 self.input_hist_raw.append('\n')
2367 self.input_hist_raw.append('\n')
2368 try:
2368 try:
2369 lineout = self.prefilter(line,continue_prompt)
2369 lineout = self.prefilter(line,continue_prompt)
2370 except:
2370 except:
2371 # blanket except, in case a user-defined prefilter crashes, so it
2371 # blanket except, in case a user-defined prefilter crashes, so it
2372 # can't take all of ipython with it.
2372 # can't take all of ipython with it.
2373 self.showtraceback()
2373 self.showtraceback()
2374 return ''
2374 return ''
2375 else:
2375 else:
2376 return lineout
2376 return lineout
2377
2377
2378 def _prefilter(self, line, continue_prompt):
2378 def _prefilter(self, line, continue_prompt):
2379 """Calls different preprocessors, depending on the form of line."""
2379 """Calls different preprocessors, depending on the form of line."""
2380
2380
2381 # All handlers *must* return a value, even if it's blank ('').
2381 # All handlers *must* return a value, even if it's blank ('').
2382
2382
2383 # Lines are NOT logged here. Handlers should process the line as
2383 # Lines are NOT logged here. Handlers should process the line as
2384 # needed, update the cache AND log it (so that the input cache array
2384 # needed, update the cache AND log it (so that the input cache array
2385 # stays synced).
2385 # stays synced).
2386
2386
2387 #.....................................................................
2387 #.....................................................................
2388 # Code begins
2388 # Code begins
2389
2389
2390 #if line.startswith('%crash'): raise RuntimeError,'Crash now!' # dbg
2390 #if line.startswith('%crash'): raise RuntimeError,'Crash now!' # dbg
2391
2391
2392 # save the line away in case we crash, so the post-mortem handler can
2392 # save the line away in case we crash, so the post-mortem handler can
2393 # record it
2393 # record it
2394 self._last_input_line = line
2394 self._last_input_line = line
2395
2395
2396 #print '***line: <%s>' % line # dbg
2396 #print '***line: <%s>' % line # dbg
2397
2397
2398 if not line:
2398 if not line:
2399 # Return immediately on purely empty lines, so that if the user
2399 # Return immediately on purely empty lines, so that if the user
2400 # previously typed some whitespace that started a continuation
2400 # previously typed some whitespace that started a continuation
2401 # prompt, he can break out of that loop with just an empty line.
2401 # prompt, he can break out of that loop with just an empty line.
2402 # This is how the default python prompt works.
2402 # This is how the default python prompt works.
2403
2403
2404 # Only return if the accumulated input buffer was just whitespace!
2404 # Only return if the accumulated input buffer was just whitespace!
2405 if ''.join(self.buffer).isspace():
2405 if ''.join(self.buffer).isspace():
2406 self.buffer[:] = []
2406 self.buffer[:] = []
2407 return ''
2407 return ''
2408
2408
2409 line_info = prefilter.LineInfo(line, continue_prompt)
2409 line_info = prefilter.LineInfo(line, continue_prompt)
2410
2410
2411 # the input history needs to track even empty lines
2411 # the input history needs to track even empty lines
2412 stripped = line.strip()
2412 stripped = line.strip()
2413
2413
2414 if not stripped:
2414 if not stripped:
2415 if not continue_prompt:
2415 if not continue_prompt:
2416 self.outputcache.prompt_count -= 1
2416 self.outputcache.prompt_count -= 1
2417 return self.handle_normal(line_info)
2417 return self.handle_normal(line_info)
2418
2418
2419 # print '***cont',continue_prompt # dbg
2419 # print '***cont',continue_prompt # dbg
2420 # special handlers are only allowed for single line statements
2420 # special handlers are only allowed for single line statements
2421 if continue_prompt and not self.rc.multi_line_specials:
2421 if continue_prompt and not self.rc.multi_line_specials:
2422 return self.handle_normal(line_info)
2422 return self.handle_normal(line_info)
2423
2423
2424
2424
2425 # See whether any pre-existing handler can take care of it
2425 # See whether any pre-existing handler can take care of it
2426 rewritten = self.hooks.input_prefilter(stripped)
2426 rewritten = self.hooks.input_prefilter(stripped)
2427 if rewritten != stripped: # ok, some prefilter did something
2427 if rewritten != stripped: # ok, some prefilter did something
2428 rewritten = line_info.pre + rewritten # add indentation
2428 rewritten = line_info.pre + rewritten # add indentation
2429 return self.handle_normal(prefilter.LineInfo(rewritten,
2429 return self.handle_normal(prefilter.LineInfo(rewritten,
2430 continue_prompt))
2430 continue_prompt))
2431
2431
2432 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2432 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2433
2433
2434 return prefilter.prefilter(line_info, self)
2434 return prefilter.prefilter(line_info, self)
2435
2435
2436
2436
2437 def _prefilter_dumb(self, line, continue_prompt):
2437 def _prefilter_dumb(self, line, continue_prompt):
2438 """simple prefilter function, for debugging"""
2438 """simple prefilter function, for debugging"""
2439 return self.handle_normal(line,continue_prompt)
2439 return self.handle_normal(line,continue_prompt)
2440
2440
2441
2441
2442 def multiline_prefilter(self, line, continue_prompt):
2442 def multiline_prefilter(self, line, continue_prompt):
2443 """ Run _prefilter for each line of input
2443 """ Run _prefilter for each line of input
2444
2444
2445 Covers cases where there are multiple lines in the user entry,
2445 Covers cases where there are multiple lines in the user entry,
2446 which is the case when the user goes back to a multiline history
2446 which is the case when the user goes back to a multiline history
2447 entry and presses enter.
2447 entry and presses enter.
2448
2448
2449 """
2449 """
2450 out = []
2450 out = []
2451 for l in line.rstrip('\n').split('\n'):
2451 for l in line.rstrip('\n').split('\n'):
2452 out.append(self._prefilter(l, continue_prompt))
2452 out.append(self._prefilter(l, continue_prompt))
2453 return '\n'.join(out)
2453 return '\n'.join(out)
2454
2454
2455 # Set the default prefilter() function (this can be user-overridden)
2455 # Set the default prefilter() function (this can be user-overridden)
2456 prefilter = multiline_prefilter
2456 prefilter = multiline_prefilter
2457
2457
2458 def handle_normal(self,line_info):
2458 def handle_normal(self,line_info):
2459 """Handle normal input lines. Use as a template for handlers."""
2459 """Handle normal input lines. Use as a template for handlers."""
2460
2460
2461 # With autoindent on, we need some way to exit the input loop, and I
2461 # With autoindent on, we need some way to exit the input loop, and I
2462 # don't want to force the user to have to backspace all the way to
2462 # don't want to force the user to have to backspace all the way to
2463 # clear the line. The rule will be in this case, that either two
2463 # clear the line. The rule will be in this case, that either two
2464 # lines of pure whitespace in a row, or a line of pure whitespace but
2464 # lines of pure whitespace in a row, or a line of pure whitespace but
2465 # of a size different to the indent level, will exit the input loop.
2465 # of a size different to the indent level, will exit the input loop.
2466 line = line_info.line
2466 line = line_info.line
2467 continue_prompt = line_info.continue_prompt
2467 continue_prompt = line_info.continue_prompt
2468
2468
2469 if (continue_prompt and self.autoindent and line.isspace() and
2469 if (continue_prompt and self.autoindent and line.isspace() and
2470 (0 < abs(len(line) - self.indent_current_nsp) <= 2 or
2470 (0 < abs(len(line) - self.indent_current_nsp) <= 2 or
2471 (self.buffer[-1]).isspace() )):
2471 (self.buffer[-1]).isspace() )):
2472 line = ''
2472 line = ''
2473
2473
2474 self.log(line,line,continue_prompt)
2474 self.log(line,line,continue_prompt)
2475 return line
2475 return line
2476
2476
2477 def handle_alias(self,line_info):
2477 def handle_alias(self,line_info):
2478 """Handle alias input lines. """
2478 """Handle alias input lines. """
2479 tgt = self.alias_table[line_info.iFun]
2479 tgt = self.alias_table[line_info.iFun]
2480 # print "=>",tgt #dbg
2480 # print "=>",tgt #dbg
2481 if callable(tgt):
2481 if callable(tgt):
2482 if '$' in line_info.line:
2482 if '$' in line_info.line:
2483 call_meth = '(_ip, _ip.itpl(%s))'
2483 call_meth = '(_ip, _ip.itpl(%s))'
2484 else:
2484 else:
2485 call_meth = '(_ip,%s)'
2485 call_meth = '(_ip,%s)'
2486 line_out = ("%s_sh.%s" + call_meth) % (line_info.preWhitespace,
2486 line_out = ("%s_sh.%s" + call_meth) % (line_info.preWhitespace,
2487 line_info.iFun,
2487 line_info.iFun,
2488 make_quoted_expr(line_info.line))
2488 make_quoted_expr(line_info.line))
2489 else:
2489 else:
2490 transformed = self.expand_aliases(line_info.iFun,line_info.theRest)
2490 transformed = self.expand_aliases(line_info.iFun,line_info.theRest)
2491
2491
2492 # pre is needed, because it carries the leading whitespace. Otherwise
2492 # pre is needed, because it carries the leading whitespace. Otherwise
2493 # aliases won't work in indented sections.
2493 # aliases won't work in indented sections.
2494 line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
2494 line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
2495 make_quoted_expr( transformed ))
2495 make_quoted_expr( transformed ))
2496
2496
2497 self.log(line_info.line,line_out,line_info.continue_prompt)
2497 self.log(line_info.line,line_out,line_info.continue_prompt)
2498 #print 'line out:',line_out # dbg
2498 #print 'line out:',line_out # dbg
2499 return line_out
2499 return line_out
2500
2500
2501 def handle_shell_escape(self, line_info):
2501 def handle_shell_escape(self, line_info):
2502 """Execute the line in a shell, empty return value"""
2502 """Execute the line in a shell, empty return value"""
2503 #print 'line in :', `line` # dbg
2503 #print 'line in :', `line` # dbg
2504 line = line_info.line
2504 line = line_info.line
2505 if line.lstrip().startswith('!!'):
2505 if line.lstrip().startswith('!!'):
2506 # rewrite LineInfo's line, iFun and theRest to properly hold the
2506 # rewrite LineInfo's line, iFun and theRest to properly hold the
2507 # call to %sx and the actual command to be executed, so
2507 # call to %sx and the actual command to be executed, so
2508 # handle_magic can work correctly. Note that this works even if
2508 # handle_magic can work correctly. Note that this works even if
2509 # the line is indented, so it handles multi_line_specials
2509 # the line is indented, so it handles multi_line_specials
2510 # properly.
2510 # properly.
2511 new_rest = line.lstrip()[2:]
2511 new_rest = line.lstrip()[2:]
2512 line_info.line = '%ssx %s' % (self.ESC_MAGIC,new_rest)
2512 line_info.line = '%ssx %s' % (self.ESC_MAGIC,new_rest)
2513 line_info.iFun = 'sx'
2513 line_info.iFun = 'sx'
2514 line_info.theRest = new_rest
2514 line_info.theRest = new_rest
2515 return self.handle_magic(line_info)
2515 return self.handle_magic(line_info)
2516 else:
2516 else:
2517 cmd = line.lstrip().lstrip('!')
2517 cmd = line.lstrip().lstrip('!')
2518 line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
2518 line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
2519 make_quoted_expr(cmd))
2519 make_quoted_expr(cmd))
2520 # update cache/log and return
2520 # update cache/log and return
2521 self.log(line,line_out,line_info.continue_prompt)
2521 self.log(line,line_out,line_info.continue_prompt)
2522 return line_out
2522 return line_out
2523
2523
2524 def handle_magic(self, line_info):
2524 def handle_magic(self, line_info):
2525 """Execute magic functions."""
2525 """Execute magic functions."""
2526 iFun = line_info.iFun
2526 iFun = line_info.iFun
2527 theRest = line_info.theRest
2527 theRest = line_info.theRest
2528 cmd = '%s_ip.magic(%s)' % (line_info.preWhitespace,
2528 cmd = '%s_ip.magic(%s)' % (line_info.preWhitespace,
2529 make_quoted_expr(iFun + " " + theRest))
2529 make_quoted_expr(iFun + " " + theRest))
2530 self.log(line_info.line,cmd,line_info.continue_prompt)
2530 self.log(line_info.line,cmd,line_info.continue_prompt)
2531 #print 'in handle_magic, cmd=<%s>' % cmd # dbg
2531 #print 'in handle_magic, cmd=<%s>' % cmd # dbg
2532 return cmd
2532 return cmd
2533
2533
2534 def handle_auto(self, line_info):
2534 def handle_auto(self, line_info):
2535 """Hande lines which can be auto-executed, quoting if requested."""
2535 """Hande lines which can be auto-executed, quoting if requested."""
2536
2536
2537 line = line_info.line
2537 line = line_info.line
2538 iFun = line_info.iFun
2538 iFun = line_info.iFun
2539 theRest = line_info.theRest
2539 theRest = line_info.theRest
2540 pre = line_info.pre
2540 pre = line_info.pre
2541 continue_prompt = line_info.continue_prompt
2541 continue_prompt = line_info.continue_prompt
2542 obj = line_info.ofind(self)['obj']
2542 obj = line_info.ofind(self)['obj']
2543
2543
2544 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2544 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2545
2545
2546 # This should only be active for single-line input!
2546 # This should only be active for single-line input!
2547 if continue_prompt:
2547 if continue_prompt:
2548 self.log(line,line,continue_prompt)
2548 self.log(line,line,continue_prompt)
2549 return line
2549 return line
2550
2550
2551 force_auto = isinstance(obj, ipapi.IPyAutocall)
2551 force_auto = isinstance(obj, ipapi.IPyAutocall)
2552 auto_rewrite = True
2552 auto_rewrite = True
2553
2553
2554 if pre == self.ESC_QUOTE:
2554 if pre == self.ESC_QUOTE:
2555 # Auto-quote splitting on whitespace
2555 # Auto-quote splitting on whitespace
2556 newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) )
2556 newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) )
2557 elif pre == self.ESC_QUOTE2:
2557 elif pre == self.ESC_QUOTE2:
2558 # Auto-quote whole string
2558 # Auto-quote whole string
2559 newcmd = '%s("%s")' % (iFun,theRest)
2559 newcmd = '%s("%s")' % (iFun,theRest)
2560 elif pre == self.ESC_PAREN:
2560 elif pre == self.ESC_PAREN:
2561 newcmd = '%s(%s)' % (iFun,",".join(theRest.split()))
2561 newcmd = '%s(%s)' % (iFun,",".join(theRest.split()))
2562 else:
2562 else:
2563 # Auto-paren.
2563 # Auto-paren.
2564 # We only apply it to argument-less calls if the autocall
2564 # We only apply it to argument-less calls if the autocall
2565 # parameter is set to 2. We only need to check that autocall is <
2565 # parameter is set to 2. We only need to check that autocall is <
2566 # 2, since this function isn't called unless it's at least 1.
2566 # 2, since this function isn't called unless it's at least 1.
2567 if not theRest and (self.rc.autocall < 2) and not force_auto:
2567 if not theRest and (self.rc.autocall < 2) and not force_auto:
2568 newcmd = '%s %s' % (iFun,theRest)
2568 newcmd = '%s %s' % (iFun,theRest)
2569 auto_rewrite = False
2569 auto_rewrite = False
2570 else:
2570 else:
2571 if not force_auto and theRest.startswith('['):
2571 if not force_auto and theRest.startswith('['):
2572 if hasattr(obj,'__getitem__'):
2572 if hasattr(obj,'__getitem__'):
2573 # Don't autocall in this case: item access for an object
2573 # Don't autocall in this case: item access for an object
2574 # which is BOTH callable and implements __getitem__.
2574 # which is BOTH callable and implements __getitem__.
2575 newcmd = '%s %s' % (iFun,theRest)
2575 newcmd = '%s %s' % (iFun,theRest)
2576 auto_rewrite = False
2576 auto_rewrite = False
2577 else:
2577 else:
2578 # if the object doesn't support [] access, go ahead and
2578 # if the object doesn't support [] access, go ahead and
2579 # autocall
2579 # autocall
2580 newcmd = '%s(%s)' % (iFun.rstrip(),theRest)
2580 newcmd = '%s(%s)' % (iFun.rstrip(),theRest)
2581 elif theRest.endswith(';'):
2581 elif theRest.endswith(';'):
2582 newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1])
2582 newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1])
2583 else:
2583 else:
2584 newcmd = '%s(%s)' % (iFun.rstrip(), theRest)
2584 newcmd = '%s(%s)' % (iFun.rstrip(), theRest)
2585
2585
2586 if auto_rewrite:
2586 if auto_rewrite:
2587 rw = self.outputcache.prompt1.auto_rewrite() + newcmd
2587 rw = self.outputcache.prompt1.auto_rewrite() + newcmd
2588
2588
2589 try:
2589 try:
2590 # plain ascii works better w/ pyreadline, on some machines, so
2590 # plain ascii works better w/ pyreadline, on some machines, so
2591 # we use it and only print uncolored rewrite if we have unicode
2591 # we use it and only print uncolored rewrite if we have unicode
2592 rw = str(rw)
2592 rw = str(rw)
2593 print >>Term.cout, rw
2593 print >>Term.cout, rw
2594 except UnicodeEncodeError:
2594 except UnicodeEncodeError:
2595 print "-------------->" + newcmd
2595 print "-------------->" + newcmd
2596
2596
2597 # log what is now valid Python, not the actual user input (without the
2597 # log what is now valid Python, not the actual user input (without the
2598 # final newline)
2598 # final newline)
2599 self.log(line,newcmd,continue_prompt)
2599 self.log(line,newcmd,continue_prompt)
2600 return newcmd
2600 return newcmd
2601
2601
2602 def handle_help(self, line_info):
2602 def handle_help(self, line_info):
2603 """Try to get some help for the object.
2603 """Try to get some help for the object.
2604
2604
2605 obj? or ?obj -> basic information.
2605 obj? or ?obj -> basic information.
2606 obj?? or ??obj -> more details.
2606 obj?? or ??obj -> more details.
2607 """
2607 """
2608
2608
2609 line = line_info.line
2609 line = line_info.line
2610 # We need to make sure that we don't process lines which would be
2610 # We need to make sure that we don't process lines which would be
2611 # otherwise valid python, such as "x=1 # what?"
2611 # otherwise valid python, such as "x=1 # what?"
2612 try:
2612 try:
2613 codeop.compile_command(line)
2613 codeop.compile_command(line)
2614 except SyntaxError:
2614 except SyntaxError:
2615 # We should only handle as help stuff which is NOT valid syntax
2615 # We should only handle as help stuff which is NOT valid syntax
2616 if line[0]==self.ESC_HELP:
2616 if line[0]==self.ESC_HELP:
2617 line = line[1:]
2617 line = line[1:]
2618 elif line[-1]==self.ESC_HELP:
2618 elif line[-1]==self.ESC_HELP:
2619 line = line[:-1]
2619 line = line[:-1]
2620 self.log(line,'#?'+line,line_info.continue_prompt)
2620 self.log(line,'#?'+line,line_info.continue_prompt)
2621 if line:
2621 if line:
2622 #print 'line:<%r>' % line # dbg
2622 #print 'line:<%r>' % line # dbg
2623 self.magic_pinfo(line)
2623 self.magic_pinfo(line)
2624 else:
2624 else:
2625 page(self.usage,screen_lines=self.rc.screen_length)
2625 page(self.usage,screen_lines=self.rc.screen_length)
2626 return '' # Empty string is needed here!
2626 return '' # Empty string is needed here!
2627 except:
2627 except:
2628 # Pass any other exceptions through to the normal handler
2628 # Pass any other exceptions through to the normal handler
2629 return self.handle_normal(line_info)
2629 return self.handle_normal(line_info)
2630 else:
2630 else:
2631 # If the code compiles ok, we should handle it normally
2631 # If the code compiles ok, we should handle it normally
2632 return self.handle_normal(line_info)
2632 return self.handle_normal(line_info)
2633
2633
2634 def getapi(self):
2634 def getapi(self):
2635 """ Get an IPApi object for this shell instance
2635 """ Get an IPApi object for this shell instance
2636
2636
2637 Getting an IPApi object is always preferable to accessing the shell
2637 Getting an IPApi object is always preferable to accessing the shell
2638 directly, but this holds true especially for extensions.
2638 directly, but this holds true especially for extensions.
2639
2639
2640 It should always be possible to implement an extension with IPApi
2640 It should always be possible to implement an extension with IPApi
2641 alone. If not, contact maintainer to request an addition.
2641 alone. If not, contact maintainer to request an addition.
2642
2642
2643 """
2643 """
2644 return self.api
2644 return self.api
2645
2645
2646 def handle_emacs(self, line_info):
2646 def handle_emacs(self, line_info):
2647 """Handle input lines marked by python-mode."""
2647 """Handle input lines marked by python-mode."""
2648
2648
2649 # Currently, nothing is done. Later more functionality can be added
2649 # Currently, nothing is done. Later more functionality can be added
2650 # here if needed.
2650 # here if needed.
2651
2651
2652 # The input cache shouldn't be updated
2652 # The input cache shouldn't be updated
2653 return line_info.line
2653 return line_info.line
2654
2654
2655
2655
2656 def mktempfile(self,data=None):
2656 def mktempfile(self,data=None):
2657 """Make a new tempfile and return its filename.
2657 """Make a new tempfile and return its filename.
2658
2658
2659 This makes a call to tempfile.mktemp, but it registers the created
2659 This makes a call to tempfile.mktemp, but it registers the created
2660 filename internally so ipython cleans it up at exit time.
2660 filename internally so ipython cleans it up at exit time.
2661
2661
2662 Optional inputs:
2662 Optional inputs:
2663
2663
2664 - data(None): if data is given, it gets written out to the temp file
2664 - data(None): if data is given, it gets written out to the temp file
2665 immediately, and the file is closed again."""
2665 immediately, and the file is closed again."""
2666
2666
2667 filename = tempfile.mktemp('.py','ipython_edit_')
2667 filename = tempfile.mktemp('.py','ipython_edit_')
2668 self.tempfiles.append(filename)
2668 self.tempfiles.append(filename)
2669
2669
2670 if data:
2670 if data:
2671 tmp_file = open(filename,'w')
2671 tmp_file = open(filename,'w')
2672 tmp_file.write(data)
2672 tmp_file.write(data)
2673 tmp_file.close()
2673 tmp_file.close()
2674 return filename
2674 return filename
2675
2675
2676 def write(self,data):
2676 def write(self,data):
2677 """Write a string to the default output"""
2677 """Write a string to the default output"""
2678 Term.cout.write(data)
2678 Term.cout.write(data)
2679
2679
2680 def write_err(self,data):
2680 def write_err(self,data):
2681 """Write a string to the default error output"""
2681 """Write a string to the default error output"""
2682 Term.cerr.write(data)
2682 Term.cerr.write(data)
2683
2683
2684 def ask_exit(self):
2684 def ask_exit(self):
2685 """ Call for exiting. Can be overiden and used as a callback. """
2685 """ Call for exiting. Can be overiden and used as a callback. """
2686 self.exit_now = True
2686 self.exit_now = True
2687
2687
2688 def exit(self):
2688 def exit(self):
2689 """Handle interactive exit.
2689 """Handle interactive exit.
2690
2690
2691 This method calls the ask_exit callback."""
2691 This method calls the ask_exit callback."""
2692
2692
2693 if self.rc.confirm_exit:
2693 if self.rc.confirm_exit:
2694 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
2694 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
2695 self.ask_exit()
2695 self.ask_exit()
2696 else:
2696 else:
2697 self.ask_exit()
2697 self.ask_exit()
2698
2698
2699 def safe_execfile(self,fname,*where,**kw):
2699 def safe_execfile(self,fname,*where,**kw):
2700 """A safe version of the builtin execfile().
2700 """A safe version of the builtin execfile().
2701
2701
2702 This version will never throw an exception, and knows how to handle
2702 This version will never throw an exception, and knows how to handle
2703 ipython logs as well.
2703 ipython logs as well.
2704
2704
2705 :Parameters:
2705 :Parameters:
2706 fname : string
2706 fname : string
2707 Name of the file to be executed.
2707 Name of the file to be executed.
2708
2708
2709 where : tuple
2709 where : tuple
2710 One or two namespaces, passed to execfile() as (globals,locals).
2710 One or two namespaces, passed to execfile() as (globals,locals).
2711 If only one is given, it is passed as both.
2711 If only one is given, it is passed as both.
2712
2712
2713 :Keywords:
2713 :Keywords:
2714 islog : boolean (False)
2714 islog : boolean (False)
2715
2715
2716 quiet : boolean (True)
2716 quiet : boolean (True)
2717
2717
2718 exit_ignore : boolean (False)
2718 exit_ignore : boolean (False)
2719 """
2719 """
2720
2720
2721 def syspath_cleanup():
2721 def syspath_cleanup():
2722 """Internal cleanup routine for sys.path."""
2722 """Internal cleanup routine for sys.path."""
2723 if add_dname:
2723 if add_dname:
2724 try:
2724 try:
2725 sys.path.remove(dname)
2725 sys.path.remove(dname)
2726 except ValueError:
2726 except ValueError:
2727 # For some reason the user has already removed it, ignore.
2727 # For some reason the user has already removed it, ignore.
2728 pass
2728 pass
2729
2729
2730 fname = os.path.expanduser(fname)
2730 fname = os.path.expanduser(fname)
2731
2731
2732 # Find things also in current directory. This is needed to mimic the
2732 # Find things also in current directory. This is needed to mimic the
2733 # behavior of running a script from the system command line, where
2733 # behavior of running a script from the system command line, where
2734 # Python inserts the script's directory into sys.path
2734 # Python inserts the script's directory into sys.path
2735 dname = os.path.dirname(os.path.abspath(fname))
2735 dname = os.path.dirname(os.path.abspath(fname))
2736 add_dname = False
2736 add_dname = False
2737 if dname not in sys.path:
2737 if dname not in sys.path:
2738 sys.path.insert(0,dname)
2738 sys.path.insert(0,dname)
2739 add_dname = True
2739 add_dname = True
2740
2740
2741 try:
2741 try:
2742 xfile = open(fname)
2742 xfile = open(fname)
2743 except:
2743 except:
2744 print >> Term.cerr, \
2744 print >> Term.cerr, \
2745 'Could not open file <%s> for safe execution.' % fname
2745 'Could not open file <%s> for safe execution.' % fname
2746 syspath_cleanup()
2746 syspath_cleanup()
2747 return None
2747 return None
2748
2748
2749 kw.setdefault('islog',0)
2749 kw.setdefault('islog',0)
2750 kw.setdefault('quiet',1)
2750 kw.setdefault('quiet',1)
2751 kw.setdefault('exit_ignore',0)
2751 kw.setdefault('exit_ignore',0)
2752
2752
2753 first = xfile.readline()
2753 first = xfile.readline()
2754 loghead = str(self.loghead_tpl).split('\n',1)[0].strip()
2754 loghead = str(self.loghead_tpl).split('\n',1)[0].strip()
2755 xfile.close()
2755 xfile.close()
2756 # line by line execution
2756 # line by line execution
2757 if first.startswith(loghead) or kw['islog']:
2757 if first.startswith(loghead) or kw['islog']:
2758 print 'Loading log file <%s> one line at a time...' % fname
2758 print 'Loading log file <%s> one line at a time...' % fname
2759 if kw['quiet']:
2759 if kw['quiet']:
2760 stdout_save = sys.stdout
2760 stdout_save = sys.stdout
2761 sys.stdout = StringIO.StringIO()
2761 sys.stdout = StringIO.StringIO()
2762 try:
2762 try:
2763 globs,locs = where[0:2]
2763 globs,locs = where[0:2]
2764 except:
2764 except:
2765 try:
2765 try:
2766 globs = locs = where[0]
2766 globs = locs = where[0]
2767 except:
2767 except:
2768 globs = locs = globals()
2768 globs = locs = globals()
2769 badblocks = []
2769 badblocks = []
2770
2770
2771 # we also need to identify indented blocks of code when replaying
2771 # we also need to identify indented blocks of code when replaying
2772 # logs and put them together before passing them to an exec
2772 # logs and put them together before passing them to an exec
2773 # statement. This takes a bit of regexp and look-ahead work in the
2773 # statement. This takes a bit of regexp and look-ahead work in the
2774 # file. It's easiest if we swallow the whole thing in memory
2774 # file. It's easiest if we swallow the whole thing in memory
2775 # first, and manually walk through the lines list moving the
2775 # first, and manually walk through the lines list moving the
2776 # counter ourselves.
2776 # counter ourselves.
2777 indent_re = re.compile('\s+\S')
2777 indent_re = re.compile('\s+\S')
2778 xfile = open(fname)
2778 xfile = open(fname)
2779 filelines = xfile.readlines()
2779 filelines = xfile.readlines()
2780 xfile.close()
2780 xfile.close()
2781 nlines = len(filelines)
2781 nlines = len(filelines)
2782 lnum = 0
2782 lnum = 0
2783 while lnum < nlines:
2783 while lnum < nlines:
2784 line = filelines[lnum]
2784 line = filelines[lnum]
2785 lnum += 1
2785 lnum += 1
2786 # don't re-insert logger status info into cache
2786 # don't re-insert logger status info into cache
2787 if line.startswith('#log#'):
2787 if line.startswith('#log#'):
2788 continue
2788 continue
2789 else:
2789 else:
2790 # build a block of code (maybe a single line) for execution
2790 # build a block of code (maybe a single line) for execution
2791 block = line
2791 block = line
2792 try:
2792 try:
2793 next = filelines[lnum] # lnum has already incremented
2793 next = filelines[lnum] # lnum has already incremented
2794 except:
2794 except:
2795 next = None
2795 next = None
2796 while next and indent_re.match(next):
2796 while next and indent_re.match(next):
2797 block += next
2797 block += next
2798 lnum += 1
2798 lnum += 1
2799 try:
2799 try:
2800 next = filelines[lnum]
2800 next = filelines[lnum]
2801 except:
2801 except:
2802 next = None
2802 next = None
2803 # now execute the block of one or more lines
2803 # now execute the block of one or more lines
2804 try:
2804 try:
2805 exec block in globs,locs
2805 exec block in globs,locs
2806 except SystemExit:
2806 except SystemExit:
2807 pass
2807 pass
2808 except:
2808 except:
2809 badblocks.append(block.rstrip())
2809 badblocks.append(block.rstrip())
2810 if kw['quiet']: # restore stdout
2810 if kw['quiet']: # restore stdout
2811 sys.stdout.close()
2811 sys.stdout.close()
2812 sys.stdout = stdout_save
2812 sys.stdout = stdout_save
2813 print 'Finished replaying log file <%s>' % fname
2813 print 'Finished replaying log file <%s>' % fname
2814 if badblocks:
2814 if badblocks:
2815 print >> sys.stderr, ('\nThe following lines/blocks in file '
2815 print >> sys.stderr, ('\nThe following lines/blocks in file '
2816 '<%s> reported errors:' % fname)
2816 '<%s> reported errors:' % fname)
2817
2817
2818 for badline in badblocks:
2818 for badline in badblocks:
2819 print >> sys.stderr, badline
2819 print >> sys.stderr, badline
2820 else: # regular file execution
2820 else: # regular file execution
2821 try:
2821 try:
2822 if sys.platform == 'win32' and sys.version_info < (2,5,1):
2822 if sys.platform == 'win32' and sys.version_info < (2,5,1):
2823 # Work around a bug in Python for Windows. The bug was
2823 # Work around a bug in Python for Windows. The bug was
2824 # fixed in in Python 2.5 r54159 and 54158, but that's still
2824 # fixed in in Python 2.5 r54159 and 54158, but that's still
2825 # SVN Python as of March/07. For details, see:
2825 # SVN Python as of March/07. For details, see:
2826 # http://projects.scipy.org/ipython/ipython/ticket/123
2826 # http://projects.scipy.org/ipython/ipython/ticket/123
2827 try:
2827 try:
2828 globs,locs = where[0:2]
2828 globs,locs = where[0:2]
2829 except:
2829 except:
2830 try:
2830 try:
2831 globs = locs = where[0]
2831 globs = locs = where[0]
2832 except:
2832 except:
2833 globs = locs = globals()
2833 globs = locs = globals()
2834 exec file(fname) in globs,locs
2834 exec file(fname) in globs,locs
2835 else:
2835 else:
2836 execfile(fname,*where)
2836 execfile(fname,*where)
2837 except SyntaxError:
2837 except SyntaxError:
2838 self.showsyntaxerror()
2838 self.showsyntaxerror()
2839 warn('Failure executing file: <%s>' % fname)
2839 warn('Failure executing file: <%s>' % fname)
2840 except SystemExit,status:
2840 except SystemExit,status:
2841 # Code that correctly sets the exit status flag to success (0)
2841 # Code that correctly sets the exit status flag to success (0)
2842 # shouldn't be bothered with a traceback. Note that a plain
2842 # shouldn't be bothered with a traceback. Note that a plain
2843 # sys.exit() does NOT set the message to 0 (it's empty) so that
2843 # sys.exit() does NOT set the message to 0 (it's empty) so that
2844 # will still get a traceback. Note that the structure of the
2844 # will still get a traceback. Note that the structure of the
2845 # SystemExit exception changed between Python 2.4 and 2.5, so
2845 # SystemExit exception changed between Python 2.4 and 2.5, so
2846 # the checks must be done in a version-dependent way.
2846 # the checks must be done in a version-dependent way.
2847 show = False
2847 show = False
2848
2848
2849 if sys.version_info[:2] > (2,5):
2849 if sys.version_info[:2] > (2,5):
2850 if status.message!=0 and not kw['exit_ignore']:
2850 if status.message!=0 and not kw['exit_ignore']:
2851 show = True
2851 show = True
2852 else:
2852 else:
2853 if status.code and not kw['exit_ignore']:
2853 if status.code and not kw['exit_ignore']:
2854 show = True
2854 show = True
2855 if show:
2855 if show:
2856 self.showtraceback()
2856 self.showtraceback()
2857 warn('Failure executing file: <%s>' % fname)
2857 warn('Failure executing file: <%s>' % fname)
2858 except:
2858 except:
2859 self.showtraceback()
2859 self.showtraceback()
2860 warn('Failure executing file: <%s>' % fname)
2860 warn('Failure executing file: <%s>' % fname)
2861
2861
2862 syspath_cleanup()
2862 syspath_cleanup()
2863
2863
2864 #************************* end of file <iplib.py> *****************************
2864 #************************* end of file <iplib.py> *****************************
1 NO CONTENT: file renamed from IPython/Itpl.py to IPython/deathrow/Itpl.py
NO CONTENT: file renamed from IPython/Itpl.py to IPython/deathrow/Itpl.py
@@ -1,2172 +1,2172 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """General purpose utilities.
2 """General purpose utilities.
3
3
4 This is a grab-bag of stuff I find useful in most programs I write. Some of
4 This is a grab-bag of stuff I find useful in most programs I write. Some of
5 these things are also convenient when working at the command line.
5 these things are also convenient when working at the command line.
6 """
6 """
7
7
8 #*****************************************************************************
8 #*****************************************************************************
9 # Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
9 # Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
10 #
10 #
11 # Distributed under the terms of the BSD License. The full license is in
11 # Distributed under the terms of the BSD License. The full license is in
12 # the file COPYING, distributed as part of this software.
12 # the file COPYING, distributed as part of this software.
13 #*****************************************************************************
13 #*****************************************************************************
14
14
15 #****************************************************************************
15 #****************************************************************************
16 # required modules from the Python standard library
16 # required modules from the Python standard library
17 import __main__
17 import __main__
18 import commands
18 import commands
19 try:
19 try:
20 import doctest
20 import doctest
21 except ImportError:
21 except ImportError:
22 pass
22 pass
23 import os
23 import os
24 import platform
24 import platform
25 import re
25 import re
26 import shlex
26 import shlex
27 import shutil
27 import shutil
28 import subprocess
28 import subprocess
29 import sys
29 import sys
30 import tempfile
30 import tempfile
31 import time
31 import time
32 import types
32 import types
33 import warnings
33 import warnings
34
34
35 # Curses and termios are Unix-only modules
35 # Curses and termios are Unix-only modules
36 try:
36 try:
37 import curses
37 import curses
38 # We need termios as well, so if its import happens to raise, we bail on
38 # We need termios as well, so if its import happens to raise, we bail on
39 # using curses altogether.
39 # using curses altogether.
40 import termios
40 import termios
41 except ImportError:
41 except ImportError:
42 USE_CURSES = False
42 USE_CURSES = False
43 else:
43 else:
44 # Curses on Solaris may not be complete, so we can't use it there
44 # Curses on Solaris may not be complete, so we can't use it there
45 USE_CURSES = hasattr(curses,'initscr')
45 USE_CURSES = hasattr(curses,'initscr')
46
46
47 # Other IPython utilities
47 # Other IPython utilities
48 import IPython
48 import IPython
49 from IPython.Itpl import Itpl,itpl,printpl
49 from IPython.external.Itpl import Itpl,itpl,printpl
50 from IPython import platutils
50 from IPython import platutils
51 from IPython.utils import DPyGetOpt
51 from IPython.utils import DPyGetOpt
52 from IPython.utils.generics import result_display
52 from IPython.utils.generics import result_display
53 from IPython.core import ipapi
53 from IPython.core import ipapi
54 from IPython.external.path import path
54 from IPython.external.path import path
55 if os.name == "nt":
55 if os.name == "nt":
56 from IPython.winconsole import get_console_size
56 from IPython.winconsole import get_console_size
57
57
58 try:
58 try:
59 set
59 set
60 except:
60 except:
61 from sets import Set as set
61 from sets import Set as set
62
62
63
63
64 #****************************************************************************
64 #****************************************************************************
65 # Exceptions
65 # Exceptions
66 class Error(Exception):
66 class Error(Exception):
67 """Base class for exceptions in this module."""
67 """Base class for exceptions in this module."""
68 pass
68 pass
69
69
70 #----------------------------------------------------------------------------
70 #----------------------------------------------------------------------------
71 class IOStream:
71 class IOStream:
72 def __init__(self,stream,fallback):
72 def __init__(self,stream,fallback):
73 if not hasattr(stream,'write') or not hasattr(stream,'flush'):
73 if not hasattr(stream,'write') or not hasattr(stream,'flush'):
74 stream = fallback
74 stream = fallback
75 self.stream = stream
75 self.stream = stream
76 self._swrite = stream.write
76 self._swrite = stream.write
77 self.flush = stream.flush
77 self.flush = stream.flush
78
78
79 def write(self,data):
79 def write(self,data):
80 try:
80 try:
81 self._swrite(data)
81 self._swrite(data)
82 except:
82 except:
83 try:
83 try:
84 # print handles some unicode issues which may trip a plain
84 # print handles some unicode issues which may trip a plain
85 # write() call. Attempt to emulate write() by using a
85 # write() call. Attempt to emulate write() by using a
86 # trailing comma
86 # trailing comma
87 print >> self.stream, data,
87 print >> self.stream, data,
88 except:
88 except:
89 # if we get here, something is seriously broken.
89 # if we get here, something is seriously broken.
90 print >> sys.stderr, \
90 print >> sys.stderr, \
91 'ERROR - failed to write data to stream:', self.stream
91 'ERROR - failed to write data to stream:', self.stream
92
92
93 def close(self):
93 def close(self):
94 pass
94 pass
95
95
96
96
97 class IOTerm:
97 class IOTerm:
98 """ Term holds the file or file-like objects for handling I/O operations.
98 """ Term holds the file or file-like objects for handling I/O operations.
99
99
100 These are normally just sys.stdin, sys.stdout and sys.stderr but for
100 These are normally just sys.stdin, sys.stdout and sys.stderr but for
101 Windows they can can replaced to allow editing the strings before they are
101 Windows they can can replaced to allow editing the strings before they are
102 displayed."""
102 displayed."""
103
103
104 # In the future, having IPython channel all its I/O operations through
104 # In the future, having IPython channel all its I/O operations through
105 # this class will make it easier to embed it into other environments which
105 # this class will make it easier to embed it into other environments which
106 # are not a normal terminal (such as a GUI-based shell)
106 # are not a normal terminal (such as a GUI-based shell)
107 def __init__(self,cin=None,cout=None,cerr=None):
107 def __init__(self,cin=None,cout=None,cerr=None):
108 self.cin = IOStream(cin,sys.stdin)
108 self.cin = IOStream(cin,sys.stdin)
109 self.cout = IOStream(cout,sys.stdout)
109 self.cout = IOStream(cout,sys.stdout)
110 self.cerr = IOStream(cerr,sys.stderr)
110 self.cerr = IOStream(cerr,sys.stderr)
111
111
112 # Global variable to be used for all I/O
112 # Global variable to be used for all I/O
113 Term = IOTerm()
113 Term = IOTerm()
114
114
115 import IPython.rlineimpl as readline
115 import IPython.rlineimpl as readline
116 # Remake Term to use the readline i/o facilities
116 # Remake Term to use the readline i/o facilities
117 if sys.platform == 'win32' and readline.have_readline:
117 if sys.platform == 'win32' and readline.have_readline:
118
118
119 Term = IOTerm(cout=readline._outputfile,cerr=readline._outputfile)
119 Term = IOTerm(cout=readline._outputfile,cerr=readline._outputfile)
120
120
121
121
122 #****************************************************************************
122 #****************************************************************************
123 # Generic warning/error printer, used by everything else
123 # Generic warning/error printer, used by everything else
124 def warn(msg,level=2,exit_val=1):
124 def warn(msg,level=2,exit_val=1):
125 """Standard warning printer. Gives formatting consistency.
125 """Standard warning printer. Gives formatting consistency.
126
126
127 Output is sent to Term.cerr (sys.stderr by default).
127 Output is sent to Term.cerr (sys.stderr by default).
128
128
129 Options:
129 Options:
130
130
131 -level(2): allows finer control:
131 -level(2): allows finer control:
132 0 -> Do nothing, dummy function.
132 0 -> Do nothing, dummy function.
133 1 -> Print message.
133 1 -> Print message.
134 2 -> Print 'WARNING:' + message. (Default level).
134 2 -> Print 'WARNING:' + message. (Default level).
135 3 -> Print 'ERROR:' + message.
135 3 -> Print 'ERROR:' + message.
136 4 -> Print 'FATAL ERROR:' + message and trigger a sys.exit(exit_val).
136 4 -> Print 'FATAL ERROR:' + message and trigger a sys.exit(exit_val).
137
137
138 -exit_val (1): exit value returned by sys.exit() for a level 4
138 -exit_val (1): exit value returned by sys.exit() for a level 4
139 warning. Ignored for all other levels."""
139 warning. Ignored for all other levels."""
140
140
141 if level>0:
141 if level>0:
142 header = ['','','WARNING: ','ERROR: ','FATAL ERROR: ']
142 header = ['','','WARNING: ','ERROR: ','FATAL ERROR: ']
143 print >> Term.cerr, '%s%s' % (header[level],msg)
143 print >> Term.cerr, '%s%s' % (header[level],msg)
144 if level == 4:
144 if level == 4:
145 print >> Term.cerr,'Exiting.\n'
145 print >> Term.cerr,'Exiting.\n'
146 sys.exit(exit_val)
146 sys.exit(exit_val)
147
147
148 def info(msg):
148 def info(msg):
149 """Equivalent to warn(msg,level=1)."""
149 """Equivalent to warn(msg,level=1)."""
150
150
151 warn(msg,level=1)
151 warn(msg,level=1)
152
152
153 def error(msg):
153 def error(msg):
154 """Equivalent to warn(msg,level=3)."""
154 """Equivalent to warn(msg,level=3)."""
155
155
156 warn(msg,level=3)
156 warn(msg,level=3)
157
157
158 def fatal(msg,exit_val=1):
158 def fatal(msg,exit_val=1):
159 """Equivalent to warn(msg,exit_val=exit_val,level=4)."""
159 """Equivalent to warn(msg,exit_val=exit_val,level=4)."""
160
160
161 warn(msg,exit_val=exit_val,level=4)
161 warn(msg,exit_val=exit_val,level=4)
162
162
163 #---------------------------------------------------------------------------
163 #---------------------------------------------------------------------------
164 # Debugging routines
164 # Debugging routines
165 #
165 #
166 def debugx(expr,pre_msg=''):
166 def debugx(expr,pre_msg=''):
167 """Print the value of an expression from the caller's frame.
167 """Print the value of an expression from the caller's frame.
168
168
169 Takes an expression, evaluates it in the caller's frame and prints both
169 Takes an expression, evaluates it in the caller's frame and prints both
170 the given expression and the resulting value (as well as a debug mark
170 the given expression and the resulting value (as well as a debug mark
171 indicating the name of the calling function. The input must be of a form
171 indicating the name of the calling function. The input must be of a form
172 suitable for eval().
172 suitable for eval().
173
173
174 An optional message can be passed, which will be prepended to the printed
174 An optional message can be passed, which will be prepended to the printed
175 expr->value pair."""
175 expr->value pair."""
176
176
177 cf = sys._getframe(1)
177 cf = sys._getframe(1)
178 print '[DBG:%s] %s%s -> %r' % (cf.f_code.co_name,pre_msg,expr,
178 print '[DBG:%s] %s%s -> %r' % (cf.f_code.co_name,pre_msg,expr,
179 eval(expr,cf.f_globals,cf.f_locals))
179 eval(expr,cf.f_globals,cf.f_locals))
180
180
181 # deactivate it by uncommenting the following line, which makes it a no-op
181 # deactivate it by uncommenting the following line, which makes it a no-op
182 #def debugx(expr,pre_msg=''): pass
182 #def debugx(expr,pre_msg=''): pass
183
183
184 #----------------------------------------------------------------------------
184 #----------------------------------------------------------------------------
185 StringTypes = types.StringTypes
185 StringTypes = types.StringTypes
186
186
187 # Basic timing functionality
187 # Basic timing functionality
188
188
189 # If possible (Unix), use the resource module instead of time.clock()
189 # If possible (Unix), use the resource module instead of time.clock()
190 try:
190 try:
191 import resource
191 import resource
192 def clocku():
192 def clocku():
193 """clocku() -> floating point number
193 """clocku() -> floating point number
194
194
195 Return the *USER* CPU time in seconds since the start of the process.
195 Return the *USER* CPU time in seconds since the start of the process.
196 This is done via a call to resource.getrusage, so it avoids the
196 This is done via a call to resource.getrusage, so it avoids the
197 wraparound problems in time.clock()."""
197 wraparound problems in time.clock()."""
198
198
199 return resource.getrusage(resource.RUSAGE_SELF)[0]
199 return resource.getrusage(resource.RUSAGE_SELF)[0]
200
200
201 def clocks():
201 def clocks():
202 """clocks() -> floating point number
202 """clocks() -> floating point number
203
203
204 Return the *SYSTEM* CPU time in seconds since the start of the process.
204 Return the *SYSTEM* CPU time in seconds since the start of the process.
205 This is done via a call to resource.getrusage, so it avoids the
205 This is done via a call to resource.getrusage, so it avoids the
206 wraparound problems in time.clock()."""
206 wraparound problems in time.clock()."""
207
207
208 return resource.getrusage(resource.RUSAGE_SELF)[1]
208 return resource.getrusage(resource.RUSAGE_SELF)[1]
209
209
210 def clock():
210 def clock():
211 """clock() -> floating point number
211 """clock() -> floating point number
212
212
213 Return the *TOTAL USER+SYSTEM* CPU time in seconds since the start of
213 Return the *TOTAL USER+SYSTEM* CPU time in seconds since the start of
214 the process. This is done via a call to resource.getrusage, so it
214 the process. This is done via a call to resource.getrusage, so it
215 avoids the wraparound problems in time.clock()."""
215 avoids the wraparound problems in time.clock()."""
216
216
217 u,s = resource.getrusage(resource.RUSAGE_SELF)[:2]
217 u,s = resource.getrusage(resource.RUSAGE_SELF)[:2]
218 return u+s
218 return u+s
219
219
220 def clock2():
220 def clock2():
221 """clock2() -> (t_user,t_system)
221 """clock2() -> (t_user,t_system)
222
222
223 Similar to clock(), but return a tuple of user/system times."""
223 Similar to clock(), but return a tuple of user/system times."""
224 return resource.getrusage(resource.RUSAGE_SELF)[:2]
224 return resource.getrusage(resource.RUSAGE_SELF)[:2]
225
225
226 except ImportError:
226 except ImportError:
227 # There is no distinction of user/system time under windows, so we just use
227 # There is no distinction of user/system time under windows, so we just use
228 # time.clock() for everything...
228 # time.clock() for everything...
229 clocku = clocks = clock = time.clock
229 clocku = clocks = clock = time.clock
230 def clock2():
230 def clock2():
231 """Under windows, system CPU time can't be measured.
231 """Under windows, system CPU time can't be measured.
232
232
233 This just returns clock() and zero."""
233 This just returns clock() and zero."""
234 return time.clock(),0.0
234 return time.clock(),0.0
235
235
236 def timings_out(reps,func,*args,**kw):
236 def timings_out(reps,func,*args,**kw):
237 """timings_out(reps,func,*args,**kw) -> (t_total,t_per_call,output)
237 """timings_out(reps,func,*args,**kw) -> (t_total,t_per_call,output)
238
238
239 Execute a function reps times, return a tuple with the elapsed total
239 Execute a function reps times, return a tuple with the elapsed total
240 CPU time in seconds, the time per call and the function's output.
240 CPU time in seconds, the time per call and the function's output.
241
241
242 Under Unix, the return value is the sum of user+system time consumed by
242 Under Unix, the return value is the sum of user+system time consumed by
243 the process, computed via the resource module. This prevents problems
243 the process, computed via the resource module. This prevents problems
244 related to the wraparound effect which the time.clock() function has.
244 related to the wraparound effect which the time.clock() function has.
245
245
246 Under Windows the return value is in wall clock seconds. See the
246 Under Windows the return value is in wall clock seconds. See the
247 documentation for the time module for more details."""
247 documentation for the time module for more details."""
248
248
249 reps = int(reps)
249 reps = int(reps)
250 assert reps >=1, 'reps must be >= 1'
250 assert reps >=1, 'reps must be >= 1'
251 if reps==1:
251 if reps==1:
252 start = clock()
252 start = clock()
253 out = func(*args,**kw)
253 out = func(*args,**kw)
254 tot_time = clock()-start
254 tot_time = clock()-start
255 else:
255 else:
256 rng = xrange(reps-1) # the last time is executed separately to store output
256 rng = xrange(reps-1) # the last time is executed separately to store output
257 start = clock()
257 start = clock()
258 for dummy in rng: func(*args,**kw)
258 for dummy in rng: func(*args,**kw)
259 out = func(*args,**kw) # one last time
259 out = func(*args,**kw) # one last time
260 tot_time = clock()-start
260 tot_time = clock()-start
261 av_time = tot_time / reps
261 av_time = tot_time / reps
262 return tot_time,av_time,out
262 return tot_time,av_time,out
263
263
264 def timings(reps,func,*args,**kw):
264 def timings(reps,func,*args,**kw):
265 """timings(reps,func,*args,**kw) -> (t_total,t_per_call)
265 """timings(reps,func,*args,**kw) -> (t_total,t_per_call)
266
266
267 Execute a function reps times, return a tuple with the elapsed total CPU
267 Execute a function reps times, return a tuple with the elapsed total CPU
268 time in seconds and the time per call. These are just the first two values
268 time in seconds and the time per call. These are just the first two values
269 in timings_out()."""
269 in timings_out()."""
270
270
271 return timings_out(reps,func,*args,**kw)[0:2]
271 return timings_out(reps,func,*args,**kw)[0:2]
272
272
273 def timing(func,*args,**kw):
273 def timing(func,*args,**kw):
274 """timing(func,*args,**kw) -> t_total
274 """timing(func,*args,**kw) -> t_total
275
275
276 Execute a function once, return the elapsed total CPU time in
276 Execute a function once, return the elapsed total CPU time in
277 seconds. This is just the first value in timings_out()."""
277 seconds. This is just the first value in timings_out()."""
278
278
279 return timings_out(1,func,*args,**kw)[0]
279 return timings_out(1,func,*args,**kw)[0]
280
280
281 #****************************************************************************
281 #****************************************************************************
282 # file and system
282 # file and system
283
283
284 def arg_split(s,posix=False):
284 def arg_split(s,posix=False):
285 """Split a command line's arguments in a shell-like manner.
285 """Split a command line's arguments in a shell-like manner.
286
286
287 This is a modified version of the standard library's shlex.split()
287 This is a modified version of the standard library's shlex.split()
288 function, but with a default of posix=False for splitting, so that quotes
288 function, but with a default of posix=False for splitting, so that quotes
289 in inputs are respected."""
289 in inputs are respected."""
290
290
291 # XXX - there may be unicode-related problems here!!! I'm not sure that
291 # XXX - there may be unicode-related problems here!!! I'm not sure that
292 # shlex is truly unicode-safe, so it might be necessary to do
292 # shlex is truly unicode-safe, so it might be necessary to do
293 #
293 #
294 # s = s.encode(sys.stdin.encoding)
294 # s = s.encode(sys.stdin.encoding)
295 #
295 #
296 # first, to ensure that shlex gets a normal string. Input from anyone who
296 # first, to ensure that shlex gets a normal string. Input from anyone who
297 # knows more about unicode and shlex than I would be good to have here...
297 # knows more about unicode and shlex than I would be good to have here...
298 lex = shlex.shlex(s, posix=posix)
298 lex = shlex.shlex(s, posix=posix)
299 lex.whitespace_split = True
299 lex.whitespace_split = True
300 return list(lex)
300 return list(lex)
301
301
302 def system(cmd,verbose=0,debug=0,header=''):
302 def system(cmd,verbose=0,debug=0,header=''):
303 """Execute a system command, return its exit status.
303 """Execute a system command, return its exit status.
304
304
305 Options:
305 Options:
306
306
307 - verbose (0): print the command to be executed.
307 - verbose (0): print the command to be executed.
308
308
309 - debug (0): only print, do not actually execute.
309 - debug (0): only print, do not actually execute.
310
310
311 - header (''): Header to print on screen prior to the executed command (it
311 - header (''): Header to print on screen prior to the executed command (it
312 is only prepended to the command, no newlines are added).
312 is only prepended to the command, no newlines are added).
313
313
314 Note: a stateful version of this function is available through the
314 Note: a stateful version of this function is available through the
315 SystemExec class."""
315 SystemExec class."""
316
316
317 stat = 0
317 stat = 0
318 if verbose or debug: print header+cmd
318 if verbose or debug: print header+cmd
319 sys.stdout.flush()
319 sys.stdout.flush()
320 if not debug: stat = os.system(cmd)
320 if not debug: stat = os.system(cmd)
321 return stat
321 return stat
322
322
323 def abbrev_cwd():
323 def abbrev_cwd():
324 """ Return abbreviated version of cwd, e.g. d:mydir """
324 """ Return abbreviated version of cwd, e.g. d:mydir """
325 cwd = os.getcwd().replace('\\','/')
325 cwd = os.getcwd().replace('\\','/')
326 drivepart = ''
326 drivepart = ''
327 tail = cwd
327 tail = cwd
328 if sys.platform == 'win32':
328 if sys.platform == 'win32':
329 if len(cwd) < 4:
329 if len(cwd) < 4:
330 return cwd
330 return cwd
331 drivepart,tail = os.path.splitdrive(cwd)
331 drivepart,tail = os.path.splitdrive(cwd)
332
332
333
333
334 parts = tail.split('/')
334 parts = tail.split('/')
335 if len(parts) > 2:
335 if len(parts) > 2:
336 tail = '/'.join(parts[-2:])
336 tail = '/'.join(parts[-2:])
337
337
338 return (drivepart + (
338 return (drivepart + (
339 cwd == '/' and '/' or tail))
339 cwd == '/' and '/' or tail))
340
340
341
341
342 # This function is used by ipython in a lot of places to make system calls.
342 # This function is used by ipython in a lot of places to make system calls.
343 # We need it to be slightly different under win32, due to the vagaries of
343 # We need it to be slightly different under win32, due to the vagaries of
344 # 'network shares'. A win32 override is below.
344 # 'network shares'. A win32 override is below.
345
345
346 def shell(cmd,verbose=0,debug=0,header=''):
346 def shell(cmd,verbose=0,debug=0,header=''):
347 """Execute a command in the system shell, always return None.
347 """Execute a command in the system shell, always return None.
348
348
349 Options:
349 Options:
350
350
351 - verbose (0): print the command to be executed.
351 - verbose (0): print the command to be executed.
352
352
353 - debug (0): only print, do not actually execute.
353 - debug (0): only print, do not actually execute.
354
354
355 - header (''): Header to print on screen prior to the executed command (it
355 - header (''): Header to print on screen prior to the executed command (it
356 is only prepended to the command, no newlines are added).
356 is only prepended to the command, no newlines are added).
357
357
358 Note: this is similar to genutils.system(), but it returns None so it can
358 Note: this is similar to genutils.system(), but it returns None so it can
359 be conveniently used in interactive loops without getting the return value
359 be conveniently used in interactive loops without getting the return value
360 (typically 0) printed many times."""
360 (typically 0) printed many times."""
361
361
362 stat = 0
362 stat = 0
363 if verbose or debug: print header+cmd
363 if verbose or debug: print header+cmd
364 # flush stdout so we don't mangle python's buffering
364 # flush stdout so we don't mangle python's buffering
365 sys.stdout.flush()
365 sys.stdout.flush()
366
366
367 if not debug:
367 if not debug:
368 platutils.set_term_title("IPy " + cmd)
368 platutils.set_term_title("IPy " + cmd)
369 os.system(cmd)
369 os.system(cmd)
370 platutils.set_term_title("IPy " + abbrev_cwd())
370 platutils.set_term_title("IPy " + abbrev_cwd())
371
371
372 # override shell() for win32 to deal with network shares
372 # override shell() for win32 to deal with network shares
373 if os.name in ('nt','dos'):
373 if os.name in ('nt','dos'):
374
374
375 shell_ori = shell
375 shell_ori = shell
376
376
377 def shell(cmd,verbose=0,debug=0,header=''):
377 def shell(cmd,verbose=0,debug=0,header=''):
378 if os.getcwd().startswith(r"\\"):
378 if os.getcwd().startswith(r"\\"):
379 path = os.getcwd()
379 path = os.getcwd()
380 # change to c drive (cannot be on UNC-share when issuing os.system,
380 # change to c drive (cannot be on UNC-share when issuing os.system,
381 # as cmd.exe cannot handle UNC addresses)
381 # as cmd.exe cannot handle UNC addresses)
382 os.chdir("c:")
382 os.chdir("c:")
383 # issue pushd to the UNC-share and then run the command
383 # issue pushd to the UNC-share and then run the command
384 try:
384 try:
385 shell_ori('"pushd %s&&"'%path+cmd,verbose,debug,header)
385 shell_ori('"pushd %s&&"'%path+cmd,verbose,debug,header)
386 finally:
386 finally:
387 os.chdir(path)
387 os.chdir(path)
388 else:
388 else:
389 shell_ori(cmd,verbose,debug,header)
389 shell_ori(cmd,verbose,debug,header)
390
390
391 shell.__doc__ = shell_ori.__doc__
391 shell.__doc__ = shell_ori.__doc__
392
392
393 def getoutput(cmd,verbose=0,debug=0,header='',split=0):
393 def getoutput(cmd,verbose=0,debug=0,header='',split=0):
394 """Dummy substitute for perl's backquotes.
394 """Dummy substitute for perl's backquotes.
395
395
396 Executes a command and returns the output.
396 Executes a command and returns the output.
397
397
398 Accepts the same arguments as system(), plus:
398 Accepts the same arguments as system(), plus:
399
399
400 - split(0): if true, the output is returned as a list split on newlines.
400 - split(0): if true, the output is returned as a list split on newlines.
401
401
402 Note: a stateful version of this function is available through the
402 Note: a stateful version of this function is available through the
403 SystemExec class.
403 SystemExec class.
404
404
405 This is pretty much deprecated and rarely used,
405 This is pretty much deprecated and rarely used,
406 genutils.getoutputerror may be what you need.
406 genutils.getoutputerror may be what you need.
407
407
408 """
408 """
409
409
410 if verbose or debug: print header+cmd
410 if verbose or debug: print header+cmd
411 if not debug:
411 if not debug:
412 output = os.popen(cmd).read()
412 output = os.popen(cmd).read()
413 # stipping last \n is here for backwards compat.
413 # stipping last \n is here for backwards compat.
414 if output.endswith('\n'):
414 if output.endswith('\n'):
415 output = output[:-1]
415 output = output[:-1]
416 if split:
416 if split:
417 return output.split('\n')
417 return output.split('\n')
418 else:
418 else:
419 return output
419 return output
420
420
421 def getoutputerror(cmd,verbose=0,debug=0,header='',split=0):
421 def getoutputerror(cmd,verbose=0,debug=0,header='',split=0):
422 """Return (standard output,standard error) of executing cmd in a shell.
422 """Return (standard output,standard error) of executing cmd in a shell.
423
423
424 Accepts the same arguments as system(), plus:
424 Accepts the same arguments as system(), plus:
425
425
426 - split(0): if true, each of stdout/err is returned as a list split on
426 - split(0): if true, each of stdout/err is returned as a list split on
427 newlines.
427 newlines.
428
428
429 Note: a stateful version of this function is available through the
429 Note: a stateful version of this function is available through the
430 SystemExec class."""
430 SystemExec class."""
431
431
432 if verbose or debug: print header+cmd
432 if verbose or debug: print header+cmd
433 if not cmd:
433 if not cmd:
434 if split:
434 if split:
435 return [],[]
435 return [],[]
436 else:
436 else:
437 return '',''
437 return '',''
438 if not debug:
438 if not debug:
439 pin,pout,perr = os.popen3(cmd)
439 pin,pout,perr = os.popen3(cmd)
440 tout = pout.read().rstrip()
440 tout = pout.read().rstrip()
441 terr = perr.read().rstrip()
441 terr = perr.read().rstrip()
442 pin.close()
442 pin.close()
443 pout.close()
443 pout.close()
444 perr.close()
444 perr.close()
445 if split:
445 if split:
446 return tout.split('\n'),terr.split('\n')
446 return tout.split('\n'),terr.split('\n')
447 else:
447 else:
448 return tout,terr
448 return tout,terr
449
449
450 # for compatibility with older naming conventions
450 # for compatibility with older naming conventions
451 xsys = system
451 xsys = system
452 bq = getoutput
452 bq = getoutput
453
453
454 class SystemExec:
454 class SystemExec:
455 """Access the system and getoutput functions through a stateful interface.
455 """Access the system and getoutput functions through a stateful interface.
456
456
457 Note: here we refer to the system and getoutput functions from this
457 Note: here we refer to the system and getoutput functions from this
458 library, not the ones from the standard python library.
458 library, not the ones from the standard python library.
459
459
460 This class offers the system and getoutput functions as methods, but the
460 This class offers the system and getoutput functions as methods, but the
461 verbose, debug and header parameters can be set for the instance (at
461 verbose, debug and header parameters can be set for the instance (at
462 creation time or later) so that they don't need to be specified on each
462 creation time or later) so that they don't need to be specified on each
463 call.
463 call.
464
464
465 For efficiency reasons, there's no way to override the parameters on a
465 For efficiency reasons, there's no way to override the parameters on a
466 per-call basis other than by setting instance attributes. If you need
466 per-call basis other than by setting instance attributes. If you need
467 local overrides, it's best to directly call system() or getoutput().
467 local overrides, it's best to directly call system() or getoutput().
468
468
469 The following names are provided as alternate options:
469 The following names are provided as alternate options:
470 - xsys: alias to system
470 - xsys: alias to system
471 - bq: alias to getoutput
471 - bq: alias to getoutput
472
472
473 An instance can then be created as:
473 An instance can then be created as:
474 >>> sysexec = SystemExec(verbose=1,debug=0,header='Calling: ')
474 >>> sysexec = SystemExec(verbose=1,debug=0,header='Calling: ')
475 """
475 """
476
476
477 def __init__(self,verbose=0,debug=0,header='',split=0):
477 def __init__(self,verbose=0,debug=0,header='',split=0):
478 """Specify the instance's values for verbose, debug and header."""
478 """Specify the instance's values for verbose, debug and header."""
479 setattr_list(self,'verbose debug header split')
479 setattr_list(self,'verbose debug header split')
480
480
481 def system(self,cmd):
481 def system(self,cmd):
482 """Stateful interface to system(), with the same keyword parameters."""
482 """Stateful interface to system(), with the same keyword parameters."""
483
483
484 system(cmd,self.verbose,self.debug,self.header)
484 system(cmd,self.verbose,self.debug,self.header)
485
485
486 def shell(self,cmd):
486 def shell(self,cmd):
487 """Stateful interface to shell(), with the same keyword parameters."""
487 """Stateful interface to shell(), with the same keyword parameters."""
488
488
489 shell(cmd,self.verbose,self.debug,self.header)
489 shell(cmd,self.verbose,self.debug,self.header)
490
490
491 xsys = system # alias
491 xsys = system # alias
492
492
493 def getoutput(self,cmd):
493 def getoutput(self,cmd):
494 """Stateful interface to getoutput()."""
494 """Stateful interface to getoutput()."""
495
495
496 return getoutput(cmd,self.verbose,self.debug,self.header,self.split)
496 return getoutput(cmd,self.verbose,self.debug,self.header,self.split)
497
497
498 def getoutputerror(self,cmd):
498 def getoutputerror(self,cmd):
499 """Stateful interface to getoutputerror()."""
499 """Stateful interface to getoutputerror()."""
500
500
501 return getoutputerror(cmd,self.verbose,self.debug,self.header,self.split)
501 return getoutputerror(cmd,self.verbose,self.debug,self.header,self.split)
502
502
503 bq = getoutput # alias
503 bq = getoutput # alias
504
504
505 #-----------------------------------------------------------------------------
505 #-----------------------------------------------------------------------------
506 def mutex_opts(dict,ex_op):
506 def mutex_opts(dict,ex_op):
507 """Check for presence of mutually exclusive keys in a dict.
507 """Check for presence of mutually exclusive keys in a dict.
508
508
509 Call: mutex_opts(dict,[[op1a,op1b],[op2a,op2b]...]"""
509 Call: mutex_opts(dict,[[op1a,op1b],[op2a,op2b]...]"""
510 for op1,op2 in ex_op:
510 for op1,op2 in ex_op:
511 if op1 in dict and op2 in dict:
511 if op1 in dict and op2 in dict:
512 raise ValueError,'\n*** ERROR in Arguments *** '\
512 raise ValueError,'\n*** ERROR in Arguments *** '\
513 'Options '+op1+' and '+op2+' are mutually exclusive.'
513 'Options '+op1+' and '+op2+' are mutually exclusive.'
514
514
515 #-----------------------------------------------------------------------------
515 #-----------------------------------------------------------------------------
516 def get_py_filename(name):
516 def get_py_filename(name):
517 """Return a valid python filename in the current directory.
517 """Return a valid python filename in the current directory.
518
518
519 If the given name is not a file, it adds '.py' and searches again.
519 If the given name is not a file, it adds '.py' and searches again.
520 Raises IOError with an informative message if the file isn't found."""
520 Raises IOError with an informative message if the file isn't found."""
521
521
522 name = os.path.expanduser(name)
522 name = os.path.expanduser(name)
523 if not os.path.isfile(name) and not name.endswith('.py'):
523 if not os.path.isfile(name) and not name.endswith('.py'):
524 name += '.py'
524 name += '.py'
525 if os.path.isfile(name):
525 if os.path.isfile(name):
526 return name
526 return name
527 else:
527 else:
528 raise IOError,'File `%s` not found.' % name
528 raise IOError,'File `%s` not found.' % name
529
529
530 #-----------------------------------------------------------------------------
530 #-----------------------------------------------------------------------------
531 def filefind(fname,alt_dirs = None):
531 def filefind(fname,alt_dirs = None):
532 """Return the given filename either in the current directory, if it
532 """Return the given filename either in the current directory, if it
533 exists, or in a specified list of directories.
533 exists, or in a specified list of directories.
534
534
535 ~ expansion is done on all file and directory names.
535 ~ expansion is done on all file and directory names.
536
536
537 Upon an unsuccessful search, raise an IOError exception."""
537 Upon an unsuccessful search, raise an IOError exception."""
538
538
539 if alt_dirs is None:
539 if alt_dirs is None:
540 try:
540 try:
541 alt_dirs = get_home_dir()
541 alt_dirs = get_home_dir()
542 except HomeDirError:
542 except HomeDirError:
543 alt_dirs = os.getcwd()
543 alt_dirs = os.getcwd()
544 search = [fname] + list_strings(alt_dirs)
544 search = [fname] + list_strings(alt_dirs)
545 search = map(os.path.expanduser,search)
545 search = map(os.path.expanduser,search)
546 #print 'search list for',fname,'list:',search # dbg
546 #print 'search list for',fname,'list:',search # dbg
547 fname = search[0]
547 fname = search[0]
548 if os.path.isfile(fname):
548 if os.path.isfile(fname):
549 return fname
549 return fname
550 for direc in search[1:]:
550 for direc in search[1:]:
551 testname = os.path.join(direc,fname)
551 testname = os.path.join(direc,fname)
552 #print 'testname',testname # dbg
552 #print 'testname',testname # dbg
553 if os.path.isfile(testname):
553 if os.path.isfile(testname):
554 return testname
554 return testname
555 raise IOError,'File' + `fname` + \
555 raise IOError,'File' + `fname` + \
556 ' not found in current or supplied directories:' + `alt_dirs`
556 ' not found in current or supplied directories:' + `alt_dirs`
557
557
558 #----------------------------------------------------------------------------
558 #----------------------------------------------------------------------------
559 def file_read(filename):
559 def file_read(filename):
560 """Read a file and close it. Returns the file source."""
560 """Read a file and close it. Returns the file source."""
561 fobj = open(filename,'r');
561 fobj = open(filename,'r');
562 source = fobj.read();
562 source = fobj.read();
563 fobj.close()
563 fobj.close()
564 return source
564 return source
565
565
566 def file_readlines(filename):
566 def file_readlines(filename):
567 """Read a file and close it. Returns the file source using readlines()."""
567 """Read a file and close it. Returns the file source using readlines()."""
568 fobj = open(filename,'r');
568 fobj = open(filename,'r');
569 lines = fobj.readlines();
569 lines = fobj.readlines();
570 fobj.close()
570 fobj.close()
571 return lines
571 return lines
572
572
573 #----------------------------------------------------------------------------
573 #----------------------------------------------------------------------------
574 def target_outdated(target,deps):
574 def target_outdated(target,deps):
575 """Determine whether a target is out of date.
575 """Determine whether a target is out of date.
576
576
577 target_outdated(target,deps) -> 1/0
577 target_outdated(target,deps) -> 1/0
578
578
579 deps: list of filenames which MUST exist.
579 deps: list of filenames which MUST exist.
580 target: single filename which may or may not exist.
580 target: single filename which may or may not exist.
581
581
582 If target doesn't exist or is older than any file listed in deps, return
582 If target doesn't exist or is older than any file listed in deps, return
583 true, otherwise return false.
583 true, otherwise return false.
584 """
584 """
585 try:
585 try:
586 target_time = os.path.getmtime(target)
586 target_time = os.path.getmtime(target)
587 except os.error:
587 except os.error:
588 return 1
588 return 1
589 for dep in deps:
589 for dep in deps:
590 dep_time = os.path.getmtime(dep)
590 dep_time = os.path.getmtime(dep)
591 if dep_time > target_time:
591 if dep_time > target_time:
592 #print "For target",target,"Dep failed:",dep # dbg
592 #print "For target",target,"Dep failed:",dep # dbg
593 #print "times (dep,tar):",dep_time,target_time # dbg
593 #print "times (dep,tar):",dep_time,target_time # dbg
594 return 1
594 return 1
595 return 0
595 return 0
596
596
597 #-----------------------------------------------------------------------------
597 #-----------------------------------------------------------------------------
598 def target_update(target,deps,cmd):
598 def target_update(target,deps,cmd):
599 """Update a target with a given command given a list of dependencies.
599 """Update a target with a given command given a list of dependencies.
600
600
601 target_update(target,deps,cmd) -> runs cmd if target is outdated.
601 target_update(target,deps,cmd) -> runs cmd if target is outdated.
602
602
603 This is just a wrapper around target_outdated() which calls the given
603 This is just a wrapper around target_outdated() which calls the given
604 command if target is outdated."""
604 command if target is outdated."""
605
605
606 if target_outdated(target,deps):
606 if target_outdated(target,deps):
607 xsys(cmd)
607 xsys(cmd)
608
608
609 #----------------------------------------------------------------------------
609 #----------------------------------------------------------------------------
610 def unquote_ends(istr):
610 def unquote_ends(istr):
611 """Remove a single pair of quotes from the endpoints of a string."""
611 """Remove a single pair of quotes from the endpoints of a string."""
612
612
613 if not istr:
613 if not istr:
614 return istr
614 return istr
615 if (istr[0]=="'" and istr[-1]=="'") or \
615 if (istr[0]=="'" and istr[-1]=="'") or \
616 (istr[0]=='"' and istr[-1]=='"'):
616 (istr[0]=='"' and istr[-1]=='"'):
617 return istr[1:-1]
617 return istr[1:-1]
618 else:
618 else:
619 return istr
619 return istr
620
620
621 #----------------------------------------------------------------------------
621 #----------------------------------------------------------------------------
622 def process_cmdline(argv,names=[],defaults={},usage=''):
622 def process_cmdline(argv,names=[],defaults={},usage=''):
623 """ Process command-line options and arguments.
623 """ Process command-line options and arguments.
624
624
625 Arguments:
625 Arguments:
626
626
627 - argv: list of arguments, typically sys.argv.
627 - argv: list of arguments, typically sys.argv.
628
628
629 - names: list of option names. See DPyGetOpt docs for details on options
629 - names: list of option names. See DPyGetOpt docs for details on options
630 syntax.
630 syntax.
631
631
632 - defaults: dict of default values.
632 - defaults: dict of default values.
633
633
634 - usage: optional usage notice to print if a wrong argument is passed.
634 - usage: optional usage notice to print if a wrong argument is passed.
635
635
636 Return a dict of options and a list of free arguments."""
636 Return a dict of options and a list of free arguments."""
637
637
638 getopt = DPyGetOpt.DPyGetOpt()
638 getopt = DPyGetOpt.DPyGetOpt()
639 getopt.setIgnoreCase(0)
639 getopt.setIgnoreCase(0)
640 getopt.parseConfiguration(names)
640 getopt.parseConfiguration(names)
641
641
642 try:
642 try:
643 getopt.processArguments(argv)
643 getopt.processArguments(argv)
644 except DPyGetOpt.ArgumentError, exc:
644 except DPyGetOpt.ArgumentError, exc:
645 print usage
645 print usage
646 warn('"%s"' % exc,level=4)
646 warn('"%s"' % exc,level=4)
647
647
648 defaults.update(getopt.optionValues)
648 defaults.update(getopt.optionValues)
649 args = getopt.freeValues
649 args = getopt.freeValues
650
650
651 return defaults,args
651 return defaults,args
652
652
653 #----------------------------------------------------------------------------
653 #----------------------------------------------------------------------------
654 def optstr2types(ostr):
654 def optstr2types(ostr):
655 """Convert a string of option names to a dict of type mappings.
655 """Convert a string of option names to a dict of type mappings.
656
656
657 optstr2types(str) -> {None:'string_opts',int:'int_opts',float:'float_opts'}
657 optstr2types(str) -> {None:'string_opts',int:'int_opts',float:'float_opts'}
658
658
659 This is used to get the types of all the options in a string formatted
659 This is used to get the types of all the options in a string formatted
660 with the conventions of DPyGetOpt. The 'type' None is used for options
660 with the conventions of DPyGetOpt. The 'type' None is used for options
661 which are strings (they need no further conversion). This function's main
661 which are strings (they need no further conversion). This function's main
662 use is to get a typemap for use with read_dict().
662 use is to get a typemap for use with read_dict().
663 """
663 """
664
664
665 typeconv = {None:'',int:'',float:''}
665 typeconv = {None:'',int:'',float:''}
666 typemap = {'s':None,'i':int,'f':float}
666 typemap = {'s':None,'i':int,'f':float}
667 opt_re = re.compile(r'([\w]*)([^:=]*:?=?)([sif]?)')
667 opt_re = re.compile(r'([\w]*)([^:=]*:?=?)([sif]?)')
668
668
669 for w in ostr.split():
669 for w in ostr.split():
670 oname,alias,otype = opt_re.match(w).groups()
670 oname,alias,otype = opt_re.match(w).groups()
671 if otype == '' or alias == '!': # simple switches are integers too
671 if otype == '' or alias == '!': # simple switches are integers too
672 otype = 'i'
672 otype = 'i'
673 typeconv[typemap[otype]] += oname + ' '
673 typeconv[typemap[otype]] += oname + ' '
674 return typeconv
674 return typeconv
675
675
676 #----------------------------------------------------------------------------
676 #----------------------------------------------------------------------------
677 def read_dict(filename,type_conv=None,**opt):
677 def read_dict(filename,type_conv=None,**opt):
678 r"""Read a dictionary of key=value pairs from an input file, optionally
678 r"""Read a dictionary of key=value pairs from an input file, optionally
679 performing conversions on the resulting values.
679 performing conversions on the resulting values.
680
680
681 read_dict(filename,type_conv,**opt) -> dict
681 read_dict(filename,type_conv,**opt) -> dict
682
682
683 Only one value per line is accepted, the format should be
683 Only one value per line is accepted, the format should be
684 # optional comments are ignored
684 # optional comments are ignored
685 key value\n
685 key value\n
686
686
687 Args:
687 Args:
688
688
689 - type_conv: A dictionary specifying which keys need to be converted to
689 - type_conv: A dictionary specifying which keys need to be converted to
690 which types. By default all keys are read as strings. This dictionary
690 which types. By default all keys are read as strings. This dictionary
691 should have as its keys valid conversion functions for strings
691 should have as its keys valid conversion functions for strings
692 (int,long,float,complex, or your own). The value for each key
692 (int,long,float,complex, or your own). The value for each key
693 (converter) should be a whitespace separated string containing the names
693 (converter) should be a whitespace separated string containing the names
694 of all the entries in the file to be converted using that function. For
694 of all the entries in the file to be converted using that function. For
695 keys to be left alone, use None as the conversion function (only needed
695 keys to be left alone, use None as the conversion function (only needed
696 with purge=1, see below).
696 with purge=1, see below).
697
697
698 - opt: dictionary with extra options as below (default in parens)
698 - opt: dictionary with extra options as below (default in parens)
699
699
700 purge(0): if set to 1, all keys *not* listed in type_conv are purged out
700 purge(0): if set to 1, all keys *not* listed in type_conv are purged out
701 of the dictionary to be returned. If purge is going to be used, the
701 of the dictionary to be returned. If purge is going to be used, the
702 set of keys to be left as strings also has to be explicitly specified
702 set of keys to be left as strings also has to be explicitly specified
703 using the (non-existent) conversion function None.
703 using the (non-existent) conversion function None.
704
704
705 fs(None): field separator. This is the key/value separator to be used
705 fs(None): field separator. This is the key/value separator to be used
706 when parsing the file. The None default means any whitespace [behavior
706 when parsing the file. The None default means any whitespace [behavior
707 of string.split()].
707 of string.split()].
708
708
709 strip(0): if 1, strip string values of leading/trailinig whitespace.
709 strip(0): if 1, strip string values of leading/trailinig whitespace.
710
710
711 warn(1): warning level if requested keys are not found in file.
711 warn(1): warning level if requested keys are not found in file.
712 - 0: silently ignore.
712 - 0: silently ignore.
713 - 1: inform but proceed.
713 - 1: inform but proceed.
714 - 2: raise KeyError exception.
714 - 2: raise KeyError exception.
715
715
716 no_empty(0): if 1, remove keys with whitespace strings as a value.
716 no_empty(0): if 1, remove keys with whitespace strings as a value.
717
717
718 unique([]): list of keys (or space separated string) which can't be
718 unique([]): list of keys (or space separated string) which can't be
719 repeated. If one such key is found in the file, each new instance
719 repeated. If one such key is found in the file, each new instance
720 overwrites the previous one. For keys not listed here, the behavior is
720 overwrites the previous one. For keys not listed here, the behavior is
721 to make a list of all appearances.
721 to make a list of all appearances.
722
722
723 Example:
723 Example:
724
724
725 If the input file test.ini contains (we put it in a string to keep the test
725 If the input file test.ini contains (we put it in a string to keep the test
726 self-contained):
726 self-contained):
727
727
728 >>> test_ini = '''\
728 >>> test_ini = '''\
729 ... i 3
729 ... i 3
730 ... x 4.5
730 ... x 4.5
731 ... y 5.5
731 ... y 5.5
732 ... s hi ho'''
732 ... s hi ho'''
733
733
734 Then we can use it as follows:
734 Then we can use it as follows:
735 >>> type_conv={int:'i',float:'x',None:'s'}
735 >>> type_conv={int:'i',float:'x',None:'s'}
736
736
737 >>> d = read_dict(test_ini)
737 >>> d = read_dict(test_ini)
738
738
739 >>> sorted(d.items())
739 >>> sorted(d.items())
740 [('i', '3'), ('s', 'hi ho'), ('x', '4.5'), ('y', '5.5')]
740 [('i', '3'), ('s', 'hi ho'), ('x', '4.5'), ('y', '5.5')]
741
741
742 >>> d = read_dict(test_ini,type_conv)
742 >>> d = read_dict(test_ini,type_conv)
743
743
744 >>> sorted(d.items())
744 >>> sorted(d.items())
745 [('i', 3), ('s', 'hi ho'), ('x', 4.5), ('y', '5.5')]
745 [('i', 3), ('s', 'hi ho'), ('x', 4.5), ('y', '5.5')]
746
746
747 >>> d = read_dict(test_ini,type_conv,purge=True)
747 >>> d = read_dict(test_ini,type_conv,purge=True)
748
748
749 >>> sorted(d.items())
749 >>> sorted(d.items())
750 [('i', 3), ('s', 'hi ho'), ('x', 4.5)]
750 [('i', 3), ('s', 'hi ho'), ('x', 4.5)]
751 """
751 """
752
752
753 # starting config
753 # starting config
754 opt.setdefault('purge',0)
754 opt.setdefault('purge',0)
755 opt.setdefault('fs',None) # field sep defaults to any whitespace
755 opt.setdefault('fs',None) # field sep defaults to any whitespace
756 opt.setdefault('strip',0)
756 opt.setdefault('strip',0)
757 opt.setdefault('warn',1)
757 opt.setdefault('warn',1)
758 opt.setdefault('no_empty',0)
758 opt.setdefault('no_empty',0)
759 opt.setdefault('unique','')
759 opt.setdefault('unique','')
760 if type(opt['unique']) in StringTypes:
760 if type(opt['unique']) in StringTypes:
761 unique_keys = qw(opt['unique'])
761 unique_keys = qw(opt['unique'])
762 elif type(opt['unique']) in (types.TupleType,types.ListType):
762 elif type(opt['unique']) in (types.TupleType,types.ListType):
763 unique_keys = opt['unique']
763 unique_keys = opt['unique']
764 else:
764 else:
765 raise ValueError, 'Unique keys must be given as a string, List or Tuple'
765 raise ValueError, 'Unique keys must be given as a string, List or Tuple'
766
766
767 dict = {}
767 dict = {}
768
768
769 # first read in table of values as strings
769 # first read in table of values as strings
770 if '\n' in filename:
770 if '\n' in filename:
771 lines = filename.splitlines()
771 lines = filename.splitlines()
772 file = None
772 file = None
773 else:
773 else:
774 file = open(filename,'r')
774 file = open(filename,'r')
775 lines = file.readlines()
775 lines = file.readlines()
776 for line in lines:
776 for line in lines:
777 line = line.strip()
777 line = line.strip()
778 if len(line) and line[0]=='#': continue
778 if len(line) and line[0]=='#': continue
779 if len(line)>0:
779 if len(line)>0:
780 lsplit = line.split(opt['fs'],1)
780 lsplit = line.split(opt['fs'],1)
781 try:
781 try:
782 key,val = lsplit
782 key,val = lsplit
783 except ValueError:
783 except ValueError:
784 key,val = lsplit[0],''
784 key,val = lsplit[0],''
785 key = key.strip()
785 key = key.strip()
786 if opt['strip']: val = val.strip()
786 if opt['strip']: val = val.strip()
787 if val == "''" or val == '""': val = ''
787 if val == "''" or val == '""': val = ''
788 if opt['no_empty'] and (val=='' or val.isspace()):
788 if opt['no_empty'] and (val=='' or val.isspace()):
789 continue
789 continue
790 # if a key is found more than once in the file, build a list
790 # if a key is found more than once in the file, build a list
791 # unless it's in the 'unique' list. In that case, last found in file
791 # unless it's in the 'unique' list. In that case, last found in file
792 # takes precedence. User beware.
792 # takes precedence. User beware.
793 try:
793 try:
794 if dict[key] and key in unique_keys:
794 if dict[key] and key in unique_keys:
795 dict[key] = val
795 dict[key] = val
796 elif type(dict[key]) is types.ListType:
796 elif type(dict[key]) is types.ListType:
797 dict[key].append(val)
797 dict[key].append(val)
798 else:
798 else:
799 dict[key] = [dict[key],val]
799 dict[key] = [dict[key],val]
800 except KeyError:
800 except KeyError:
801 dict[key] = val
801 dict[key] = val
802 # purge if requested
802 # purge if requested
803 if opt['purge']:
803 if opt['purge']:
804 accepted_keys = qwflat(type_conv.values())
804 accepted_keys = qwflat(type_conv.values())
805 for key in dict.keys():
805 for key in dict.keys():
806 if key in accepted_keys: continue
806 if key in accepted_keys: continue
807 del(dict[key])
807 del(dict[key])
808 # now convert if requested
808 # now convert if requested
809 if type_conv==None: return dict
809 if type_conv==None: return dict
810 conversions = type_conv.keys()
810 conversions = type_conv.keys()
811 try: conversions.remove(None)
811 try: conversions.remove(None)
812 except: pass
812 except: pass
813 for convert in conversions:
813 for convert in conversions:
814 for val in qw(type_conv[convert]):
814 for val in qw(type_conv[convert]):
815 try:
815 try:
816 dict[val] = convert(dict[val])
816 dict[val] = convert(dict[val])
817 except KeyError,e:
817 except KeyError,e:
818 if opt['warn'] == 0:
818 if opt['warn'] == 0:
819 pass
819 pass
820 elif opt['warn'] == 1:
820 elif opt['warn'] == 1:
821 print >>sys.stderr, 'Warning: key',val,\
821 print >>sys.stderr, 'Warning: key',val,\
822 'not found in file',filename
822 'not found in file',filename
823 elif opt['warn'] == 2:
823 elif opt['warn'] == 2:
824 raise KeyError,e
824 raise KeyError,e
825 else:
825 else:
826 raise ValueError,'Warning level must be 0,1 or 2'
826 raise ValueError,'Warning level must be 0,1 or 2'
827
827
828 return dict
828 return dict
829
829
830 #----------------------------------------------------------------------------
830 #----------------------------------------------------------------------------
831 def flag_calls(func):
831 def flag_calls(func):
832 """Wrap a function to detect and flag when it gets called.
832 """Wrap a function to detect and flag when it gets called.
833
833
834 This is a decorator which takes a function and wraps it in a function with
834 This is a decorator which takes a function and wraps it in a function with
835 a 'called' attribute. wrapper.called is initialized to False.
835 a 'called' attribute. wrapper.called is initialized to False.
836
836
837 The wrapper.called attribute is set to False right before each call to the
837 The wrapper.called attribute is set to False right before each call to the
838 wrapped function, so if the call fails it remains False. After the call
838 wrapped function, so if the call fails it remains False. After the call
839 completes, wrapper.called is set to True and the output is returned.
839 completes, wrapper.called is set to True and the output is returned.
840
840
841 Testing for truth in wrapper.called allows you to determine if a call to
841 Testing for truth in wrapper.called allows you to determine if a call to
842 func() was attempted and succeeded."""
842 func() was attempted and succeeded."""
843
843
844 def wrapper(*args,**kw):
844 def wrapper(*args,**kw):
845 wrapper.called = False
845 wrapper.called = False
846 out = func(*args,**kw)
846 out = func(*args,**kw)
847 wrapper.called = True
847 wrapper.called = True
848 return out
848 return out
849
849
850 wrapper.called = False
850 wrapper.called = False
851 wrapper.__doc__ = func.__doc__
851 wrapper.__doc__ = func.__doc__
852 return wrapper
852 return wrapper
853
853
854 #----------------------------------------------------------------------------
854 #----------------------------------------------------------------------------
855 def dhook_wrap(func,*a,**k):
855 def dhook_wrap(func,*a,**k):
856 """Wrap a function call in a sys.displayhook controller.
856 """Wrap a function call in a sys.displayhook controller.
857
857
858 Returns a wrapper around func which calls func, with all its arguments and
858 Returns a wrapper around func which calls func, with all its arguments and
859 keywords unmodified, using the default sys.displayhook. Since IPython
859 keywords unmodified, using the default sys.displayhook. Since IPython
860 modifies sys.displayhook, it breaks the behavior of certain systems that
860 modifies sys.displayhook, it breaks the behavior of certain systems that
861 rely on the default behavior, notably doctest.
861 rely on the default behavior, notably doctest.
862 """
862 """
863
863
864 def f(*a,**k):
864 def f(*a,**k):
865
865
866 dhook_s = sys.displayhook
866 dhook_s = sys.displayhook
867 sys.displayhook = sys.__displayhook__
867 sys.displayhook = sys.__displayhook__
868 try:
868 try:
869 out = func(*a,**k)
869 out = func(*a,**k)
870 finally:
870 finally:
871 sys.displayhook = dhook_s
871 sys.displayhook = dhook_s
872
872
873 return out
873 return out
874
874
875 f.__doc__ = func.__doc__
875 f.__doc__ = func.__doc__
876 return f
876 return f
877
877
878 #----------------------------------------------------------------------------
878 #----------------------------------------------------------------------------
879 def doctest_reload():
879 def doctest_reload():
880 """Properly reload doctest to reuse it interactively.
880 """Properly reload doctest to reuse it interactively.
881
881
882 This routine:
882 This routine:
883
883
884 - reloads doctest
884 - reloads doctest
885
885
886 - resets its global 'master' attribute to None, so that multiple uses of
886 - resets its global 'master' attribute to None, so that multiple uses of
887 the module interactively don't produce cumulative reports.
887 the module interactively don't produce cumulative reports.
888
888
889 - Monkeypatches its core test runner method to protect it from IPython's
889 - Monkeypatches its core test runner method to protect it from IPython's
890 modified displayhook. Doctest expects the default displayhook behavior
890 modified displayhook. Doctest expects the default displayhook behavior
891 deep down, so our modification breaks it completely. For this reason, a
891 deep down, so our modification breaks it completely. For this reason, a
892 hard monkeypatch seems like a reasonable solution rather than asking
892 hard monkeypatch seems like a reasonable solution rather than asking
893 users to manually use a different doctest runner when under IPython."""
893 users to manually use a different doctest runner when under IPython."""
894
894
895 import doctest
895 import doctest
896 reload(doctest)
896 reload(doctest)
897 doctest.master=None
897 doctest.master=None
898
898
899 try:
899 try:
900 doctest.DocTestRunner
900 doctest.DocTestRunner
901 except AttributeError:
901 except AttributeError:
902 # This is only for python 2.3 compatibility, remove once we move to
902 # This is only for python 2.3 compatibility, remove once we move to
903 # 2.4 only.
903 # 2.4 only.
904 pass
904 pass
905 else:
905 else:
906 doctest.DocTestRunner.run = dhook_wrap(doctest.DocTestRunner.run)
906 doctest.DocTestRunner.run = dhook_wrap(doctest.DocTestRunner.run)
907
907
908 #----------------------------------------------------------------------------
908 #----------------------------------------------------------------------------
909 class HomeDirError(Error):
909 class HomeDirError(Error):
910 pass
910 pass
911
911
912 def get_home_dir():
912 def get_home_dir():
913 """Return the closest possible equivalent to a 'home' directory.
913 """Return the closest possible equivalent to a 'home' directory.
914
914
915 We first try $HOME. Absent that, on NT it's $HOMEDRIVE\$HOMEPATH.
915 We first try $HOME. Absent that, on NT it's $HOMEDRIVE\$HOMEPATH.
916
916
917 Currently only Posix and NT are implemented, a HomeDirError exception is
917 Currently only Posix and NT are implemented, a HomeDirError exception is
918 raised for all other OSes. """
918 raised for all other OSes. """
919
919
920 isdir = os.path.isdir
920 isdir = os.path.isdir
921 env = os.environ
921 env = os.environ
922
922
923 # first, check py2exe distribution root directory for _ipython.
923 # first, check py2exe distribution root directory for _ipython.
924 # This overrides all. Normally does not exist.
924 # This overrides all. Normally does not exist.
925
925
926 if hasattr(sys, "frozen"): #Is frozen by py2exe
926 if hasattr(sys, "frozen"): #Is frozen by py2exe
927 if '\\library.zip\\' in IPython.__file__.lower():#libraries compressed to zip-file
927 if '\\library.zip\\' in IPython.__file__.lower():#libraries compressed to zip-file
928 root, rest = IPython.__file__.lower().split('library.zip')
928 root, rest = IPython.__file__.lower().split('library.zip')
929 else:
929 else:
930 root=os.path.join(os.path.split(IPython.__file__)[0],"../../")
930 root=os.path.join(os.path.split(IPython.__file__)[0],"../../")
931 root=os.path.abspath(root).rstrip('\\')
931 root=os.path.abspath(root).rstrip('\\')
932 if isdir(os.path.join(root, '_ipython')):
932 if isdir(os.path.join(root, '_ipython')):
933 os.environ["IPYKITROOT"] = root
933 os.environ["IPYKITROOT"] = root
934 return root
934 return root
935 try:
935 try:
936 homedir = env['HOME']
936 homedir = env['HOME']
937 if not isdir(homedir):
937 if not isdir(homedir):
938 # in case a user stuck some string which does NOT resolve to a
938 # in case a user stuck some string which does NOT resolve to a
939 # valid path, it's as good as if we hadn't foud it
939 # valid path, it's as good as if we hadn't foud it
940 raise KeyError
940 raise KeyError
941 return homedir
941 return homedir
942 except KeyError:
942 except KeyError:
943 if os.name == 'posix':
943 if os.name == 'posix':
944 raise HomeDirError,'undefined $HOME, IPython can not proceed.'
944 raise HomeDirError,'undefined $HOME, IPython can not proceed.'
945 elif os.name == 'nt':
945 elif os.name == 'nt':
946 # For some strange reason, win9x returns 'nt' for os.name.
946 # For some strange reason, win9x returns 'nt' for os.name.
947 try:
947 try:
948 homedir = os.path.join(env['HOMEDRIVE'],env['HOMEPATH'])
948 homedir = os.path.join(env['HOMEDRIVE'],env['HOMEPATH'])
949 if not isdir(homedir):
949 if not isdir(homedir):
950 homedir = os.path.join(env['USERPROFILE'])
950 homedir = os.path.join(env['USERPROFILE'])
951 if not isdir(homedir):
951 if not isdir(homedir):
952 raise HomeDirError
952 raise HomeDirError
953 return homedir
953 return homedir
954 except KeyError:
954 except KeyError:
955 try:
955 try:
956 # Use the registry to get the 'My Documents' folder.
956 # Use the registry to get the 'My Documents' folder.
957 import _winreg as wreg
957 import _winreg as wreg
958 key = wreg.OpenKey(wreg.HKEY_CURRENT_USER,
958 key = wreg.OpenKey(wreg.HKEY_CURRENT_USER,
959 "Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders")
959 "Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders")
960 homedir = wreg.QueryValueEx(key,'Personal')[0]
960 homedir = wreg.QueryValueEx(key,'Personal')[0]
961 key.Close()
961 key.Close()
962 if not isdir(homedir):
962 if not isdir(homedir):
963 e = ('Invalid "Personal" folder registry key '
963 e = ('Invalid "Personal" folder registry key '
964 'typically "My Documents".\n'
964 'typically "My Documents".\n'
965 'Value: %s\n'
965 'Value: %s\n'
966 'This is not a valid directory on your system.' %
966 'This is not a valid directory on your system.' %
967 homedir)
967 homedir)
968 raise HomeDirError(e)
968 raise HomeDirError(e)
969 return homedir
969 return homedir
970 except HomeDirError:
970 except HomeDirError:
971 raise
971 raise
972 except:
972 except:
973 return 'C:\\'
973 return 'C:\\'
974 elif os.name == 'dos':
974 elif os.name == 'dos':
975 # Desperate, may do absurd things in classic MacOS. May work under DOS.
975 # Desperate, may do absurd things in classic MacOS. May work under DOS.
976 return 'C:\\'
976 return 'C:\\'
977 else:
977 else:
978 raise HomeDirError,'support for your operating system not implemented.'
978 raise HomeDirError,'support for your operating system not implemented.'
979
979
980
980
981 def get_ipython_dir():
981 def get_ipython_dir():
982 """Get the IPython directory for this platform and user.
982 """Get the IPython directory for this platform and user.
983
983
984 This uses the logic in `get_home_dir` to find the home directory
984 This uses the logic in `get_home_dir` to find the home directory
985 and the adds either .ipython or _ipython to the end of the path.
985 and the adds either .ipython or _ipython to the end of the path.
986 """
986 """
987 if os.name == 'posix':
987 if os.name == 'posix':
988 ipdir_def = '.ipython'
988 ipdir_def = '.ipython'
989 else:
989 else:
990 ipdir_def = '_ipython'
990 ipdir_def = '_ipython'
991 home_dir = get_home_dir()
991 home_dir = get_home_dir()
992 ipdir = os.path.abspath(os.environ.get('IPYTHONDIR',
992 ipdir = os.path.abspath(os.environ.get('IPYTHONDIR',
993 os.path.join(home_dir, ipdir_def)))
993 os.path.join(home_dir, ipdir_def)))
994 return ipdir.decode(sys.getfilesystemencoding())
994 return ipdir.decode(sys.getfilesystemencoding())
995
995
996 def get_security_dir():
996 def get_security_dir():
997 """Get the IPython security directory.
997 """Get the IPython security directory.
998
998
999 This directory is the default location for all security related files,
999 This directory is the default location for all security related files,
1000 including SSL/TLS certificates and FURL files.
1000 including SSL/TLS certificates and FURL files.
1001
1001
1002 If the directory does not exist, it is created with 0700 permissions.
1002 If the directory does not exist, it is created with 0700 permissions.
1003 If it exists, permissions are set to 0700.
1003 If it exists, permissions are set to 0700.
1004 """
1004 """
1005 security_dir = os.path.join(get_ipython_dir(), 'security')
1005 security_dir = os.path.join(get_ipython_dir(), 'security')
1006 if not os.path.isdir(security_dir):
1006 if not os.path.isdir(security_dir):
1007 os.mkdir(security_dir, 0700)
1007 os.mkdir(security_dir, 0700)
1008 else:
1008 else:
1009 os.chmod(security_dir, 0700)
1009 os.chmod(security_dir, 0700)
1010 return security_dir
1010 return security_dir
1011
1011
1012 def get_log_dir():
1012 def get_log_dir():
1013 """Get the IPython log directory.
1013 """Get the IPython log directory.
1014
1014
1015 If the log directory does not exist, it is created.
1015 If the log directory does not exist, it is created.
1016 """
1016 """
1017 log_dir = os.path.join(get_ipython_dir(), 'log')
1017 log_dir = os.path.join(get_ipython_dir(), 'log')
1018 if not os.path.isdir(log_dir):
1018 if not os.path.isdir(log_dir):
1019 os.mkdir(log_dir, 0777)
1019 os.mkdir(log_dir, 0777)
1020 return log_dir
1020 return log_dir
1021
1021
1022 #****************************************************************************
1022 #****************************************************************************
1023 # strings and text
1023 # strings and text
1024
1024
1025 class LSString(str):
1025 class LSString(str):
1026 """String derivative with a special access attributes.
1026 """String derivative with a special access attributes.
1027
1027
1028 These are normal strings, but with the special attributes:
1028 These are normal strings, but with the special attributes:
1029
1029
1030 .l (or .list) : value as list (split on newlines).
1030 .l (or .list) : value as list (split on newlines).
1031 .n (or .nlstr): original value (the string itself).
1031 .n (or .nlstr): original value (the string itself).
1032 .s (or .spstr): value as whitespace-separated string.
1032 .s (or .spstr): value as whitespace-separated string.
1033 .p (or .paths): list of path objects
1033 .p (or .paths): list of path objects
1034
1034
1035 Any values which require transformations are computed only once and
1035 Any values which require transformations are computed only once and
1036 cached.
1036 cached.
1037
1037
1038 Such strings are very useful to efficiently interact with the shell, which
1038 Such strings are very useful to efficiently interact with the shell, which
1039 typically only understands whitespace-separated options for commands."""
1039 typically only understands whitespace-separated options for commands."""
1040
1040
1041 def get_list(self):
1041 def get_list(self):
1042 try:
1042 try:
1043 return self.__list
1043 return self.__list
1044 except AttributeError:
1044 except AttributeError:
1045 self.__list = self.split('\n')
1045 self.__list = self.split('\n')
1046 return self.__list
1046 return self.__list
1047
1047
1048 l = list = property(get_list)
1048 l = list = property(get_list)
1049
1049
1050 def get_spstr(self):
1050 def get_spstr(self):
1051 try:
1051 try:
1052 return self.__spstr
1052 return self.__spstr
1053 except AttributeError:
1053 except AttributeError:
1054 self.__spstr = self.replace('\n',' ')
1054 self.__spstr = self.replace('\n',' ')
1055 return self.__spstr
1055 return self.__spstr
1056
1056
1057 s = spstr = property(get_spstr)
1057 s = spstr = property(get_spstr)
1058
1058
1059 def get_nlstr(self):
1059 def get_nlstr(self):
1060 return self
1060 return self
1061
1061
1062 n = nlstr = property(get_nlstr)
1062 n = nlstr = property(get_nlstr)
1063
1063
1064 def get_paths(self):
1064 def get_paths(self):
1065 try:
1065 try:
1066 return self.__paths
1066 return self.__paths
1067 except AttributeError:
1067 except AttributeError:
1068 self.__paths = [path(p) for p in self.split('\n') if os.path.exists(p)]
1068 self.__paths = [path(p) for p in self.split('\n') if os.path.exists(p)]
1069 return self.__paths
1069 return self.__paths
1070
1070
1071 p = paths = property(get_paths)
1071 p = paths = property(get_paths)
1072
1072
1073 def print_lsstring(arg):
1073 def print_lsstring(arg):
1074 """ Prettier (non-repr-like) and more informative printer for LSString """
1074 """ Prettier (non-repr-like) and more informative printer for LSString """
1075 print "LSString (.p, .n, .l, .s available). Value:"
1075 print "LSString (.p, .n, .l, .s available). Value:"
1076 print arg
1076 print arg
1077
1077
1078 print_lsstring = result_display.when_type(LSString)(print_lsstring)
1078 print_lsstring = result_display.when_type(LSString)(print_lsstring)
1079
1079
1080 #----------------------------------------------------------------------------
1080 #----------------------------------------------------------------------------
1081 class SList(list):
1081 class SList(list):
1082 """List derivative with a special access attributes.
1082 """List derivative with a special access attributes.
1083
1083
1084 These are normal lists, but with the special attributes:
1084 These are normal lists, but with the special attributes:
1085
1085
1086 .l (or .list) : value as list (the list itself).
1086 .l (or .list) : value as list (the list itself).
1087 .n (or .nlstr): value as a string, joined on newlines.
1087 .n (or .nlstr): value as a string, joined on newlines.
1088 .s (or .spstr): value as a string, joined on spaces.
1088 .s (or .spstr): value as a string, joined on spaces.
1089 .p (or .paths): list of path objects
1089 .p (or .paths): list of path objects
1090
1090
1091 Any values which require transformations are computed only once and
1091 Any values which require transformations are computed only once and
1092 cached."""
1092 cached."""
1093
1093
1094 def get_list(self):
1094 def get_list(self):
1095 return self
1095 return self
1096
1096
1097 l = list = property(get_list)
1097 l = list = property(get_list)
1098
1098
1099 def get_spstr(self):
1099 def get_spstr(self):
1100 try:
1100 try:
1101 return self.__spstr
1101 return self.__spstr
1102 except AttributeError:
1102 except AttributeError:
1103 self.__spstr = ' '.join(self)
1103 self.__spstr = ' '.join(self)
1104 return self.__spstr
1104 return self.__spstr
1105
1105
1106 s = spstr = property(get_spstr)
1106 s = spstr = property(get_spstr)
1107
1107
1108 def get_nlstr(self):
1108 def get_nlstr(self):
1109 try:
1109 try:
1110 return self.__nlstr
1110 return self.__nlstr
1111 except AttributeError:
1111 except AttributeError:
1112 self.__nlstr = '\n'.join(self)
1112 self.__nlstr = '\n'.join(self)
1113 return self.__nlstr
1113 return self.__nlstr
1114
1114
1115 n = nlstr = property(get_nlstr)
1115 n = nlstr = property(get_nlstr)
1116
1116
1117 def get_paths(self):
1117 def get_paths(self):
1118 try:
1118 try:
1119 return self.__paths
1119 return self.__paths
1120 except AttributeError:
1120 except AttributeError:
1121 self.__paths = [path(p) for p in self if os.path.exists(p)]
1121 self.__paths = [path(p) for p in self if os.path.exists(p)]
1122 return self.__paths
1122 return self.__paths
1123
1123
1124 p = paths = property(get_paths)
1124 p = paths = property(get_paths)
1125
1125
1126 def grep(self, pattern, prune = False, field = None):
1126 def grep(self, pattern, prune = False, field = None):
1127 """ Return all strings matching 'pattern' (a regex or callable)
1127 """ Return all strings matching 'pattern' (a regex or callable)
1128
1128
1129 This is case-insensitive. If prune is true, return all items
1129 This is case-insensitive. If prune is true, return all items
1130 NOT matching the pattern.
1130 NOT matching the pattern.
1131
1131
1132 If field is specified, the match must occur in the specified
1132 If field is specified, the match must occur in the specified
1133 whitespace-separated field.
1133 whitespace-separated field.
1134
1134
1135 Examples::
1135 Examples::
1136
1136
1137 a.grep( lambda x: x.startswith('C') )
1137 a.grep( lambda x: x.startswith('C') )
1138 a.grep('Cha.*log', prune=1)
1138 a.grep('Cha.*log', prune=1)
1139 a.grep('chm', field=-1)
1139 a.grep('chm', field=-1)
1140 """
1140 """
1141
1141
1142 def match_target(s):
1142 def match_target(s):
1143 if field is None:
1143 if field is None:
1144 return s
1144 return s
1145 parts = s.split()
1145 parts = s.split()
1146 try:
1146 try:
1147 tgt = parts[field]
1147 tgt = parts[field]
1148 return tgt
1148 return tgt
1149 except IndexError:
1149 except IndexError:
1150 return ""
1150 return ""
1151
1151
1152 if isinstance(pattern, basestring):
1152 if isinstance(pattern, basestring):
1153 pred = lambda x : re.search(pattern, x, re.IGNORECASE)
1153 pred = lambda x : re.search(pattern, x, re.IGNORECASE)
1154 else:
1154 else:
1155 pred = pattern
1155 pred = pattern
1156 if not prune:
1156 if not prune:
1157 return SList([el for el in self if pred(match_target(el))])
1157 return SList([el for el in self if pred(match_target(el))])
1158 else:
1158 else:
1159 return SList([el for el in self if not pred(match_target(el))])
1159 return SList([el for el in self if not pred(match_target(el))])
1160 def fields(self, *fields):
1160 def fields(self, *fields):
1161 """ Collect whitespace-separated fields from string list
1161 """ Collect whitespace-separated fields from string list
1162
1162
1163 Allows quick awk-like usage of string lists.
1163 Allows quick awk-like usage of string lists.
1164
1164
1165 Example data (in var a, created by 'a = !ls -l')::
1165 Example data (in var a, created by 'a = !ls -l')::
1166 -rwxrwxrwx 1 ville None 18 Dec 14 2006 ChangeLog
1166 -rwxrwxrwx 1 ville None 18 Dec 14 2006 ChangeLog
1167 drwxrwxrwx+ 6 ville None 0 Oct 24 18:05 IPython
1167 drwxrwxrwx+ 6 ville None 0 Oct 24 18:05 IPython
1168
1168
1169 a.fields(0) is ['-rwxrwxrwx', 'drwxrwxrwx+']
1169 a.fields(0) is ['-rwxrwxrwx', 'drwxrwxrwx+']
1170 a.fields(1,0) is ['1 -rwxrwxrwx', '6 drwxrwxrwx+']
1170 a.fields(1,0) is ['1 -rwxrwxrwx', '6 drwxrwxrwx+']
1171 (note the joining by space).
1171 (note the joining by space).
1172 a.fields(-1) is ['ChangeLog', 'IPython']
1172 a.fields(-1) is ['ChangeLog', 'IPython']
1173
1173
1174 IndexErrors are ignored.
1174 IndexErrors are ignored.
1175
1175
1176 Without args, fields() just split()'s the strings.
1176 Without args, fields() just split()'s the strings.
1177 """
1177 """
1178 if len(fields) == 0:
1178 if len(fields) == 0:
1179 return [el.split() for el in self]
1179 return [el.split() for el in self]
1180
1180
1181 res = SList()
1181 res = SList()
1182 for el in [f.split() for f in self]:
1182 for el in [f.split() for f in self]:
1183 lineparts = []
1183 lineparts = []
1184
1184
1185 for fd in fields:
1185 for fd in fields:
1186 try:
1186 try:
1187 lineparts.append(el[fd])
1187 lineparts.append(el[fd])
1188 except IndexError:
1188 except IndexError:
1189 pass
1189 pass
1190 if lineparts:
1190 if lineparts:
1191 res.append(" ".join(lineparts))
1191 res.append(" ".join(lineparts))
1192
1192
1193 return res
1193 return res
1194 def sort(self,field= None, nums = False):
1194 def sort(self,field= None, nums = False):
1195 """ sort by specified fields (see fields())
1195 """ sort by specified fields (see fields())
1196
1196
1197 Example::
1197 Example::
1198 a.sort(1, nums = True)
1198 a.sort(1, nums = True)
1199
1199
1200 Sorts a by second field, in numerical order (so that 21 > 3)
1200 Sorts a by second field, in numerical order (so that 21 > 3)
1201
1201
1202 """
1202 """
1203
1203
1204 #decorate, sort, undecorate
1204 #decorate, sort, undecorate
1205 if field is not None:
1205 if field is not None:
1206 dsu = [[SList([line]).fields(field), line] for line in self]
1206 dsu = [[SList([line]).fields(field), line] for line in self]
1207 else:
1207 else:
1208 dsu = [[line, line] for line in self]
1208 dsu = [[line, line] for line in self]
1209 if nums:
1209 if nums:
1210 for i in range(len(dsu)):
1210 for i in range(len(dsu)):
1211 numstr = "".join([ch for ch in dsu[i][0] if ch.isdigit()])
1211 numstr = "".join([ch for ch in dsu[i][0] if ch.isdigit()])
1212 try:
1212 try:
1213 n = int(numstr)
1213 n = int(numstr)
1214 except ValueError:
1214 except ValueError:
1215 n = 0;
1215 n = 0;
1216 dsu[i][0] = n
1216 dsu[i][0] = n
1217
1217
1218
1218
1219 dsu.sort()
1219 dsu.sort()
1220 return SList([t[1] for t in dsu])
1220 return SList([t[1] for t in dsu])
1221
1221
1222 def print_slist(arg):
1222 def print_slist(arg):
1223 """ Prettier (non-repr-like) and more informative printer for SList """
1223 """ Prettier (non-repr-like) and more informative printer for SList """
1224 print "SList (.p, .n, .l, .s, .grep(), .fields(), sort() available):"
1224 print "SList (.p, .n, .l, .s, .grep(), .fields(), sort() available):"
1225 if hasattr(arg, 'hideonce') and arg.hideonce:
1225 if hasattr(arg, 'hideonce') and arg.hideonce:
1226 arg.hideonce = False
1226 arg.hideonce = False
1227 return
1227 return
1228
1228
1229 nlprint(arg)
1229 nlprint(arg)
1230
1230
1231 print_slist = result_display.when_type(SList)(print_slist)
1231 print_slist = result_display.when_type(SList)(print_slist)
1232
1232
1233
1233
1234
1234
1235 #----------------------------------------------------------------------------
1235 #----------------------------------------------------------------------------
1236 def esc_quotes(strng):
1236 def esc_quotes(strng):
1237 """Return the input string with single and double quotes escaped out"""
1237 """Return the input string with single and double quotes escaped out"""
1238
1238
1239 return strng.replace('"','\\"').replace("'","\\'")
1239 return strng.replace('"','\\"').replace("'","\\'")
1240
1240
1241 #----------------------------------------------------------------------------
1241 #----------------------------------------------------------------------------
1242 def make_quoted_expr(s):
1242 def make_quoted_expr(s):
1243 """Return string s in appropriate quotes, using raw string if possible.
1243 """Return string s in appropriate quotes, using raw string if possible.
1244
1244
1245 XXX - example removed because it caused encoding errors in documentation
1245 XXX - example removed because it caused encoding errors in documentation
1246 generation. We need a new example that doesn't contain invalid chars.
1246 generation. We need a new example that doesn't contain invalid chars.
1247
1247
1248 Note the use of raw string and padding at the end to allow trailing
1248 Note the use of raw string and padding at the end to allow trailing
1249 backslash.
1249 backslash.
1250 """
1250 """
1251
1251
1252 tail = ''
1252 tail = ''
1253 tailpadding = ''
1253 tailpadding = ''
1254 raw = ''
1254 raw = ''
1255 if "\\" in s:
1255 if "\\" in s:
1256 raw = 'r'
1256 raw = 'r'
1257 if s.endswith('\\'):
1257 if s.endswith('\\'):
1258 tail = '[:-1]'
1258 tail = '[:-1]'
1259 tailpadding = '_'
1259 tailpadding = '_'
1260 if '"' not in s:
1260 if '"' not in s:
1261 quote = '"'
1261 quote = '"'
1262 elif "'" not in s:
1262 elif "'" not in s:
1263 quote = "'"
1263 quote = "'"
1264 elif '"""' not in s and not s.endswith('"'):
1264 elif '"""' not in s and not s.endswith('"'):
1265 quote = '"""'
1265 quote = '"""'
1266 elif "'''" not in s and not s.endswith("'"):
1266 elif "'''" not in s and not s.endswith("'"):
1267 quote = "'''"
1267 quote = "'''"
1268 else:
1268 else:
1269 # give up, backslash-escaped string will do
1269 # give up, backslash-escaped string will do
1270 return '"%s"' % esc_quotes(s)
1270 return '"%s"' % esc_quotes(s)
1271 res = raw + quote + s + tailpadding + quote + tail
1271 res = raw + quote + s + tailpadding + quote + tail
1272 return res
1272 return res
1273
1273
1274
1274
1275 #----------------------------------------------------------------------------
1275 #----------------------------------------------------------------------------
1276 def raw_input_multi(header='', ps1='==> ', ps2='..> ',terminate_str = '.'):
1276 def raw_input_multi(header='', ps1='==> ', ps2='..> ',terminate_str = '.'):
1277 """Take multiple lines of input.
1277 """Take multiple lines of input.
1278
1278
1279 A list with each line of input as a separate element is returned when a
1279 A list with each line of input as a separate element is returned when a
1280 termination string is entered (defaults to a single '.'). Input can also
1280 termination string is entered (defaults to a single '.'). Input can also
1281 terminate via EOF (^D in Unix, ^Z-RET in Windows).
1281 terminate via EOF (^D in Unix, ^Z-RET in Windows).
1282
1282
1283 Lines of input which end in \\ are joined into single entries (and a
1283 Lines of input which end in \\ are joined into single entries (and a
1284 secondary continuation prompt is issued as long as the user terminates
1284 secondary continuation prompt is issued as long as the user terminates
1285 lines with \\). This allows entering very long strings which are still
1285 lines with \\). This allows entering very long strings which are still
1286 meant to be treated as single entities.
1286 meant to be treated as single entities.
1287 """
1287 """
1288
1288
1289 try:
1289 try:
1290 if header:
1290 if header:
1291 header += '\n'
1291 header += '\n'
1292 lines = [raw_input(header + ps1)]
1292 lines = [raw_input(header + ps1)]
1293 except EOFError:
1293 except EOFError:
1294 return []
1294 return []
1295 terminate = [terminate_str]
1295 terminate = [terminate_str]
1296 try:
1296 try:
1297 while lines[-1:] != terminate:
1297 while lines[-1:] != terminate:
1298 new_line = raw_input(ps1)
1298 new_line = raw_input(ps1)
1299 while new_line.endswith('\\'):
1299 while new_line.endswith('\\'):
1300 new_line = new_line[:-1] + raw_input(ps2)
1300 new_line = new_line[:-1] + raw_input(ps2)
1301 lines.append(new_line)
1301 lines.append(new_line)
1302
1302
1303 return lines[:-1] # don't return the termination command
1303 return lines[:-1] # don't return the termination command
1304 except EOFError:
1304 except EOFError:
1305 print
1305 print
1306 return lines
1306 return lines
1307
1307
1308 #----------------------------------------------------------------------------
1308 #----------------------------------------------------------------------------
1309 def raw_input_ext(prompt='', ps2='... '):
1309 def raw_input_ext(prompt='', ps2='... '):
1310 """Similar to raw_input(), but accepts extended lines if input ends with \\."""
1310 """Similar to raw_input(), but accepts extended lines if input ends with \\."""
1311
1311
1312 line = raw_input(prompt)
1312 line = raw_input(prompt)
1313 while line.endswith('\\'):
1313 while line.endswith('\\'):
1314 line = line[:-1] + raw_input(ps2)
1314 line = line[:-1] + raw_input(ps2)
1315 return line
1315 return line
1316
1316
1317 #----------------------------------------------------------------------------
1317 #----------------------------------------------------------------------------
1318 def ask_yes_no(prompt,default=None):
1318 def ask_yes_no(prompt,default=None):
1319 """Asks a question and returns a boolean (y/n) answer.
1319 """Asks a question and returns a boolean (y/n) answer.
1320
1320
1321 If default is given (one of 'y','n'), it is used if the user input is
1321 If default is given (one of 'y','n'), it is used if the user input is
1322 empty. Otherwise the question is repeated until an answer is given.
1322 empty. Otherwise the question is repeated until an answer is given.
1323
1323
1324 An EOF is treated as the default answer. If there is no default, an
1324 An EOF is treated as the default answer. If there is no default, an
1325 exception is raised to prevent infinite loops.
1325 exception is raised to prevent infinite loops.
1326
1326
1327 Valid answers are: y/yes/n/no (match is not case sensitive)."""
1327 Valid answers are: y/yes/n/no (match is not case sensitive)."""
1328
1328
1329 answers = {'y':True,'n':False,'yes':True,'no':False}
1329 answers = {'y':True,'n':False,'yes':True,'no':False}
1330 ans = None
1330 ans = None
1331 while ans not in answers.keys():
1331 while ans not in answers.keys():
1332 try:
1332 try:
1333 ans = raw_input(prompt+' ').lower()
1333 ans = raw_input(prompt+' ').lower()
1334 if not ans: # response was an empty string
1334 if not ans: # response was an empty string
1335 ans = default
1335 ans = default
1336 except KeyboardInterrupt:
1336 except KeyboardInterrupt:
1337 pass
1337 pass
1338 except EOFError:
1338 except EOFError:
1339 if default in answers.keys():
1339 if default in answers.keys():
1340 ans = default
1340 ans = default
1341 print
1341 print
1342 else:
1342 else:
1343 raise
1343 raise
1344
1344
1345 return answers[ans]
1345 return answers[ans]
1346
1346
1347 #----------------------------------------------------------------------------
1347 #----------------------------------------------------------------------------
1348 def marquee(txt='',width=78,mark='*'):
1348 def marquee(txt='',width=78,mark='*'):
1349 """Return the input string centered in a 'marquee'."""
1349 """Return the input string centered in a 'marquee'."""
1350 if not txt:
1350 if not txt:
1351 return (mark*width)[:width]
1351 return (mark*width)[:width]
1352 nmark = (width-len(txt)-2)/len(mark)/2
1352 nmark = (width-len(txt)-2)/len(mark)/2
1353 if nmark < 0: nmark =0
1353 if nmark < 0: nmark =0
1354 marks = mark*nmark
1354 marks = mark*nmark
1355 return '%s %s %s' % (marks,txt,marks)
1355 return '%s %s %s' % (marks,txt,marks)
1356
1356
1357 #----------------------------------------------------------------------------
1357 #----------------------------------------------------------------------------
1358 class EvalDict:
1358 class EvalDict:
1359 """
1359 """
1360 Emulate a dict which evaluates its contents in the caller's frame.
1360 Emulate a dict which evaluates its contents in the caller's frame.
1361
1361
1362 Usage:
1362 Usage:
1363 >>> number = 19
1363 >>> number = 19
1364
1364
1365 >>> text = "python"
1365 >>> text = "python"
1366
1366
1367 >>> print "%(text.capitalize())s %(number/9.0).1f rules!" % EvalDict()
1367 >>> print "%(text.capitalize())s %(number/9.0).1f rules!" % EvalDict()
1368 Python 2.1 rules!
1368 Python 2.1 rules!
1369 """
1369 """
1370
1370
1371 # This version is due to sismex01@hebmex.com on c.l.py, and is basically a
1371 # This version is due to sismex01@hebmex.com on c.l.py, and is basically a
1372 # modified (shorter) version of:
1372 # modified (shorter) version of:
1373 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/66018 by
1373 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/66018 by
1374 # Skip Montanaro (skip@pobox.com).
1374 # Skip Montanaro (skip@pobox.com).
1375
1375
1376 def __getitem__(self, name):
1376 def __getitem__(self, name):
1377 frame = sys._getframe(1)
1377 frame = sys._getframe(1)
1378 return eval(name, frame.f_globals, frame.f_locals)
1378 return eval(name, frame.f_globals, frame.f_locals)
1379
1379
1380 EvalString = EvalDict # for backwards compatibility
1380 EvalString = EvalDict # for backwards compatibility
1381 #----------------------------------------------------------------------------
1381 #----------------------------------------------------------------------------
1382 def qw(words,flat=0,sep=None,maxsplit=-1):
1382 def qw(words,flat=0,sep=None,maxsplit=-1):
1383 """Similar to Perl's qw() operator, but with some more options.
1383 """Similar to Perl's qw() operator, but with some more options.
1384
1384
1385 qw(words,flat=0,sep=' ',maxsplit=-1) -> words.split(sep,maxsplit)
1385 qw(words,flat=0,sep=' ',maxsplit=-1) -> words.split(sep,maxsplit)
1386
1386
1387 words can also be a list itself, and with flat=1, the output will be
1387 words can also be a list itself, and with flat=1, the output will be
1388 recursively flattened.
1388 recursively flattened.
1389
1389
1390 Examples:
1390 Examples:
1391
1391
1392 >>> qw('1 2')
1392 >>> qw('1 2')
1393 ['1', '2']
1393 ['1', '2']
1394
1394
1395 >>> qw(['a b','1 2',['m n','p q']])
1395 >>> qw(['a b','1 2',['m n','p q']])
1396 [['a', 'b'], ['1', '2'], [['m', 'n'], ['p', 'q']]]
1396 [['a', 'b'], ['1', '2'], [['m', 'n'], ['p', 'q']]]
1397
1397
1398 >>> qw(['a b','1 2',['m n','p q']],flat=1)
1398 >>> qw(['a b','1 2',['m n','p q']],flat=1)
1399 ['a', 'b', '1', '2', 'm', 'n', 'p', 'q']
1399 ['a', 'b', '1', '2', 'm', 'n', 'p', 'q']
1400 """
1400 """
1401
1401
1402 if type(words) in StringTypes:
1402 if type(words) in StringTypes:
1403 return [word.strip() for word in words.split(sep,maxsplit)
1403 return [word.strip() for word in words.split(sep,maxsplit)
1404 if word and not word.isspace() ]
1404 if word and not word.isspace() ]
1405 if flat:
1405 if flat:
1406 return flatten(map(qw,words,[1]*len(words)))
1406 return flatten(map(qw,words,[1]*len(words)))
1407 return map(qw,words)
1407 return map(qw,words)
1408
1408
1409 #----------------------------------------------------------------------------
1409 #----------------------------------------------------------------------------
1410 def qwflat(words,sep=None,maxsplit=-1):
1410 def qwflat(words,sep=None,maxsplit=-1):
1411 """Calls qw(words) in flat mode. It's just a convenient shorthand."""
1411 """Calls qw(words) in flat mode. It's just a convenient shorthand."""
1412 return qw(words,1,sep,maxsplit)
1412 return qw(words,1,sep,maxsplit)
1413
1413
1414 #----------------------------------------------------------------------------
1414 #----------------------------------------------------------------------------
1415 def qw_lol(indata):
1415 def qw_lol(indata):
1416 """qw_lol('a b') -> [['a','b']],
1416 """qw_lol('a b') -> [['a','b']],
1417 otherwise it's just a call to qw().
1417 otherwise it's just a call to qw().
1418
1418
1419 We need this to make sure the modules_some keys *always* end up as a
1419 We need this to make sure the modules_some keys *always* end up as a
1420 list of lists."""
1420 list of lists."""
1421
1421
1422 if type(indata) in StringTypes:
1422 if type(indata) in StringTypes:
1423 return [qw(indata)]
1423 return [qw(indata)]
1424 else:
1424 else:
1425 return qw(indata)
1425 return qw(indata)
1426
1426
1427 #-----------------------------------------------------------------------------
1427 #-----------------------------------------------------------------------------
1428 def list_strings(arg):
1428 def list_strings(arg):
1429 """Always return a list of strings, given a string or list of strings
1429 """Always return a list of strings, given a string or list of strings
1430 as input."""
1430 as input."""
1431
1431
1432 if type(arg) in StringTypes: return [arg]
1432 if type(arg) in StringTypes: return [arg]
1433 else: return arg
1433 else: return arg
1434
1434
1435 #----------------------------------------------------------------------------
1435 #----------------------------------------------------------------------------
1436 def grep(pat,list,case=1):
1436 def grep(pat,list,case=1):
1437 """Simple minded grep-like function.
1437 """Simple minded grep-like function.
1438 grep(pat,list) returns occurrences of pat in list, None on failure.
1438 grep(pat,list) returns occurrences of pat in list, None on failure.
1439
1439
1440 It only does simple string matching, with no support for regexps. Use the
1440 It only does simple string matching, with no support for regexps. Use the
1441 option case=0 for case-insensitive matching."""
1441 option case=0 for case-insensitive matching."""
1442
1442
1443 # This is pretty crude. At least it should implement copying only references
1443 # This is pretty crude. At least it should implement copying only references
1444 # to the original data in case it's big. Now it copies the data for output.
1444 # to the original data in case it's big. Now it copies the data for output.
1445 out=[]
1445 out=[]
1446 if case:
1446 if case:
1447 for term in list:
1447 for term in list:
1448 if term.find(pat)>-1: out.append(term)
1448 if term.find(pat)>-1: out.append(term)
1449 else:
1449 else:
1450 lpat=pat.lower()
1450 lpat=pat.lower()
1451 for term in list:
1451 for term in list:
1452 if term.lower().find(lpat)>-1: out.append(term)
1452 if term.lower().find(lpat)>-1: out.append(term)
1453
1453
1454 if len(out): return out
1454 if len(out): return out
1455 else: return None
1455 else: return None
1456
1456
1457 #----------------------------------------------------------------------------
1457 #----------------------------------------------------------------------------
1458 def dgrep(pat,*opts):
1458 def dgrep(pat,*opts):
1459 """Return grep() on dir()+dir(__builtins__).
1459 """Return grep() on dir()+dir(__builtins__).
1460
1460
1461 A very common use of grep() when working interactively."""
1461 A very common use of grep() when working interactively."""
1462
1462
1463 return grep(pat,dir(__main__)+dir(__main__.__builtins__),*opts)
1463 return grep(pat,dir(__main__)+dir(__main__.__builtins__),*opts)
1464
1464
1465 #----------------------------------------------------------------------------
1465 #----------------------------------------------------------------------------
1466 def idgrep(pat):
1466 def idgrep(pat):
1467 """Case-insensitive dgrep()"""
1467 """Case-insensitive dgrep()"""
1468
1468
1469 return dgrep(pat,0)
1469 return dgrep(pat,0)
1470
1470
1471 #----------------------------------------------------------------------------
1471 #----------------------------------------------------------------------------
1472 def igrep(pat,list):
1472 def igrep(pat,list):
1473 """Synonym for case-insensitive grep."""
1473 """Synonym for case-insensitive grep."""
1474
1474
1475 return grep(pat,list,case=0)
1475 return grep(pat,list,case=0)
1476
1476
1477 #----------------------------------------------------------------------------
1477 #----------------------------------------------------------------------------
1478 def indent(str,nspaces=4,ntabs=0):
1478 def indent(str,nspaces=4,ntabs=0):
1479 """Indent a string a given number of spaces or tabstops.
1479 """Indent a string a given number of spaces or tabstops.
1480
1480
1481 indent(str,nspaces=4,ntabs=0) -> indent str by ntabs+nspaces.
1481 indent(str,nspaces=4,ntabs=0) -> indent str by ntabs+nspaces.
1482 """
1482 """
1483 if str is None:
1483 if str is None:
1484 return
1484 return
1485 ind = '\t'*ntabs+' '*nspaces
1485 ind = '\t'*ntabs+' '*nspaces
1486 outstr = '%s%s' % (ind,str.replace(os.linesep,os.linesep+ind))
1486 outstr = '%s%s' % (ind,str.replace(os.linesep,os.linesep+ind))
1487 if outstr.endswith(os.linesep+ind):
1487 if outstr.endswith(os.linesep+ind):
1488 return outstr[:-len(ind)]
1488 return outstr[:-len(ind)]
1489 else:
1489 else:
1490 return outstr
1490 return outstr
1491
1491
1492 #-----------------------------------------------------------------------------
1492 #-----------------------------------------------------------------------------
1493 def native_line_ends(filename,backup=1):
1493 def native_line_ends(filename,backup=1):
1494 """Convert (in-place) a file to line-ends native to the current OS.
1494 """Convert (in-place) a file to line-ends native to the current OS.
1495
1495
1496 If the optional backup argument is given as false, no backup of the
1496 If the optional backup argument is given as false, no backup of the
1497 original file is left. """
1497 original file is left. """
1498
1498
1499 backup_suffixes = {'posix':'~','dos':'.bak','nt':'.bak','mac':'.bak'}
1499 backup_suffixes = {'posix':'~','dos':'.bak','nt':'.bak','mac':'.bak'}
1500
1500
1501 bak_filename = filename + backup_suffixes[os.name]
1501 bak_filename = filename + backup_suffixes[os.name]
1502
1502
1503 original = open(filename).read()
1503 original = open(filename).read()
1504 shutil.copy2(filename,bak_filename)
1504 shutil.copy2(filename,bak_filename)
1505 try:
1505 try:
1506 new = open(filename,'wb')
1506 new = open(filename,'wb')
1507 new.write(os.linesep.join(original.splitlines()))
1507 new.write(os.linesep.join(original.splitlines()))
1508 new.write(os.linesep) # ALWAYS put an eol at the end of the file
1508 new.write(os.linesep) # ALWAYS put an eol at the end of the file
1509 new.close()
1509 new.close()
1510 except:
1510 except:
1511 os.rename(bak_filename,filename)
1511 os.rename(bak_filename,filename)
1512 if not backup:
1512 if not backup:
1513 try:
1513 try:
1514 os.remove(bak_filename)
1514 os.remove(bak_filename)
1515 except:
1515 except:
1516 pass
1516 pass
1517
1517
1518 #----------------------------------------------------------------------------
1518 #----------------------------------------------------------------------------
1519 def get_pager_cmd(pager_cmd = None):
1519 def get_pager_cmd(pager_cmd = None):
1520 """Return a pager command.
1520 """Return a pager command.
1521
1521
1522 Makes some attempts at finding an OS-correct one."""
1522 Makes some attempts at finding an OS-correct one."""
1523
1523
1524 if os.name == 'posix':
1524 if os.name == 'posix':
1525 default_pager_cmd = 'less -r' # -r for color control sequences
1525 default_pager_cmd = 'less -r' # -r for color control sequences
1526 elif os.name in ['nt','dos']:
1526 elif os.name in ['nt','dos']:
1527 default_pager_cmd = 'type'
1527 default_pager_cmd = 'type'
1528
1528
1529 if pager_cmd is None:
1529 if pager_cmd is None:
1530 try:
1530 try:
1531 pager_cmd = os.environ['PAGER']
1531 pager_cmd = os.environ['PAGER']
1532 except:
1532 except:
1533 pager_cmd = default_pager_cmd
1533 pager_cmd = default_pager_cmd
1534 return pager_cmd
1534 return pager_cmd
1535
1535
1536 #-----------------------------------------------------------------------------
1536 #-----------------------------------------------------------------------------
1537 def get_pager_start(pager,start):
1537 def get_pager_start(pager,start):
1538 """Return the string for paging files with an offset.
1538 """Return the string for paging files with an offset.
1539
1539
1540 This is the '+N' argument which less and more (under Unix) accept.
1540 This is the '+N' argument which less and more (under Unix) accept.
1541 """
1541 """
1542
1542
1543 if pager in ['less','more']:
1543 if pager in ['less','more']:
1544 if start:
1544 if start:
1545 start_string = '+' + str(start)
1545 start_string = '+' + str(start)
1546 else:
1546 else:
1547 start_string = ''
1547 start_string = ''
1548 else:
1548 else:
1549 start_string = ''
1549 start_string = ''
1550 return start_string
1550 return start_string
1551
1551
1552 #----------------------------------------------------------------------------
1552 #----------------------------------------------------------------------------
1553 # (X)emacs on W32 doesn't like to be bypassed with msvcrt.getch()
1553 # (X)emacs on W32 doesn't like to be bypassed with msvcrt.getch()
1554 if os.name == 'nt' and os.environ.get('TERM','dumb') != 'emacs':
1554 if os.name == 'nt' and os.environ.get('TERM','dumb') != 'emacs':
1555 import msvcrt
1555 import msvcrt
1556 def page_more():
1556 def page_more():
1557 """ Smart pausing between pages
1557 """ Smart pausing between pages
1558
1558
1559 @return: True if need print more lines, False if quit
1559 @return: True if need print more lines, False if quit
1560 """
1560 """
1561 Term.cout.write('---Return to continue, q to quit--- ')
1561 Term.cout.write('---Return to continue, q to quit--- ')
1562 ans = msvcrt.getch()
1562 ans = msvcrt.getch()
1563 if ans in ("q", "Q"):
1563 if ans in ("q", "Q"):
1564 result = False
1564 result = False
1565 else:
1565 else:
1566 result = True
1566 result = True
1567 Term.cout.write("\b"*37 + " "*37 + "\b"*37)
1567 Term.cout.write("\b"*37 + " "*37 + "\b"*37)
1568 return result
1568 return result
1569 else:
1569 else:
1570 def page_more():
1570 def page_more():
1571 ans = raw_input('---Return to continue, q to quit--- ')
1571 ans = raw_input('---Return to continue, q to quit--- ')
1572 if ans.lower().startswith('q'):
1572 if ans.lower().startswith('q'):
1573 return False
1573 return False
1574 else:
1574 else:
1575 return True
1575 return True
1576
1576
1577 esc_re = re.compile(r"(\x1b[^m]+m)")
1577 esc_re = re.compile(r"(\x1b[^m]+m)")
1578
1578
1579 def page_dumb(strng,start=0,screen_lines=25):
1579 def page_dumb(strng,start=0,screen_lines=25):
1580 """Very dumb 'pager' in Python, for when nothing else works.
1580 """Very dumb 'pager' in Python, for when nothing else works.
1581
1581
1582 Only moves forward, same interface as page(), except for pager_cmd and
1582 Only moves forward, same interface as page(), except for pager_cmd and
1583 mode."""
1583 mode."""
1584
1584
1585 out_ln = strng.splitlines()[start:]
1585 out_ln = strng.splitlines()[start:]
1586 screens = chop(out_ln,screen_lines-1)
1586 screens = chop(out_ln,screen_lines-1)
1587 if len(screens) == 1:
1587 if len(screens) == 1:
1588 print >>Term.cout, os.linesep.join(screens[0])
1588 print >>Term.cout, os.linesep.join(screens[0])
1589 else:
1589 else:
1590 last_escape = ""
1590 last_escape = ""
1591 for scr in screens[0:-1]:
1591 for scr in screens[0:-1]:
1592 hunk = os.linesep.join(scr)
1592 hunk = os.linesep.join(scr)
1593 print >>Term.cout, last_escape + hunk
1593 print >>Term.cout, last_escape + hunk
1594 if not page_more():
1594 if not page_more():
1595 return
1595 return
1596 esc_list = esc_re.findall(hunk)
1596 esc_list = esc_re.findall(hunk)
1597 if len(esc_list) > 0:
1597 if len(esc_list) > 0:
1598 last_escape = esc_list[-1]
1598 last_escape = esc_list[-1]
1599 print >>Term.cout, last_escape + os.linesep.join(screens[-1])
1599 print >>Term.cout, last_escape + os.linesep.join(screens[-1])
1600
1600
1601 #----------------------------------------------------------------------------
1601 #----------------------------------------------------------------------------
1602 def page(strng,start=0,screen_lines=0,pager_cmd = None):
1602 def page(strng,start=0,screen_lines=0,pager_cmd = None):
1603 """Print a string, piping through a pager after a certain length.
1603 """Print a string, piping through a pager after a certain length.
1604
1604
1605 The screen_lines parameter specifies the number of *usable* lines of your
1605 The screen_lines parameter specifies the number of *usable* lines of your
1606 terminal screen (total lines minus lines you need to reserve to show other
1606 terminal screen (total lines minus lines you need to reserve to show other
1607 information).
1607 information).
1608
1608
1609 If you set screen_lines to a number <=0, page() will try to auto-determine
1609 If you set screen_lines to a number <=0, page() will try to auto-determine
1610 your screen size and will only use up to (screen_size+screen_lines) for
1610 your screen size and will only use up to (screen_size+screen_lines) for
1611 printing, paging after that. That is, if you want auto-detection but need
1611 printing, paging after that. That is, if you want auto-detection but need
1612 to reserve the bottom 3 lines of the screen, use screen_lines = -3, and for
1612 to reserve the bottom 3 lines of the screen, use screen_lines = -3, and for
1613 auto-detection without any lines reserved simply use screen_lines = 0.
1613 auto-detection without any lines reserved simply use screen_lines = 0.
1614
1614
1615 If a string won't fit in the allowed lines, it is sent through the
1615 If a string won't fit in the allowed lines, it is sent through the
1616 specified pager command. If none given, look for PAGER in the environment,
1616 specified pager command. If none given, look for PAGER in the environment,
1617 and ultimately default to less.
1617 and ultimately default to less.
1618
1618
1619 If no system pager works, the string is sent through a 'dumb pager'
1619 If no system pager works, the string is sent through a 'dumb pager'
1620 written in python, very simplistic.
1620 written in python, very simplistic.
1621 """
1621 """
1622
1622
1623 # Some routines may auto-compute start offsets incorrectly and pass a
1623 # Some routines may auto-compute start offsets incorrectly and pass a
1624 # negative value. Offset to 0 for robustness.
1624 # negative value. Offset to 0 for robustness.
1625 start = max(0,start)
1625 start = max(0,start)
1626
1626
1627 # first, try the hook
1627 # first, try the hook
1628 ip = ipapi.get()
1628 ip = ipapi.get()
1629 if ip:
1629 if ip:
1630 try:
1630 try:
1631 ip.IP.hooks.show_in_pager(strng)
1631 ip.IP.hooks.show_in_pager(strng)
1632 return
1632 return
1633 except ipapi.TryNext:
1633 except ipapi.TryNext:
1634 pass
1634 pass
1635
1635
1636 # Ugly kludge, but calling curses.initscr() flat out crashes in emacs
1636 # Ugly kludge, but calling curses.initscr() flat out crashes in emacs
1637 TERM = os.environ.get('TERM','dumb')
1637 TERM = os.environ.get('TERM','dumb')
1638 if TERM in ['dumb','emacs'] and os.name != 'nt':
1638 if TERM in ['dumb','emacs'] and os.name != 'nt':
1639 print strng
1639 print strng
1640 return
1640 return
1641 # chop off the topmost part of the string we don't want to see
1641 # chop off the topmost part of the string we don't want to see
1642 str_lines = strng.split(os.linesep)[start:]
1642 str_lines = strng.split(os.linesep)[start:]
1643 str_toprint = os.linesep.join(str_lines)
1643 str_toprint = os.linesep.join(str_lines)
1644 num_newlines = len(str_lines)
1644 num_newlines = len(str_lines)
1645 len_str = len(str_toprint)
1645 len_str = len(str_toprint)
1646
1646
1647 # Dumb heuristics to guesstimate number of on-screen lines the string
1647 # Dumb heuristics to guesstimate number of on-screen lines the string
1648 # takes. Very basic, but good enough for docstrings in reasonable
1648 # takes. Very basic, but good enough for docstrings in reasonable
1649 # terminals. If someone later feels like refining it, it's not hard.
1649 # terminals. If someone later feels like refining it, it's not hard.
1650 numlines = max(num_newlines,int(len_str/80)+1)
1650 numlines = max(num_newlines,int(len_str/80)+1)
1651
1651
1652 if os.name == "nt":
1652 if os.name == "nt":
1653 screen_lines_def = get_console_size(defaulty=25)[1]
1653 screen_lines_def = get_console_size(defaulty=25)[1]
1654 else:
1654 else:
1655 screen_lines_def = 25 # default value if we can't auto-determine
1655 screen_lines_def = 25 # default value if we can't auto-determine
1656
1656
1657 # auto-determine screen size
1657 # auto-determine screen size
1658 if screen_lines <= 0:
1658 if screen_lines <= 0:
1659 if TERM=='xterm':
1659 if TERM=='xterm':
1660 use_curses = USE_CURSES
1660 use_curses = USE_CURSES
1661 else:
1661 else:
1662 # curses causes problems on many terminals other than xterm.
1662 # curses causes problems on many terminals other than xterm.
1663 use_curses = False
1663 use_curses = False
1664 if use_curses:
1664 if use_curses:
1665 # There is a bug in curses, where *sometimes* it fails to properly
1665 # There is a bug in curses, where *sometimes* it fails to properly
1666 # initialize, and then after the endwin() call is made, the
1666 # initialize, and then after the endwin() call is made, the
1667 # terminal is left in an unusable state. Rather than trying to
1667 # terminal is left in an unusable state. Rather than trying to
1668 # check everytime for this (by requesting and comparing termios
1668 # check everytime for this (by requesting and comparing termios
1669 # flags each time), we just save the initial terminal state and
1669 # flags each time), we just save the initial terminal state and
1670 # unconditionally reset it every time. It's cheaper than making
1670 # unconditionally reset it every time. It's cheaper than making
1671 # the checks.
1671 # the checks.
1672 term_flags = termios.tcgetattr(sys.stdout)
1672 term_flags = termios.tcgetattr(sys.stdout)
1673 scr = curses.initscr()
1673 scr = curses.initscr()
1674 screen_lines_real,screen_cols = scr.getmaxyx()
1674 screen_lines_real,screen_cols = scr.getmaxyx()
1675 curses.endwin()
1675 curses.endwin()
1676 # Restore terminal state in case endwin() didn't.
1676 # Restore terminal state in case endwin() didn't.
1677 termios.tcsetattr(sys.stdout,termios.TCSANOW,term_flags)
1677 termios.tcsetattr(sys.stdout,termios.TCSANOW,term_flags)
1678 # Now we have what we needed: the screen size in rows/columns
1678 # Now we have what we needed: the screen size in rows/columns
1679 screen_lines += screen_lines_real
1679 screen_lines += screen_lines_real
1680 #print '***Screen size:',screen_lines_real,'lines x',\
1680 #print '***Screen size:',screen_lines_real,'lines x',\
1681 #screen_cols,'columns.' # dbg
1681 #screen_cols,'columns.' # dbg
1682 else:
1682 else:
1683 screen_lines += screen_lines_def
1683 screen_lines += screen_lines_def
1684
1684
1685 #print 'numlines',numlines,'screenlines',screen_lines # dbg
1685 #print 'numlines',numlines,'screenlines',screen_lines # dbg
1686 if numlines <= screen_lines :
1686 if numlines <= screen_lines :
1687 #print '*** normal print' # dbg
1687 #print '*** normal print' # dbg
1688 print >>Term.cout, str_toprint
1688 print >>Term.cout, str_toprint
1689 else:
1689 else:
1690 # Try to open pager and default to internal one if that fails.
1690 # Try to open pager and default to internal one if that fails.
1691 # All failure modes are tagged as 'retval=1', to match the return
1691 # All failure modes are tagged as 'retval=1', to match the return
1692 # value of a failed system command. If any intermediate attempt
1692 # value of a failed system command. If any intermediate attempt
1693 # sets retval to 1, at the end we resort to our own page_dumb() pager.
1693 # sets retval to 1, at the end we resort to our own page_dumb() pager.
1694 pager_cmd = get_pager_cmd(pager_cmd)
1694 pager_cmd = get_pager_cmd(pager_cmd)
1695 pager_cmd += ' ' + get_pager_start(pager_cmd,start)
1695 pager_cmd += ' ' + get_pager_start(pager_cmd,start)
1696 if os.name == 'nt':
1696 if os.name == 'nt':
1697 if pager_cmd.startswith('type'):
1697 if pager_cmd.startswith('type'):
1698 # The default WinXP 'type' command is failing on complex strings.
1698 # The default WinXP 'type' command is failing on complex strings.
1699 retval = 1
1699 retval = 1
1700 else:
1700 else:
1701 tmpname = tempfile.mktemp('.txt')
1701 tmpname = tempfile.mktemp('.txt')
1702 tmpfile = file(tmpname,'wt')
1702 tmpfile = file(tmpname,'wt')
1703 tmpfile.write(strng)
1703 tmpfile.write(strng)
1704 tmpfile.close()
1704 tmpfile.close()
1705 cmd = "%s < %s" % (pager_cmd,tmpname)
1705 cmd = "%s < %s" % (pager_cmd,tmpname)
1706 if os.system(cmd):
1706 if os.system(cmd):
1707 retval = 1
1707 retval = 1
1708 else:
1708 else:
1709 retval = None
1709 retval = None
1710 os.remove(tmpname)
1710 os.remove(tmpname)
1711 else:
1711 else:
1712 try:
1712 try:
1713 retval = None
1713 retval = None
1714 # if I use popen4, things hang. No idea why.
1714 # if I use popen4, things hang. No idea why.
1715 #pager,shell_out = os.popen4(pager_cmd)
1715 #pager,shell_out = os.popen4(pager_cmd)
1716 pager = os.popen(pager_cmd,'w')
1716 pager = os.popen(pager_cmd,'w')
1717 pager.write(strng)
1717 pager.write(strng)
1718 pager.close()
1718 pager.close()
1719 retval = pager.close() # success returns None
1719 retval = pager.close() # success returns None
1720 except IOError,msg: # broken pipe when user quits
1720 except IOError,msg: # broken pipe when user quits
1721 if msg.args == (32,'Broken pipe'):
1721 if msg.args == (32,'Broken pipe'):
1722 retval = None
1722 retval = None
1723 else:
1723 else:
1724 retval = 1
1724 retval = 1
1725 except OSError:
1725 except OSError:
1726 # Other strange problems, sometimes seen in Win2k/cygwin
1726 # Other strange problems, sometimes seen in Win2k/cygwin
1727 retval = 1
1727 retval = 1
1728 if retval is not None:
1728 if retval is not None:
1729 page_dumb(strng,screen_lines=screen_lines)
1729 page_dumb(strng,screen_lines=screen_lines)
1730
1730
1731 #----------------------------------------------------------------------------
1731 #----------------------------------------------------------------------------
1732 def page_file(fname,start = 0, pager_cmd = None):
1732 def page_file(fname,start = 0, pager_cmd = None):
1733 """Page a file, using an optional pager command and starting line.
1733 """Page a file, using an optional pager command and starting line.
1734 """
1734 """
1735
1735
1736 pager_cmd = get_pager_cmd(pager_cmd)
1736 pager_cmd = get_pager_cmd(pager_cmd)
1737 pager_cmd += ' ' + get_pager_start(pager_cmd,start)
1737 pager_cmd += ' ' + get_pager_start(pager_cmd,start)
1738
1738
1739 try:
1739 try:
1740 if os.environ['TERM'] in ['emacs','dumb']:
1740 if os.environ['TERM'] in ['emacs','dumb']:
1741 raise EnvironmentError
1741 raise EnvironmentError
1742 xsys(pager_cmd + ' ' + fname)
1742 xsys(pager_cmd + ' ' + fname)
1743 except:
1743 except:
1744 try:
1744 try:
1745 if start > 0:
1745 if start > 0:
1746 start -= 1
1746 start -= 1
1747 page(open(fname).read(),start)
1747 page(open(fname).read(),start)
1748 except:
1748 except:
1749 print 'Unable to show file',`fname`
1749 print 'Unable to show file',`fname`
1750
1750
1751
1751
1752 #----------------------------------------------------------------------------
1752 #----------------------------------------------------------------------------
1753 def snip_print(str,width = 75,print_full = 0,header = ''):
1753 def snip_print(str,width = 75,print_full = 0,header = ''):
1754 """Print a string snipping the midsection to fit in width.
1754 """Print a string snipping the midsection to fit in width.
1755
1755
1756 print_full: mode control:
1756 print_full: mode control:
1757 - 0: only snip long strings
1757 - 0: only snip long strings
1758 - 1: send to page() directly.
1758 - 1: send to page() directly.
1759 - 2: snip long strings and ask for full length viewing with page()
1759 - 2: snip long strings and ask for full length viewing with page()
1760 Return 1 if snipping was necessary, 0 otherwise."""
1760 Return 1 if snipping was necessary, 0 otherwise."""
1761
1761
1762 if print_full == 1:
1762 if print_full == 1:
1763 page(header+str)
1763 page(header+str)
1764 return 0
1764 return 0
1765
1765
1766 print header,
1766 print header,
1767 if len(str) < width:
1767 if len(str) < width:
1768 print str
1768 print str
1769 snip = 0
1769 snip = 0
1770 else:
1770 else:
1771 whalf = int((width -5)/2)
1771 whalf = int((width -5)/2)
1772 print str[:whalf] + ' <...> ' + str[-whalf:]
1772 print str[:whalf] + ' <...> ' + str[-whalf:]
1773 snip = 1
1773 snip = 1
1774 if snip and print_full == 2:
1774 if snip and print_full == 2:
1775 if raw_input(header+' Snipped. View (y/n)? [N]').lower() == 'y':
1775 if raw_input(header+' Snipped. View (y/n)? [N]').lower() == 'y':
1776 page(str)
1776 page(str)
1777 return snip
1777 return snip
1778
1778
1779 #****************************************************************************
1779 #****************************************************************************
1780 # lists, dicts and structures
1780 # lists, dicts and structures
1781
1781
1782 def belong(candidates,checklist):
1782 def belong(candidates,checklist):
1783 """Check whether a list of items appear in a given list of options.
1783 """Check whether a list of items appear in a given list of options.
1784
1784
1785 Returns a list of 1 and 0, one for each candidate given."""
1785 Returns a list of 1 and 0, one for each candidate given."""
1786
1786
1787 return [x in checklist for x in candidates]
1787 return [x in checklist for x in candidates]
1788
1788
1789 #----------------------------------------------------------------------------
1789 #----------------------------------------------------------------------------
1790 def uniq_stable(elems):
1790 def uniq_stable(elems):
1791 """uniq_stable(elems) -> list
1791 """uniq_stable(elems) -> list
1792
1792
1793 Return from an iterable, a list of all the unique elements in the input,
1793 Return from an iterable, a list of all the unique elements in the input,
1794 but maintaining the order in which they first appear.
1794 but maintaining the order in which they first appear.
1795
1795
1796 A naive solution to this problem which just makes a dictionary with the
1796 A naive solution to this problem which just makes a dictionary with the
1797 elements as keys fails to respect the stability condition, since
1797 elements as keys fails to respect the stability condition, since
1798 dictionaries are unsorted by nature.
1798 dictionaries are unsorted by nature.
1799
1799
1800 Note: All elements in the input must be valid dictionary keys for this
1800 Note: All elements in the input must be valid dictionary keys for this
1801 routine to work, as it internally uses a dictionary for efficiency
1801 routine to work, as it internally uses a dictionary for efficiency
1802 reasons."""
1802 reasons."""
1803
1803
1804 unique = []
1804 unique = []
1805 unique_dict = {}
1805 unique_dict = {}
1806 for nn in elems:
1806 for nn in elems:
1807 if nn not in unique_dict:
1807 if nn not in unique_dict:
1808 unique.append(nn)
1808 unique.append(nn)
1809 unique_dict[nn] = None
1809 unique_dict[nn] = None
1810 return unique
1810 return unique
1811
1811
1812 #----------------------------------------------------------------------------
1812 #----------------------------------------------------------------------------
1813 class NLprinter:
1813 class NLprinter:
1814 """Print an arbitrarily nested list, indicating index numbers.
1814 """Print an arbitrarily nested list, indicating index numbers.
1815
1815
1816 An instance of this class called nlprint is available and callable as a
1816 An instance of this class called nlprint is available and callable as a
1817 function.
1817 function.
1818
1818
1819 nlprint(list,indent=' ',sep=': ') -> prints indenting each level by 'indent'
1819 nlprint(list,indent=' ',sep=': ') -> prints indenting each level by 'indent'
1820 and using 'sep' to separate the index from the value. """
1820 and using 'sep' to separate the index from the value. """
1821
1821
1822 def __init__(self):
1822 def __init__(self):
1823 self.depth = 0
1823 self.depth = 0
1824
1824
1825 def __call__(self,lst,pos='',**kw):
1825 def __call__(self,lst,pos='',**kw):
1826 """Prints the nested list numbering levels."""
1826 """Prints the nested list numbering levels."""
1827 kw.setdefault('indent',' ')
1827 kw.setdefault('indent',' ')
1828 kw.setdefault('sep',': ')
1828 kw.setdefault('sep',': ')
1829 kw.setdefault('start',0)
1829 kw.setdefault('start',0)
1830 kw.setdefault('stop',len(lst))
1830 kw.setdefault('stop',len(lst))
1831 # we need to remove start and stop from kw so they don't propagate
1831 # we need to remove start and stop from kw so they don't propagate
1832 # into a recursive call for a nested list.
1832 # into a recursive call for a nested list.
1833 start = kw['start']; del kw['start']
1833 start = kw['start']; del kw['start']
1834 stop = kw['stop']; del kw['stop']
1834 stop = kw['stop']; del kw['stop']
1835 if self.depth == 0 and 'header' in kw.keys():
1835 if self.depth == 0 and 'header' in kw.keys():
1836 print kw['header']
1836 print kw['header']
1837
1837
1838 for idx in range(start,stop):
1838 for idx in range(start,stop):
1839 elem = lst[idx]
1839 elem = lst[idx]
1840 if type(elem)==type([]):
1840 if type(elem)==type([]):
1841 self.depth += 1
1841 self.depth += 1
1842 self.__call__(elem,itpl('$pos$idx,'),**kw)
1842 self.__call__(elem,itpl('$pos$idx,'),**kw)
1843 self.depth -= 1
1843 self.depth -= 1
1844 else:
1844 else:
1845 printpl(kw['indent']*self.depth+'$pos$idx$kw["sep"]$elem')
1845 printpl(kw['indent']*self.depth+'$pos$idx$kw["sep"]$elem')
1846
1846
1847 nlprint = NLprinter()
1847 nlprint = NLprinter()
1848 #----------------------------------------------------------------------------
1848 #----------------------------------------------------------------------------
1849 def all_belong(candidates,checklist):
1849 def all_belong(candidates,checklist):
1850 """Check whether a list of items ALL appear in a given list of options.
1850 """Check whether a list of items ALL appear in a given list of options.
1851
1851
1852 Returns a single 1 or 0 value."""
1852 Returns a single 1 or 0 value."""
1853
1853
1854 return 1-(0 in [x in checklist for x in candidates])
1854 return 1-(0 in [x in checklist for x in candidates])
1855
1855
1856 #----------------------------------------------------------------------------
1856 #----------------------------------------------------------------------------
1857 def sort_compare(lst1,lst2,inplace = 1):
1857 def sort_compare(lst1,lst2,inplace = 1):
1858 """Sort and compare two lists.
1858 """Sort and compare two lists.
1859
1859
1860 By default it does it in place, thus modifying the lists. Use inplace = 0
1860 By default it does it in place, thus modifying the lists. Use inplace = 0
1861 to avoid that (at the cost of temporary copy creation)."""
1861 to avoid that (at the cost of temporary copy creation)."""
1862 if not inplace:
1862 if not inplace:
1863 lst1 = lst1[:]
1863 lst1 = lst1[:]
1864 lst2 = lst2[:]
1864 lst2 = lst2[:]
1865 lst1.sort(); lst2.sort()
1865 lst1.sort(); lst2.sort()
1866 return lst1 == lst2
1866 return lst1 == lst2
1867
1867
1868 #----------------------------------------------------------------------------
1868 #----------------------------------------------------------------------------
1869 def list2dict(lst):
1869 def list2dict(lst):
1870 """Takes a list of (key,value) pairs and turns it into a dict."""
1870 """Takes a list of (key,value) pairs and turns it into a dict."""
1871
1871
1872 dic = {}
1872 dic = {}
1873 for k,v in lst: dic[k] = v
1873 for k,v in lst: dic[k] = v
1874 return dic
1874 return dic
1875
1875
1876 #----------------------------------------------------------------------------
1876 #----------------------------------------------------------------------------
1877 def list2dict2(lst,default=''):
1877 def list2dict2(lst,default=''):
1878 """Takes a list and turns it into a dict.
1878 """Takes a list and turns it into a dict.
1879 Much slower than list2dict, but more versatile. This version can take
1879 Much slower than list2dict, but more versatile. This version can take
1880 lists with sublists of arbitrary length (including sclars)."""
1880 lists with sublists of arbitrary length (including sclars)."""
1881
1881
1882 dic = {}
1882 dic = {}
1883 for elem in lst:
1883 for elem in lst:
1884 if type(elem) in (types.ListType,types.TupleType):
1884 if type(elem) in (types.ListType,types.TupleType):
1885 size = len(elem)
1885 size = len(elem)
1886 if size == 0:
1886 if size == 0:
1887 pass
1887 pass
1888 elif size == 1:
1888 elif size == 1:
1889 dic[elem] = default
1889 dic[elem] = default
1890 else:
1890 else:
1891 k,v = elem[0], elem[1:]
1891 k,v = elem[0], elem[1:]
1892 if len(v) == 1: v = v[0]
1892 if len(v) == 1: v = v[0]
1893 dic[k] = v
1893 dic[k] = v
1894 else:
1894 else:
1895 dic[elem] = default
1895 dic[elem] = default
1896 return dic
1896 return dic
1897
1897
1898 #----------------------------------------------------------------------------
1898 #----------------------------------------------------------------------------
1899 def flatten(seq):
1899 def flatten(seq):
1900 """Flatten a list of lists (NOT recursive, only works for 2d lists)."""
1900 """Flatten a list of lists (NOT recursive, only works for 2d lists)."""
1901
1901
1902 return [x for subseq in seq for x in subseq]
1902 return [x for subseq in seq for x in subseq]
1903
1903
1904 #----------------------------------------------------------------------------
1904 #----------------------------------------------------------------------------
1905 def get_slice(seq,start=0,stop=None,step=1):
1905 def get_slice(seq,start=0,stop=None,step=1):
1906 """Get a slice of a sequence with variable step. Specify start,stop,step."""
1906 """Get a slice of a sequence with variable step. Specify start,stop,step."""
1907 if stop == None:
1907 if stop == None:
1908 stop = len(seq)
1908 stop = len(seq)
1909 item = lambda i: seq[i]
1909 item = lambda i: seq[i]
1910 return map(item,xrange(start,stop,step))
1910 return map(item,xrange(start,stop,step))
1911
1911
1912 #----------------------------------------------------------------------------
1912 #----------------------------------------------------------------------------
1913 def chop(seq,size):
1913 def chop(seq,size):
1914 """Chop a sequence into chunks of the given size."""
1914 """Chop a sequence into chunks of the given size."""
1915 chunk = lambda i: seq[i:i+size]
1915 chunk = lambda i: seq[i:i+size]
1916 return map(chunk,xrange(0,len(seq),size))
1916 return map(chunk,xrange(0,len(seq),size))
1917
1917
1918 #----------------------------------------------------------------------------
1918 #----------------------------------------------------------------------------
1919 # with is a keyword as of python 2.5, so this function is renamed to withobj
1919 # with is a keyword as of python 2.5, so this function is renamed to withobj
1920 # from its old 'with' name.
1920 # from its old 'with' name.
1921 def with_obj(object, **args):
1921 def with_obj(object, **args):
1922 """Set multiple attributes for an object, similar to Pascal's with.
1922 """Set multiple attributes for an object, similar to Pascal's with.
1923
1923
1924 Example:
1924 Example:
1925 with_obj(jim,
1925 with_obj(jim,
1926 born = 1960,
1926 born = 1960,
1927 haircolour = 'Brown',
1927 haircolour = 'Brown',
1928 eyecolour = 'Green')
1928 eyecolour = 'Green')
1929
1929
1930 Credit: Greg Ewing, in
1930 Credit: Greg Ewing, in
1931 http://mail.python.org/pipermail/python-list/2001-May/040703.html.
1931 http://mail.python.org/pipermail/python-list/2001-May/040703.html.
1932
1932
1933 NOTE: up until IPython 0.7.2, this was called simply 'with', but 'with'
1933 NOTE: up until IPython 0.7.2, this was called simply 'with', but 'with'
1934 has become a keyword for Python 2.5, so we had to rename it."""
1934 has become a keyword for Python 2.5, so we had to rename it."""
1935
1935
1936 object.__dict__.update(args)
1936 object.__dict__.update(args)
1937
1937
1938 #----------------------------------------------------------------------------
1938 #----------------------------------------------------------------------------
1939 def setattr_list(obj,alist,nspace = None):
1939 def setattr_list(obj,alist,nspace = None):
1940 """Set a list of attributes for an object taken from a namespace.
1940 """Set a list of attributes for an object taken from a namespace.
1941
1941
1942 setattr_list(obj,alist,nspace) -> sets in obj all the attributes listed in
1942 setattr_list(obj,alist,nspace) -> sets in obj all the attributes listed in
1943 alist with their values taken from nspace, which must be a dict (something
1943 alist with their values taken from nspace, which must be a dict (something
1944 like locals() will often do) If nspace isn't given, locals() of the
1944 like locals() will often do) If nspace isn't given, locals() of the
1945 *caller* is used, so in most cases you can omit it.
1945 *caller* is used, so in most cases you can omit it.
1946
1946
1947 Note that alist can be given as a string, which will be automatically
1947 Note that alist can be given as a string, which will be automatically
1948 split into a list on whitespace. If given as a list, it must be a list of
1948 split into a list on whitespace. If given as a list, it must be a list of
1949 *strings* (the variable names themselves), not of variables."""
1949 *strings* (the variable names themselves), not of variables."""
1950
1950
1951 # this grabs the local variables from the *previous* call frame -- that is
1951 # this grabs the local variables from the *previous* call frame -- that is
1952 # the locals from the function that called setattr_list().
1952 # the locals from the function that called setattr_list().
1953 # - snipped from weave.inline()
1953 # - snipped from weave.inline()
1954 if nspace is None:
1954 if nspace is None:
1955 call_frame = sys._getframe().f_back
1955 call_frame = sys._getframe().f_back
1956 nspace = call_frame.f_locals
1956 nspace = call_frame.f_locals
1957
1957
1958 if type(alist) in StringTypes:
1958 if type(alist) in StringTypes:
1959 alist = alist.split()
1959 alist = alist.split()
1960 for attr in alist:
1960 for attr in alist:
1961 val = eval(attr,nspace)
1961 val = eval(attr,nspace)
1962 setattr(obj,attr,val)
1962 setattr(obj,attr,val)
1963
1963
1964 #----------------------------------------------------------------------------
1964 #----------------------------------------------------------------------------
1965 def getattr_list(obj,alist,*args):
1965 def getattr_list(obj,alist,*args):
1966 """getattr_list(obj,alist[, default]) -> attribute list.
1966 """getattr_list(obj,alist[, default]) -> attribute list.
1967
1967
1968 Get a list of named attributes for an object. When a default argument is
1968 Get a list of named attributes for an object. When a default argument is
1969 given, it is returned when the attribute doesn't exist; without it, an
1969 given, it is returned when the attribute doesn't exist; without it, an
1970 exception is raised in that case.
1970 exception is raised in that case.
1971
1971
1972 Note that alist can be given as a string, which will be automatically
1972 Note that alist can be given as a string, which will be automatically
1973 split into a list on whitespace. If given as a list, it must be a list of
1973 split into a list on whitespace. If given as a list, it must be a list of
1974 *strings* (the variable names themselves), not of variables."""
1974 *strings* (the variable names themselves), not of variables."""
1975
1975
1976 if type(alist) in StringTypes:
1976 if type(alist) in StringTypes:
1977 alist = alist.split()
1977 alist = alist.split()
1978 if args:
1978 if args:
1979 if len(args)==1:
1979 if len(args)==1:
1980 default = args[0]
1980 default = args[0]
1981 return map(lambda attr: getattr(obj,attr,default),alist)
1981 return map(lambda attr: getattr(obj,attr,default),alist)
1982 else:
1982 else:
1983 raise ValueError,'getattr_list() takes only one optional argument'
1983 raise ValueError,'getattr_list() takes only one optional argument'
1984 else:
1984 else:
1985 return map(lambda attr: getattr(obj,attr),alist)
1985 return map(lambda attr: getattr(obj,attr),alist)
1986
1986
1987 #----------------------------------------------------------------------------
1987 #----------------------------------------------------------------------------
1988 def map_method(method,object_list,*argseq,**kw):
1988 def map_method(method,object_list,*argseq,**kw):
1989 """map_method(method,object_list,*args,**kw) -> list
1989 """map_method(method,object_list,*args,**kw) -> list
1990
1990
1991 Return a list of the results of applying the methods to the items of the
1991 Return a list of the results of applying the methods to the items of the
1992 argument sequence(s). If more than one sequence is given, the method is
1992 argument sequence(s). If more than one sequence is given, the method is
1993 called with an argument list consisting of the corresponding item of each
1993 called with an argument list consisting of the corresponding item of each
1994 sequence. All sequences must be of the same length.
1994 sequence. All sequences must be of the same length.
1995
1995
1996 Keyword arguments are passed verbatim to all objects called.
1996 Keyword arguments are passed verbatim to all objects called.
1997
1997
1998 This is Python code, so it's not nearly as fast as the builtin map()."""
1998 This is Python code, so it's not nearly as fast as the builtin map()."""
1999
1999
2000 out_list = []
2000 out_list = []
2001 idx = 0
2001 idx = 0
2002 for object in object_list:
2002 for object in object_list:
2003 try:
2003 try:
2004 handler = getattr(object, method)
2004 handler = getattr(object, method)
2005 except AttributeError:
2005 except AttributeError:
2006 out_list.append(None)
2006 out_list.append(None)
2007 else:
2007 else:
2008 if argseq:
2008 if argseq:
2009 args = map(lambda lst:lst[idx],argseq)
2009 args = map(lambda lst:lst[idx],argseq)
2010 #print 'ob',object,'hand',handler,'ar',args # dbg
2010 #print 'ob',object,'hand',handler,'ar',args # dbg
2011 out_list.append(handler(args,**kw))
2011 out_list.append(handler(args,**kw))
2012 else:
2012 else:
2013 out_list.append(handler(**kw))
2013 out_list.append(handler(**kw))
2014 idx += 1
2014 idx += 1
2015 return out_list
2015 return out_list
2016
2016
2017 #----------------------------------------------------------------------------
2017 #----------------------------------------------------------------------------
2018 def get_class_members(cls):
2018 def get_class_members(cls):
2019 ret = dir(cls)
2019 ret = dir(cls)
2020 if hasattr(cls,'__bases__'):
2020 if hasattr(cls,'__bases__'):
2021 for base in cls.__bases__:
2021 for base in cls.__bases__:
2022 ret.extend(get_class_members(base))
2022 ret.extend(get_class_members(base))
2023 return ret
2023 return ret
2024
2024
2025 #----------------------------------------------------------------------------
2025 #----------------------------------------------------------------------------
2026 def dir2(obj):
2026 def dir2(obj):
2027 """dir2(obj) -> list of strings
2027 """dir2(obj) -> list of strings
2028
2028
2029 Extended version of the Python builtin dir(), which does a few extra
2029 Extended version of the Python builtin dir(), which does a few extra
2030 checks, and supports common objects with unusual internals that confuse
2030 checks, and supports common objects with unusual internals that confuse
2031 dir(), such as Traits and PyCrust.
2031 dir(), such as Traits and PyCrust.
2032
2032
2033 This version is guaranteed to return only a list of true strings, whereas
2033 This version is guaranteed to return only a list of true strings, whereas
2034 dir() returns anything that objects inject into themselves, even if they
2034 dir() returns anything that objects inject into themselves, even if they
2035 are later not really valid for attribute access (many extension libraries
2035 are later not really valid for attribute access (many extension libraries
2036 have such bugs).
2036 have such bugs).
2037 """
2037 """
2038
2038
2039 # Start building the attribute list via dir(), and then complete it
2039 # Start building the attribute list via dir(), and then complete it
2040 # with a few extra special-purpose calls.
2040 # with a few extra special-purpose calls.
2041 words = dir(obj)
2041 words = dir(obj)
2042
2042
2043 if hasattr(obj,'__class__'):
2043 if hasattr(obj,'__class__'):
2044 words.append('__class__')
2044 words.append('__class__')
2045 words.extend(get_class_members(obj.__class__))
2045 words.extend(get_class_members(obj.__class__))
2046 #if '__base__' in words: 1/0
2046 #if '__base__' in words: 1/0
2047
2047
2048 # Some libraries (such as traits) may introduce duplicates, we want to
2048 # Some libraries (such as traits) may introduce duplicates, we want to
2049 # track and clean this up if it happens
2049 # track and clean this up if it happens
2050 may_have_dupes = False
2050 may_have_dupes = False
2051
2051
2052 # this is the 'dir' function for objects with Enthought's traits
2052 # this is the 'dir' function for objects with Enthought's traits
2053 if hasattr(obj, 'trait_names'):
2053 if hasattr(obj, 'trait_names'):
2054 try:
2054 try:
2055 words.extend(obj.trait_names())
2055 words.extend(obj.trait_names())
2056 may_have_dupes = True
2056 may_have_dupes = True
2057 except TypeError:
2057 except TypeError:
2058 # This will happen if `obj` is a class and not an instance.
2058 # This will happen if `obj` is a class and not an instance.
2059 pass
2059 pass
2060
2060
2061 # Support for PyCrust-style _getAttributeNames magic method.
2061 # Support for PyCrust-style _getAttributeNames magic method.
2062 if hasattr(obj, '_getAttributeNames'):
2062 if hasattr(obj, '_getAttributeNames'):
2063 try:
2063 try:
2064 words.extend(obj._getAttributeNames())
2064 words.extend(obj._getAttributeNames())
2065 may_have_dupes = True
2065 may_have_dupes = True
2066 except TypeError:
2066 except TypeError:
2067 # `obj` is a class and not an instance. Ignore
2067 # `obj` is a class and not an instance. Ignore
2068 # this error.
2068 # this error.
2069 pass
2069 pass
2070
2070
2071 if may_have_dupes:
2071 if may_have_dupes:
2072 # eliminate possible duplicates, as some traits may also
2072 # eliminate possible duplicates, as some traits may also
2073 # appear as normal attributes in the dir() call.
2073 # appear as normal attributes in the dir() call.
2074 words = list(set(words))
2074 words = list(set(words))
2075 words.sort()
2075 words.sort()
2076
2076
2077 # filter out non-string attributes which may be stuffed by dir() calls
2077 # filter out non-string attributes which may be stuffed by dir() calls
2078 # and poor coding in third-party modules
2078 # and poor coding in third-party modules
2079 return [w for w in words if isinstance(w, basestring)]
2079 return [w for w in words if isinstance(w, basestring)]
2080
2080
2081 #----------------------------------------------------------------------------
2081 #----------------------------------------------------------------------------
2082 def import_fail_info(mod_name,fns=None):
2082 def import_fail_info(mod_name,fns=None):
2083 """Inform load failure for a module."""
2083 """Inform load failure for a module."""
2084
2084
2085 if fns == None:
2085 if fns == None:
2086 warn("Loading of %s failed.\n" % (mod_name,))
2086 warn("Loading of %s failed.\n" % (mod_name,))
2087 else:
2087 else:
2088 warn("Loading of %s from %s failed.\n" % (fns,mod_name))
2088 warn("Loading of %s from %s failed.\n" % (fns,mod_name))
2089
2089
2090 #----------------------------------------------------------------------------
2090 #----------------------------------------------------------------------------
2091 # Proposed popitem() extension, written as a method
2091 # Proposed popitem() extension, written as a method
2092
2092
2093
2093
2094 class NotGiven: pass
2094 class NotGiven: pass
2095
2095
2096 def popkey(dct,key,default=NotGiven):
2096 def popkey(dct,key,default=NotGiven):
2097 """Return dct[key] and delete dct[key].
2097 """Return dct[key] and delete dct[key].
2098
2098
2099 If default is given, return it if dct[key] doesn't exist, otherwise raise
2099 If default is given, return it if dct[key] doesn't exist, otherwise raise
2100 KeyError. """
2100 KeyError. """
2101
2101
2102 try:
2102 try:
2103 val = dct[key]
2103 val = dct[key]
2104 except KeyError:
2104 except KeyError:
2105 if default is NotGiven:
2105 if default is NotGiven:
2106 raise
2106 raise
2107 else:
2107 else:
2108 return default
2108 return default
2109 else:
2109 else:
2110 del dct[key]
2110 del dct[key]
2111 return val
2111 return val
2112
2112
2113 def wrap_deprecated(func, suggest = '<nothing>'):
2113 def wrap_deprecated(func, suggest = '<nothing>'):
2114 def newFunc(*args, **kwargs):
2114 def newFunc(*args, **kwargs):
2115 warnings.warn("Call to deprecated function %s, use %s instead" %
2115 warnings.warn("Call to deprecated function %s, use %s instead" %
2116 ( func.__name__, suggest),
2116 ( func.__name__, suggest),
2117 category=DeprecationWarning,
2117 category=DeprecationWarning,
2118 stacklevel = 2)
2118 stacklevel = 2)
2119 return func(*args, **kwargs)
2119 return func(*args, **kwargs)
2120 return newFunc
2120 return newFunc
2121
2121
2122
2122
2123 def _num_cpus_unix():
2123 def _num_cpus_unix():
2124 """Return the number of active CPUs on a Unix system."""
2124 """Return the number of active CPUs on a Unix system."""
2125 return os.sysconf("SC_NPROCESSORS_ONLN")
2125 return os.sysconf("SC_NPROCESSORS_ONLN")
2126
2126
2127
2127
2128 def _num_cpus_darwin():
2128 def _num_cpus_darwin():
2129 """Return the number of active CPUs on a Darwin system."""
2129 """Return the number of active CPUs on a Darwin system."""
2130 p = subprocess.Popen(['sysctl','-n','hw.ncpu'],stdout=subprocess.PIPE)
2130 p = subprocess.Popen(['sysctl','-n','hw.ncpu'],stdout=subprocess.PIPE)
2131 return p.stdout.read()
2131 return p.stdout.read()
2132
2132
2133
2133
2134 def _num_cpus_windows():
2134 def _num_cpus_windows():
2135 """Return the number of active CPUs on a Windows system."""
2135 """Return the number of active CPUs on a Windows system."""
2136 return os.environ.get("NUMBER_OF_PROCESSORS")
2136 return os.environ.get("NUMBER_OF_PROCESSORS")
2137
2137
2138
2138
2139 def num_cpus():
2139 def num_cpus():
2140 """Return the effective number of CPUs in the system as an integer.
2140 """Return the effective number of CPUs in the system as an integer.
2141
2141
2142 This cross-platform function makes an attempt at finding the total number of
2142 This cross-platform function makes an attempt at finding the total number of
2143 available CPUs in the system, as returned by various underlying system and
2143 available CPUs in the system, as returned by various underlying system and
2144 python calls.
2144 python calls.
2145
2145
2146 If it can't find a sensible answer, it returns 1 (though an error *may* make
2146 If it can't find a sensible answer, it returns 1 (though an error *may* make
2147 it return a large positive number that's actually incorrect).
2147 it return a large positive number that's actually incorrect).
2148 """
2148 """
2149
2149
2150 # Many thanks to the Parallel Python project (http://www.parallelpython.com)
2150 # Many thanks to the Parallel Python project (http://www.parallelpython.com)
2151 # for the names of the keys we needed to look up for this function. This
2151 # for the names of the keys we needed to look up for this function. This
2152 # code was inspired by their equivalent function.
2152 # code was inspired by their equivalent function.
2153
2153
2154 ncpufuncs = {'Linux':_num_cpus_unix,
2154 ncpufuncs = {'Linux':_num_cpus_unix,
2155 'Darwin':_num_cpus_darwin,
2155 'Darwin':_num_cpus_darwin,
2156 'Windows':_num_cpus_windows,
2156 'Windows':_num_cpus_windows,
2157 # On Vista, python < 2.5.2 has a bug and returns 'Microsoft'
2157 # On Vista, python < 2.5.2 has a bug and returns 'Microsoft'
2158 # See http://bugs.python.org/issue1082 for details.
2158 # See http://bugs.python.org/issue1082 for details.
2159 'Microsoft':_num_cpus_windows,
2159 'Microsoft':_num_cpus_windows,
2160 }
2160 }
2161
2161
2162 ncpufunc = ncpufuncs.get(platform.system(),
2162 ncpufunc = ncpufuncs.get(platform.system(),
2163 # default to unix version (Solaris, AIX, etc)
2163 # default to unix version (Solaris, AIX, etc)
2164 _num_cpus_unix)
2164 _num_cpus_unix)
2165
2165
2166 try:
2166 try:
2167 ncpus = max(1,int(ncpufunc()))
2167 ncpus = max(1,int(ncpufunc()))
2168 except:
2168 except:
2169 ncpus = 1
2169 ncpus = 1
2170 return ncpus
2170 return ncpus
2171
2171
2172 #*************************** end of file <genutils.py> **********************
2172 #*************************** end of file <genutils.py> **********************
General Comments 0
You need to be logged in to leave comments. Login now