##// END OF EJS Templates
genutils.py => utils/genutils.py and updated imports and tests.
Brian Granger -
Show More

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

@@ -1,253 +1,253 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Modified input prompt for executing files.
2 """Modified input prompt for executing files.
3
3
4 We define a special input line filter to allow typing lines which begin with
4 We define a special input line filter to allow typing lines which begin with
5 '~', '/' or '.'. If one of those strings is encountered, it is automatically
5 '~', '/' or '.'. If one of those strings is encountered, it is automatically
6 executed.
6 executed.
7 """
7 """
8
8
9 #*****************************************************************************
9 #*****************************************************************************
10 # Copyright (C) 2004 W.J. van der Laan <gnufnork@hetdigitalegat.nl>
10 # Copyright (C) 2004 W.J. van der Laan <gnufnork@hetdigitalegat.nl>
11 # Copyright (C) 2004-2006 Fernando Perez <fperez@colorado.edu>
11 # Copyright (C) 2004-2006 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 # TODO: deprecated
17 # TODO: deprecated
18 def prefilter_shell(self,line,continuation):
18 def prefilter_shell(self,line,continuation):
19 """Alternate prefilter, modified for shell-like functionality.
19 """Alternate prefilter, modified for shell-like functionality.
20
20
21 - Execute all lines beginning with '~', '/' or '.'
21 - Execute all lines beginning with '~', '/' or '.'
22 - $var=cmd <=> %sc var=cmd
22 - $var=cmd <=> %sc var=cmd
23 - $$var=cmd <=> %sc -l var=cmd
23 - $$var=cmd <=> %sc -l var=cmd
24 """
24 """
25
25
26 if line:
26 if line:
27 l0 = line[0]
27 l0 = line[0]
28 if l0 in '~/.':
28 if l0 in '~/.':
29 return self._prefilter("!%s"%line,continuation)
29 return self._prefilter("!%s"%line,continuation)
30 elif l0=='$':
30 elif l0=='$':
31 lrest = line[1:]
31 lrest = line[1:]
32 if lrest.startswith('$'):
32 if lrest.startswith('$'):
33 # $$var=cmd <=> %sc -l var=cmd
33 # $$var=cmd <=> %sc -l var=cmd
34 return self._prefilter("%ssc -l %s" % (self.ESC_MAGIC,lrest[1:]),
34 return self._prefilter("%ssc -l %s" % (self.ESC_MAGIC,lrest[1:]),
35 continuation)
35 continuation)
36 else:
36 else:
37 # $var=cmd <=> %sc var=cmd
37 # $var=cmd <=> %sc var=cmd
38 return self._prefilter("%ssc %s" % (self.ESC_MAGIC,lrest),
38 return self._prefilter("%ssc %s" % (self.ESC_MAGIC,lrest),
39 continuation)
39 continuation)
40 else:
40 else:
41 return self._prefilter(line,continuation)
41 return self._prefilter(line,continuation)
42 else:
42 else:
43 return self._prefilter(line,continuation)
43 return self._prefilter(line,continuation)
44
44
45 # Rebind this to be the new IPython prefilter:
45 # Rebind this to be the new IPython prefilter:
46 from IPython.iplib import InteractiveShell
46 from IPython.iplib import InteractiveShell
47 InteractiveShell.prefilter = prefilter_shell
47 InteractiveShell.prefilter = prefilter_shell
48 # Clean up the namespace.
48 # Clean up the namespace.
49 del InteractiveShell,prefilter_shell
49 del InteractiveShell,prefilter_shell
50
50
51 # Provide pysh and further shell-oriented services
51 # Provide pysh and further shell-oriented services
52 import os,sys,shutil
52 import os,sys,shutil
53 from IPython.genutils import system,shell,getoutput,getoutputerror
53 from IPython.utils.genutils import system,shell,getoutput,getoutputerror
54
54
55 # Short aliases for getting shell output as a string and a list
55 # Short aliases for getting shell output as a string and a list
56 sout = getoutput
56 sout = getoutput
57 lout = lambda cmd: getoutput(cmd,split=1)
57 lout = lambda cmd: getoutput(cmd,split=1)
58
58
59 # Empty function, meant as a docstring holder so help(pysh) works.
59 # Empty function, meant as a docstring holder so help(pysh) works.
60 def pysh():
60 def pysh():
61 """Pysh is a set of modules and extensions to IPython which make shell-like
61 """Pysh is a set of modules and extensions to IPython which make shell-like
62 usage with Python syntax more convenient. Keep in mind that pysh is NOT a
62 usage with Python syntax more convenient. Keep in mind that pysh is NOT a
63 full-blown shell, so don't try to make it your /etc/passwd entry!
63 full-blown shell, so don't try to make it your /etc/passwd entry!
64
64
65 In particular, it has no job control, so if you type Ctrl-Z (under Unix),
65 In particular, it has no job control, so if you type Ctrl-Z (under Unix),
66 you'll suspend pysh itself, not the process you just started.
66 you'll suspend pysh itself, not the process you just started.
67
67
68 Since pysh is really nothing but a customized IPython, you should
68 Since pysh is really nothing but a customized IPython, you should
69 familiarize yourself with IPython's features. This brief help mainly
69 familiarize yourself with IPython's features. This brief help mainly
70 documents areas in which pysh differs from the normal IPython.
70 documents areas in which pysh differs from the normal IPython.
71
71
72 ALIASES
72 ALIASES
73 -------
73 -------
74 All of your $PATH has been loaded as IPython aliases, so you should be
74 All of your $PATH has been loaded as IPython aliases, so you should be
75 able to type any normal system command and have it executed. See %alias?
75 able to type any normal system command and have it executed. See %alias?
76 and %unalias? for details on the alias facilities.
76 and %unalias? for details on the alias facilities.
77
77
78 SPECIAL SYNTAX
78 SPECIAL SYNTAX
79 --------------
79 --------------
80 Any lines which begin with '~', '/' and '.' will be executed as shell
80 Any lines which begin with '~', '/' and '.' will be executed as shell
81 commands instead of as Python code. The special escapes below are also
81 commands instead of as Python code. The special escapes below are also
82 recognized. !cmd is valid in single or multi-line input, all others are
82 recognized. !cmd is valid in single or multi-line input, all others are
83 only valid in single-line input:
83 only valid in single-line input:
84
84
85 !cmd - pass 'cmd' directly to the shell
85 !cmd - pass 'cmd' directly to the shell
86 !!cmd - execute 'cmd' and return output as a list (split on '\\n')
86 !!cmd - execute 'cmd' and return output as a list (split on '\\n')
87 $var=cmd - capture output of cmd into var, as a string
87 $var=cmd - capture output of cmd into var, as a string
88 $$var=cmd - capture output of cmd into var, as a list (split on '\\n')
88 $$var=cmd - capture output of cmd into var, as a list (split on '\\n')
89
89
90 The $/$$ syntaxes make Python variables from system output, which you can
90 The $/$$ syntaxes make Python variables from system output, which you can
91 later use for further scripting. The converse is also possible: when
91 later use for further scripting. The converse is also possible: when
92 executing an alias or calling to the system via !/!!, you can expand any
92 executing an alias or calling to the system via !/!!, you can expand any
93 python variable or expression by prepending it with $. Full details of
93 python variable or expression by prepending it with $. Full details of
94 the allowed syntax can be found in Python's PEP 215.
94 the allowed syntax can be found in Python's PEP 215.
95
95
96 A few brief examples will illustrate these:
96 A few brief examples will illustrate these:
97
97
98 fperez[~/test]|3> !ls *s.py
98 fperez[~/test]|3> !ls *s.py
99 scopes.py strings.py
99 scopes.py strings.py
100
100
101 ls is an internal alias, so there's no need to use !:
101 ls is an internal alias, so there's no need to use !:
102 fperez[~/test]|4> ls *s.py
102 fperez[~/test]|4> ls *s.py
103 scopes.py* strings.py
103 scopes.py* strings.py
104
104
105 !!ls will return the output into a Python variable:
105 !!ls will return the output into a Python variable:
106 fperez[~/test]|5> !!ls *s.py
106 fperez[~/test]|5> !!ls *s.py
107 <5> ['scopes.py', 'strings.py']
107 <5> ['scopes.py', 'strings.py']
108 fperez[~/test]|6> print _5
108 fperez[~/test]|6> print _5
109 ['scopes.py', 'strings.py']
109 ['scopes.py', 'strings.py']
110
110
111 $ and $$ allow direct capture to named variables:
111 $ and $$ allow direct capture to named variables:
112 fperez[~/test]|7> $astr = ls *s.py
112 fperez[~/test]|7> $astr = ls *s.py
113 fperez[~/test]|8> astr
113 fperez[~/test]|8> astr
114 <8> 'scopes.py\\nstrings.py'
114 <8> 'scopes.py\\nstrings.py'
115
115
116 fperez[~/test]|9> $$alist = ls *s.py
116 fperez[~/test]|9> $$alist = ls *s.py
117 fperez[~/test]|10> alist
117 fperez[~/test]|10> alist
118 <10> ['scopes.py', 'strings.py']
118 <10> ['scopes.py', 'strings.py']
119
119
120 alist is now a normal python list you can loop over. Using $ will expand
120 alist is now a normal python list you can loop over. Using $ will expand
121 back the python values when alias calls are made:
121 back the python values when alias calls are made:
122 fperez[~/test]|11> for f in alist:
122 fperez[~/test]|11> for f in alist:
123 |..> print 'file',f,
123 |..> print 'file',f,
124 |..> wc -l $f
124 |..> wc -l $f
125 |..>
125 |..>
126 file scopes.py 13 scopes.py
126 file scopes.py 13 scopes.py
127 file strings.py 4 strings.py
127 file strings.py 4 strings.py
128
128
129 Note that you may need to protect your variables with braces if you want
129 Note that you may need to protect your variables with braces if you want
130 to append strings to their names. To copy all files in alist to .bak
130 to append strings to their names. To copy all files in alist to .bak
131 extensions, you must use:
131 extensions, you must use:
132 fperez[~/test]|12> for f in alist:
132 fperez[~/test]|12> for f in alist:
133 |..> cp $f ${f}.bak
133 |..> cp $f ${f}.bak
134
134
135 If you try using $f.bak, you'll get an AttributeError exception saying
135 If you try using $f.bak, you'll get an AttributeError exception saying
136 that your string object doesn't have a .bak attribute. This is because
136 that your string object doesn't have a .bak attribute. This is because
137 the $ expansion mechanism allows you to expand full Python expressions:
137 the $ expansion mechanism allows you to expand full Python expressions:
138 fperez[~/test]|13> echo "sys.platform is: $sys.platform"
138 fperez[~/test]|13> echo "sys.platform is: $sys.platform"
139 sys.platform is: linux2
139 sys.platform is: linux2
140
140
141 IPython's input history handling is still active, which allows you to
141 IPython's input history handling is still active, which allows you to
142 rerun a single block of multi-line input by simply using exec:
142 rerun a single block of multi-line input by simply using exec:
143 fperez[~/test]|14> $$alist = ls *.eps
143 fperez[~/test]|14> $$alist = ls *.eps
144 fperez[~/test]|15> exec _i11
144 fperez[~/test]|15> exec _i11
145 file image2.eps 921 image2.eps
145 file image2.eps 921 image2.eps
146 file image.eps 921 image.eps
146 file image.eps 921 image.eps
147
147
148 While these are new special-case syntaxes, they are designed to allow very
148 While these are new special-case syntaxes, they are designed to allow very
149 efficient use of the shell with minimal typing. At an interactive shell
149 efficient use of the shell with minimal typing. At an interactive shell
150 prompt, conciseness of expression wins over readability.
150 prompt, conciseness of expression wins over readability.
151
151
152 USEFUL FUNCTIONS AND MODULES
152 USEFUL FUNCTIONS AND MODULES
153 ----------------------------
153 ----------------------------
154 The os, sys and shutil modules from the Python standard library are
154 The os, sys and shutil modules from the Python standard library are
155 automatically loaded. Some additional functions, useful for shell usage,
155 automatically loaded. Some additional functions, useful for shell usage,
156 are listed below. You can request more help about them with '?'.
156 are listed below. You can request more help about them with '?'.
157
157
158 shell - execute a command in the underlying system shell
158 shell - execute a command in the underlying system shell
159 system - like shell(), but return the exit status of the command
159 system - like shell(), but return the exit status of the command
160 sout - capture the output of a command as a string
160 sout - capture the output of a command as a string
161 lout - capture the output of a command as a list (split on '\\n')
161 lout - capture the output of a command as a list (split on '\\n')
162 getoutputerror - capture (output,error) of a shell command
162 getoutputerror - capture (output,error) of a shell command
163
163
164 sout/lout are the functional equivalents of $/$$. They are provided to
164 sout/lout are the functional equivalents of $/$$. They are provided to
165 allow you to capture system output in the middle of true python code,
165 allow you to capture system output in the middle of true python code,
166 function definitions, etc (where $ and $$ are invalid).
166 function definitions, etc (where $ and $$ are invalid).
167
167
168 DIRECTORY MANAGEMENT
168 DIRECTORY MANAGEMENT
169 --------------------
169 --------------------
170 Since each command passed by pysh to the underlying system is executed in
170 Since each command passed by pysh to the underlying system is executed in
171 a subshell which exits immediately, you can NOT use !cd to navigate the
171 a subshell which exits immediately, you can NOT use !cd to navigate the
172 filesystem.
172 filesystem.
173
173
174 Pysh provides its own builtin '%cd' magic command to move in the
174 Pysh provides its own builtin '%cd' magic command to move in the
175 filesystem (the % is not required with automagic on). It also maintains a
175 filesystem (the % is not required with automagic on). It also maintains a
176 list of visited directories (use %dhist to see it) and allows direct
176 list of visited directories (use %dhist to see it) and allows direct
177 switching to any of them. Type 'cd?' for more details.
177 switching to any of them. Type 'cd?' for more details.
178
178
179 %pushd, %popd and %dirs are provided for directory stack handling.
179 %pushd, %popd and %dirs are provided for directory stack handling.
180
180
181 PROMPT CUSTOMIZATION
181 PROMPT CUSTOMIZATION
182 --------------------
182 --------------------
183
183
184 The supplied ipythonrc-pysh profile comes with an example of a very
184 The supplied ipythonrc-pysh profile comes with an example of a very
185 colored and detailed prompt, mainly to serve as an illustration. The
185 colored and detailed prompt, mainly to serve as an illustration. The
186 valid escape sequences, besides color names, are:
186 valid escape sequences, besides color names, are:
187
187
188 \\# - Prompt number.
188 \\# - Prompt number.
189 \\D - Dots, as many as there are digits in \\# (so they align).
189 \\D - Dots, as many as there are digits in \\# (so they align).
190 \\w - Current working directory (cwd).
190 \\w - Current working directory (cwd).
191 \\W - Basename of current working directory.
191 \\W - Basename of current working directory.
192 \\XN - Where N=0..5. N terms of the cwd, with $HOME written as ~.
192 \\XN - Where N=0..5. N terms of the cwd, with $HOME written as ~.
193 \\YN - Where N=0..5. Like XN, but if ~ is term N+1 it's also shown.
193 \\YN - Where N=0..5. Like XN, but if ~ is term N+1 it's also shown.
194 \\u - Username.
194 \\u - Username.
195 \\H - Full hostname.
195 \\H - Full hostname.
196 \\h - Hostname up to first '.'
196 \\h - Hostname up to first '.'
197 \\$ - Root symbol ($ or #).
197 \\$ - Root symbol ($ or #).
198 \\t - Current time, in H:M:S format.
198 \\t - Current time, in H:M:S format.
199 \\v - IPython release version.
199 \\v - IPython release version.
200 \\n - Newline.
200 \\n - Newline.
201 \\r - Carriage return.
201 \\r - Carriage return.
202 \\\\ - An explicitly escaped '\\'.
202 \\\\ - An explicitly escaped '\\'.
203
203
204 You can configure your prompt colors using any ANSI color escape. Each
204 You can configure your prompt colors using any ANSI color escape. Each
205 color escape sets the color for any subsequent text, until another escape
205 color escape sets the color for any subsequent text, until another escape
206 comes in and changes things. The valid color escapes are:
206 comes in and changes things. The valid color escapes are:
207
207
208 \\C_Black
208 \\C_Black
209 \\C_Blue
209 \\C_Blue
210 \\C_Brown
210 \\C_Brown
211 \\C_Cyan
211 \\C_Cyan
212 \\C_DarkGray
212 \\C_DarkGray
213 \\C_Green
213 \\C_Green
214 \\C_LightBlue
214 \\C_LightBlue
215 \\C_LightCyan
215 \\C_LightCyan
216 \\C_LightGray
216 \\C_LightGray
217 \\C_LightGreen
217 \\C_LightGreen
218 \\C_LightPurple
218 \\C_LightPurple
219 \\C_LightRed
219 \\C_LightRed
220 \\C_Purple
220 \\C_Purple
221 \\C_Red
221 \\C_Red
222 \\C_White
222 \\C_White
223 \\C_Yellow
223 \\C_Yellow
224 \\C_Normal - Stop coloring, defaults to your terminal settings.
224 \\C_Normal - Stop coloring, defaults to your terminal settings.
225 """
225 """
226 pass
226 pass
227
227
228 # Configure a few things. Much of this is fairly hackish, since IPython
228 # Configure a few things. Much of this is fairly hackish, since IPython
229 # doesn't really expose a clean API for it. Be careful if you start making
229 # doesn't really expose a clean API for it. Be careful if you start making
230 # many modifications here.
230 # many modifications here.
231
231
232
232
233 # Set the 'cd' command to quiet mode, a more shell-like behavior
233 # Set the 'cd' command to quiet mode, a more shell-like behavior
234 __IPYTHON__.default_option('cd','-q')
234 __IPYTHON__.default_option('cd','-q')
235
235
236 # This is redundant, ipy_user_conf.py will determine this
236 # This is redundant, ipy_user_conf.py will determine this
237 # Load all of $PATH as aliases
237 # Load all of $PATH as aliases
238 __IPYTHON__.magic_rehashx()
238 __IPYTHON__.magic_rehashx()
239
239
240 # Remove %sc,%sx if present as aliases
240 # Remove %sc,%sx if present as aliases
241 __IPYTHON__.magic_unalias('sc')
241 __IPYTHON__.magic_unalias('sc')
242 __IPYTHON__.magic_unalias('sx')
242 __IPYTHON__.magic_unalias('sx')
243
243
244 # We need different criteria for line-splitting, so that aliases such as
244 # We need different criteria for line-splitting, so that aliases such as
245 # 'gnome-terminal' are interpreted as a single alias instead of variable
245 # 'gnome-terminal' are interpreted as a single alias instead of variable
246 # 'gnome' minus variable 'terminal'.
246 # 'gnome' minus variable 'terminal'.
247 import re
247 import re
248 __IPYTHON__.line_split = re.compile(r'^([\s*,;/])'
248 __IPYTHON__.line_split = re.compile(r'^([\s*,;/])'
249 r'([\?\w\.\-\+]+\w*\s*)'
249 r'([\?\w\.\-\+]+\w*\s*)'
250 r'(\(?.*$)')
250 r'(\(?.*$)')
251
251
252 # Namespace cleanup
252 # Namespace cleanup
253 del re
253 del re
@@ -1,63 +1,63 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """ IPython extension: new prefilters for output grabbing
2 """ IPython extension: new prefilters for output grabbing
3
3
4 Provides
4 Provides
5
5
6 var = %magic blah blah
6 var = %magic blah blah
7
7
8 var = !ls
8 var = !ls
9 """
9 """
10
10
11 import IPython.ipapi
11 import IPython.ipapi
12 from IPython.genutils import *
12 from IPython.utils.genutils import *
13
13
14 ip = IPython.ipapi.get()
14 ip = IPython.ipapi.get()
15
15
16 import re
16 import re
17
17
18 def hnd_magic(line,mo):
18 def hnd_magic(line,mo):
19 """ Handle a = %mymagic blah blah """
19 """ Handle a = %mymagic blah blah """
20 #cmd = genutils.make_quoted_expr(mo.group('syscmd'))
20 #cmd = genutils.make_quoted_expr(mo.group('syscmd'))
21 #mag = 'ipmagic
21 #mag = 'ipmagic
22 #return "%s = %s"
22 #return "%s = %s"
23 var = mo.group('varname')
23 var = mo.group('varname')
24 cmd = mo.group('cmd')
24 cmd = mo.group('cmd')
25 expr = make_quoted_expr(cmd)
25 expr = make_quoted_expr(cmd)
26 return itpl('$var = _ip.magic($expr)')
26 return itpl('$var = _ip.magic($expr)')
27
27
28 def hnd_syscmd(line,mo):
28 def hnd_syscmd(line,mo):
29 """ Handle a = !ls """
29 """ Handle a = !ls """
30 #cmd = genutils.make_quoted_expr(mo.group('syscmd'))
30 #cmd = genutils.make_quoted_expr(mo.group('syscmd'))
31 #mag = 'ipmagic
31 #mag = 'ipmagic
32 #return "%s = %s"
32 #return "%s = %s"
33 var = mo.group('varname')
33 var = mo.group('varname')
34 cmd = mo.group('cmd')
34 cmd = mo.group('cmd')
35 expr = make_quoted_expr(itpl("sc -l =$cmd"))
35 expr = make_quoted_expr(itpl("sc -l =$cmd"))
36 return itpl('$var = _ip.magic($expr)')
36 return itpl('$var = _ip.magic($expr)')
37
37
38 def install_re_handler(pat, hnd):
38 def install_re_handler(pat, hnd):
39 ip.meta.re_prefilters.append((re.compile(pat), hnd))
39 ip.meta.re_prefilters.append((re.compile(pat), hnd))
40
40
41 def init_handlers():
41 def init_handlers():
42
42
43 ip.meta.re_prefilters = []
43 ip.meta.re_prefilters = []
44
44
45 install_re_handler('(?P<varname>[\w\.]+)\s*=\s*%(?P<cmd>.*)',
45 install_re_handler('(?P<varname>[\w\.]+)\s*=\s*%(?P<cmd>.*)',
46 hnd_magic
46 hnd_magic
47 )
47 )
48
48
49 install_re_handler('(?P<varname>[\w\.]+)\s*=\s*!(?P<cmd>.*)',
49 install_re_handler('(?P<varname>[\w\.]+)\s*=\s*!(?P<cmd>.*)',
50 hnd_syscmd
50 hnd_syscmd
51 )
51 )
52
52
53 init_handlers()
53 init_handlers()
54
54
55 def regex_prefilter_f(self,line):
55 def regex_prefilter_f(self,line):
56 for pat, handler in ip.meta.re_prefilters:
56 for pat, handler in ip.meta.re_prefilters:
57 mo = pat.match(line)
57 mo = pat.match(line)
58 if mo:
58 if mo:
59 return handler(line,mo)
59 return handler(line,mo)
60
60
61 raise IPython.ipapi.TryNext
61 raise IPython.ipapi.TryNext
62
62
63 ip.set_hook('input_prefilter', regex_prefilter_f)
63 ip.set_hook('input_prefilter', regex_prefilter_f)
@@ -1,2328 +1,2328 b''
1 # -*- coding: iso-8859-1 -*-
1 # -*- coding: iso-8859-1 -*-
2
2
3 """
3 """
4 ``ipipe`` provides classes to be used in an interactive Python session. Doing a
4 ``ipipe`` provides classes to be used in an interactive Python session. Doing a
5 ``from ipipe import *`` is the preferred way to do this. The name of all
5 ``from ipipe import *`` is the preferred way to do this. The name of all
6 objects imported this way starts with ``i`` to minimize collisions.
6 objects imported this way starts with ``i`` to minimize collisions.
7
7
8 ``ipipe`` supports "pipeline expressions", which is something resembling Unix
8 ``ipipe`` supports "pipeline expressions", which is something resembling Unix
9 pipes. An example is::
9 pipes. An example is::
10
10
11 >>> ienv | isort("key.lower()")
11 >>> ienv | isort("key.lower()")
12
12
13 This gives a listing of all environment variables sorted by name.
13 This gives a listing of all environment variables sorted by name.
14
14
15
15
16 There are three types of objects in a pipeline expression:
16 There are three types of objects in a pipeline expression:
17
17
18 * ``Table``s: These objects produce items. Examples are ``ils`` (listing the
18 * ``Table``s: These objects produce items. Examples are ``ils`` (listing the
19 current directory, ``ienv`` (listing environment variables), ``ipwd`` (listing
19 current directory, ``ienv`` (listing environment variables), ``ipwd`` (listing
20 user accounts) and ``igrp`` (listing user groups). A ``Table`` must be the
20 user accounts) and ``igrp`` (listing user groups). A ``Table`` must be the
21 first object in a pipe expression.
21 first object in a pipe expression.
22
22
23 * ``Pipe``s: These objects sit in the middle of a pipe expression. They
23 * ``Pipe``s: These objects sit in the middle of a pipe expression. They
24 transform the input in some way (e.g. filtering or sorting it). Examples are:
24 transform the input in some way (e.g. filtering or sorting it). Examples are:
25 ``ifilter`` (which filters the input pipe), ``isort`` (which sorts the input
25 ``ifilter`` (which filters the input pipe), ``isort`` (which sorts the input
26 pipe) and ``ieval`` (which evaluates a function or expression for each object
26 pipe) and ``ieval`` (which evaluates a function or expression for each object
27 in the input pipe).
27 in the input pipe).
28
28
29 * ``Display``s: These objects can be put as the last object in a pipeline
29 * ``Display``s: These objects can be put as the last object in a pipeline
30 expression. There are responsible for displaying the result of the pipeline
30 expression. There are responsible for displaying the result of the pipeline
31 expression. If a pipeline expression doesn't end in a display object a default
31 expression. If a pipeline expression doesn't end in a display object a default
32 display objects will be used. One example is ``ibrowse`` which is a ``curses``
32 display objects will be used. One example is ``ibrowse`` which is a ``curses``
33 based browser.
33 based browser.
34
34
35
35
36 Adding support for pipeline expressions to your own objects can be done through
36 Adding support for pipeline expressions to your own objects can be done through
37 three extensions points (all of them optional):
37 three extensions points (all of them optional):
38
38
39 * An object that will be displayed as a row by a ``Display`` object should
39 * An object that will be displayed as a row by a ``Display`` object should
40 implement the method ``__xattrs__(self, mode)`` method or register an
40 implement the method ``__xattrs__(self, mode)`` method or register an
41 implementation of the generic function ``xattrs``. For more info see ``xattrs``.
41 implementation of the generic function ``xattrs``. For more info see ``xattrs``.
42
42
43 * When an object ``foo`` is displayed by a ``Display`` object, the generic
43 * When an object ``foo`` is displayed by a ``Display`` object, the generic
44 function ``xrepr`` is used.
44 function ``xrepr`` is used.
45
45
46 * Objects that can be iterated by ``Pipe``s must iterable. For special cases,
46 * Objects that can be iterated by ``Pipe``s must iterable. For special cases,
47 where iteration for display is different than the normal iteration a special
47 where iteration for display is different than the normal iteration a special
48 implementation can be registered with the generic function ``xiter``. This
48 implementation can be registered with the generic function ``xiter``. This
49 makes it possible to use dictionaries and modules in pipeline expressions,
49 makes it possible to use dictionaries and modules in pipeline expressions,
50 for example::
50 for example::
51
51
52 >>> import sys
52 >>> import sys
53 >>> sys | ifilter("isinstance(value, int)") | idump
53 >>> sys | ifilter("isinstance(value, int)") | idump
54 key |value
54 key |value
55 api_version| 1012
55 api_version| 1012
56 dllhandle | 503316480
56 dllhandle | 503316480
57 hexversion | 33817328
57 hexversion | 33817328
58 maxint |2147483647
58 maxint |2147483647
59 maxunicode | 65535
59 maxunicode | 65535
60 >>> sys.modules | ifilter("_.value is not None") | isort("_.key.lower()")
60 >>> sys.modules | ifilter("_.value is not None") | isort("_.key.lower()")
61 ...
61 ...
62
62
63 Note: The expression strings passed to ``ifilter()`` and ``isort()`` can
63 Note: The expression strings passed to ``ifilter()`` and ``isort()`` can
64 refer to the object to be filtered or sorted via the variable ``_`` and to any
64 refer to the object to be filtered or sorted via the variable ``_`` and to any
65 of the attributes of the object, i.e.::
65 of the attributes of the object, i.e.::
66
66
67 >>> sys.modules | ifilter("_.value is not None") | isort("_.key.lower()")
67 >>> sys.modules | ifilter("_.value is not None") | isort("_.key.lower()")
68
68
69 does the same as::
69 does the same as::
70
70
71 >>> sys.modules | ifilter("value is not None") | isort("key.lower()")
71 >>> sys.modules | ifilter("value is not None") | isort("key.lower()")
72
72
73 In addition to expression strings, it's possible to pass callables (taking
73 In addition to expression strings, it's possible to pass callables (taking
74 the object as an argument) to ``ifilter()``, ``isort()`` and ``ieval()``::
74 the object as an argument) to ``ifilter()``, ``isort()`` and ``ieval()``::
75
75
76 >>> sys | ifilter(lambda _:isinstance(_.value, int)) \
76 >>> sys | ifilter(lambda _:isinstance(_.value, int)) \
77 ... | ieval(lambda _: (_.key, hex(_.value))) | idump
77 ... | ieval(lambda _: (_.key, hex(_.value))) | idump
78 0 |1
78 0 |1
79 api_version|0x3f4
79 api_version|0x3f4
80 dllhandle |0x1e000000
80 dllhandle |0x1e000000
81 hexversion |0x20402f0
81 hexversion |0x20402f0
82 maxint |0x7fffffff
82 maxint |0x7fffffff
83 maxunicode |0xffff
83 maxunicode |0xffff
84 """
84 """
85
85
86 skip_doctest = True # ignore top-level docstring as a doctest.
86 skip_doctest = True # ignore top-level docstring as a doctest.
87
87
88 import sys, os, os.path, stat, glob, new, csv, datetime, types
88 import sys, os, os.path, stat, glob, new, csv, datetime, types
89 import itertools, mimetypes, StringIO
89 import itertools, mimetypes, StringIO
90
90
91 try: # Python 2.3 compatibility
91 try: # Python 2.3 compatibility
92 import collections
92 import collections
93 except ImportError:
93 except ImportError:
94 deque = list
94 deque = list
95 else:
95 else:
96 deque = collections.deque
96 deque = collections.deque
97
97
98 try: # Python 2.3 compatibility
98 try: # Python 2.3 compatibility
99 set
99 set
100 except NameError:
100 except NameError:
101 import sets
101 import sets
102 set = sets.Set
102 set = sets.Set
103
103
104 try: # Python 2.3 compatibility
104 try: # Python 2.3 compatibility
105 sorted
105 sorted
106 except NameError:
106 except NameError:
107 def sorted(iterator, key=None, reverse=False):
107 def sorted(iterator, key=None, reverse=False):
108 items = list(iterator)
108 items = list(iterator)
109 if key is not None:
109 if key is not None:
110 items.sort(lambda i1, i2: cmp(key(i1), key(i2)))
110 items.sort(lambda i1, i2: cmp(key(i1), key(i2)))
111 else:
111 else:
112 items.sort()
112 items.sort()
113 if reverse:
113 if reverse:
114 items.reverse()
114 items.reverse()
115 return items
115 return items
116
116
117 try: # Python 2.4 compatibility
117 try: # Python 2.4 compatibility
118 GeneratorExit
118 GeneratorExit
119 except NameError:
119 except NameError:
120 GeneratorExit = SystemExit
120 GeneratorExit = SystemExit
121
121
122 try:
122 try:
123 import pwd
123 import pwd
124 except ImportError:
124 except ImportError:
125 pwd = None
125 pwd = None
126
126
127 try:
127 try:
128 import grp
128 import grp
129 except ImportError:
129 except ImportError:
130 grp = None
130 grp = None
131
131
132 from IPython.external import simplegeneric
132 from IPython.external import simplegeneric
133 from IPython.external import path
133 from IPython.external import path
134
134
135 try:
135 try:
136 from IPython import genutils
136 from IPython.utils import genutils
137 from IPython.utils import generics
137 from IPython.utils import generics
138 except ImportError:
138 except ImportError:
139 genutils = None
139 genutils = None
140 generics = None
140 generics = None
141
141
142 from IPython import ipapi
142 from IPython import ipapi
143
143
144
144
145 __all__ = [
145 __all__ = [
146 "ifile", "ils", "iglob", "iwalk", "ipwdentry", "ipwd", "igrpentry", "igrp",
146 "ifile", "ils", "iglob", "iwalk", "ipwdentry", "ipwd", "igrpentry", "igrp",
147 "icsv", "ix", "ichain", "isort", "ifilter", "ieval", "ienum",
147 "icsv", "ix", "ichain", "isort", "ifilter", "ieval", "ienum",
148 "ienv", "ihist", "ialias", "icap", "idump", "iless"
148 "ienv", "ihist", "ialias", "icap", "idump", "iless"
149 ]
149 ]
150
150
151
151
152 os.stat_float_times(True) # enable microseconds
152 os.stat_float_times(True) # enable microseconds
153
153
154
154
155 class AttrNamespace(object):
155 class AttrNamespace(object):
156 """
156 """
157 Helper class that is used for providing a namespace for evaluating
157 Helper class that is used for providing a namespace for evaluating
158 expressions containing attribute names of an object.
158 expressions containing attribute names of an object.
159 """
159 """
160 def __init__(self, wrapped):
160 def __init__(self, wrapped):
161 self.wrapped = wrapped
161 self.wrapped = wrapped
162
162
163 def __getitem__(self, name):
163 def __getitem__(self, name):
164 if name == "_":
164 if name == "_":
165 return self.wrapped
165 return self.wrapped
166 try:
166 try:
167 return getattr(self.wrapped, name)
167 return getattr(self.wrapped, name)
168 except AttributeError:
168 except AttributeError:
169 raise KeyError(name)
169 raise KeyError(name)
170
170
171 # Python 2.3 compatibility
171 # Python 2.3 compatibility
172 # use eval workaround to find out which names are used in the
172 # use eval workaround to find out which names are used in the
173 # eval string and put them into the locals. This works for most
173 # eval string and put them into the locals. This works for most
174 # normal uses case, bizarre ones like accessing the locals()
174 # normal uses case, bizarre ones like accessing the locals()
175 # will fail
175 # will fail
176 try:
176 try:
177 eval("_", None, AttrNamespace(None))
177 eval("_", None, AttrNamespace(None))
178 except TypeError:
178 except TypeError:
179 real_eval = eval
179 real_eval = eval
180 def eval(codestring, _globals, _locals):
180 def eval(codestring, _globals, _locals):
181 """
181 """
182 eval(source[, globals[, locals]]) -> value
182 eval(source[, globals[, locals]]) -> value
183
183
184 Evaluate the source in the context of globals and locals.
184 Evaluate the source in the context of globals and locals.
185 The source may be a string representing a Python expression
185 The source may be a string representing a Python expression
186 or a code object as returned by compile().
186 or a code object as returned by compile().
187 The globals must be a dictionary and locals can be any mappping.
187 The globals must be a dictionary and locals can be any mappping.
188
188
189 This function is a workaround for the shortcomings of
189 This function is a workaround for the shortcomings of
190 Python 2.3's eval.
190 Python 2.3's eval.
191 """
191 """
192
192
193 if isinstance(codestring, basestring):
193 if isinstance(codestring, basestring):
194 code = compile(codestring, "_eval", "eval")
194 code = compile(codestring, "_eval", "eval")
195 else:
195 else:
196 code = codestring
196 code = codestring
197 newlocals = {}
197 newlocals = {}
198 for name in code.co_names:
198 for name in code.co_names:
199 try:
199 try:
200 newlocals[name] = _locals[name]
200 newlocals[name] = _locals[name]
201 except KeyError:
201 except KeyError:
202 pass
202 pass
203 return real_eval(code, _globals, newlocals)
203 return real_eval(code, _globals, newlocals)
204
204
205
205
206 noitem = object()
206 noitem = object()
207
207
208
208
209 def item(iterator, index, default=noitem):
209 def item(iterator, index, default=noitem):
210 """
210 """
211 Return the ``index``th item from the iterator ``iterator``.
211 Return the ``index``th item from the iterator ``iterator``.
212 ``index`` must be an integer (negative integers are relative to the
212 ``index`` must be an integer (negative integers are relative to the
213 end (i.e. the last items produced by the iterator)).
213 end (i.e. the last items produced by the iterator)).
214
214
215 If ``default`` is given, this will be the default value when
215 If ``default`` is given, this will be the default value when
216 the iterator doesn't contain an item at this position. Otherwise an
216 the iterator doesn't contain an item at this position. Otherwise an
217 ``IndexError`` will be raised.
217 ``IndexError`` will be raised.
218
218
219 Note that using this function will partially or totally exhaust the
219 Note that using this function will partially or totally exhaust the
220 iterator.
220 iterator.
221 """
221 """
222 i = index
222 i = index
223 if i>=0:
223 if i>=0:
224 for item in iterator:
224 for item in iterator:
225 if not i:
225 if not i:
226 return item
226 return item
227 i -= 1
227 i -= 1
228 else:
228 else:
229 i = -index
229 i = -index
230 cache = deque()
230 cache = deque()
231 for item in iterator:
231 for item in iterator:
232 cache.append(item)
232 cache.append(item)
233 if len(cache)>i:
233 if len(cache)>i:
234 cache.popleft()
234 cache.popleft()
235 if len(cache)==i:
235 if len(cache)==i:
236 return cache.popleft()
236 return cache.popleft()
237 if default is noitem:
237 if default is noitem:
238 raise IndexError(index)
238 raise IndexError(index)
239 else:
239 else:
240 return default
240 return default
241
241
242
242
243 def getglobals(g):
243 def getglobals(g):
244 """
244 """
245 Return the global namespace that is used for expression strings in
245 Return the global namespace that is used for expression strings in
246 ``ifilter`` and others. This is ``g`` or (if ``g`` is ``None``) IPython's
246 ``ifilter`` and others. This is ``g`` or (if ``g`` is ``None``) IPython's
247 user namespace.
247 user namespace.
248 """
248 """
249 if g is None:
249 if g is None:
250 if ipapi is not None:
250 if ipapi is not None:
251 api = ipapi.get()
251 api = ipapi.get()
252 if api is not None:
252 if api is not None:
253 return api.user_ns
253 return api.user_ns
254 return globals()
254 return globals()
255 return g
255 return g
256
256
257
257
258 class Descriptor(object):
258 class Descriptor(object):
259 """
259 """
260 A ``Descriptor`` object is used for describing the attributes of objects.
260 A ``Descriptor`` object is used for describing the attributes of objects.
261 """
261 """
262 def __hash__(self):
262 def __hash__(self):
263 return hash(self.__class__) ^ hash(self.key())
263 return hash(self.__class__) ^ hash(self.key())
264
264
265 def __eq__(self, other):
265 def __eq__(self, other):
266 return self.__class__ is other.__class__ and self.key() == other.key()
266 return self.__class__ is other.__class__ and self.key() == other.key()
267
267
268 def __ne__(self, other):
268 def __ne__(self, other):
269 return self.__class__ is not other.__class__ or self.key() != other.key()
269 return self.__class__ is not other.__class__ or self.key() != other.key()
270
270
271 def key(self):
271 def key(self):
272 pass
272 pass
273
273
274 def name(self):
274 def name(self):
275 """
275 """
276 Return the name of this attribute for display by a ``Display`` object
276 Return the name of this attribute for display by a ``Display`` object
277 (e.g. as a column title).
277 (e.g. as a column title).
278 """
278 """
279 key = self.key()
279 key = self.key()
280 if key is None:
280 if key is None:
281 return "_"
281 return "_"
282 return str(key)
282 return str(key)
283
283
284 def attrtype(self, obj):
284 def attrtype(self, obj):
285 """
285 """
286 Return the type of this attribute (i.e. something like "attribute" or
286 Return the type of this attribute (i.e. something like "attribute" or
287 "method").
287 "method").
288 """
288 """
289
289
290 def valuetype(self, obj):
290 def valuetype(self, obj):
291 """
291 """
292 Return the type of this attribute value of the object ``obj``.
292 Return the type of this attribute value of the object ``obj``.
293 """
293 """
294
294
295 def value(self, obj):
295 def value(self, obj):
296 """
296 """
297 Return the value of this attribute of the object ``obj``.
297 Return the value of this attribute of the object ``obj``.
298 """
298 """
299
299
300 def doc(self, obj):
300 def doc(self, obj):
301 """
301 """
302 Return the documentation for this attribute.
302 Return the documentation for this attribute.
303 """
303 """
304
304
305 def shortdoc(self, obj):
305 def shortdoc(self, obj):
306 """
306 """
307 Return a short documentation for this attribute (defaulting to the
307 Return a short documentation for this attribute (defaulting to the
308 first line).
308 first line).
309 """
309 """
310 doc = self.doc(obj)
310 doc = self.doc(obj)
311 if doc is not None:
311 if doc is not None:
312 doc = doc.strip().splitlines()[0].strip()
312 doc = doc.strip().splitlines()[0].strip()
313 return doc
313 return doc
314
314
315 def iter(self, obj):
315 def iter(self, obj):
316 """
316 """
317 Return an iterator for this attribute of the object ``obj``.
317 Return an iterator for this attribute of the object ``obj``.
318 """
318 """
319 return xiter(self.value(obj))
319 return xiter(self.value(obj))
320
320
321
321
322 class SelfDescriptor(Descriptor):
322 class SelfDescriptor(Descriptor):
323 """
323 """
324 A ``SelfDescriptor`` describes the object itself.
324 A ``SelfDescriptor`` describes the object itself.
325 """
325 """
326 def key(self):
326 def key(self):
327 return None
327 return None
328
328
329 def attrtype(self, obj):
329 def attrtype(self, obj):
330 return "self"
330 return "self"
331
331
332 def valuetype(self, obj):
332 def valuetype(self, obj):
333 return type(obj)
333 return type(obj)
334
334
335 def value(self, obj):
335 def value(self, obj):
336 return obj
336 return obj
337
337
338 def __repr__(self):
338 def __repr__(self):
339 return "Self"
339 return "Self"
340
340
341 selfdescriptor = SelfDescriptor() # there's no need for more than one
341 selfdescriptor = SelfDescriptor() # there's no need for more than one
342
342
343
343
344 class AttributeDescriptor(Descriptor):
344 class AttributeDescriptor(Descriptor):
345 """
345 """
346 An ``AttributeDescriptor`` describes a simple attribute of an object.
346 An ``AttributeDescriptor`` describes a simple attribute of an object.
347 """
347 """
348 __slots__ = ("_name", "_doc")
348 __slots__ = ("_name", "_doc")
349
349
350 def __init__(self, name, doc=None):
350 def __init__(self, name, doc=None):
351 self._name = name
351 self._name = name
352 self._doc = doc
352 self._doc = doc
353
353
354 def key(self):
354 def key(self):
355 return self._name
355 return self._name
356
356
357 def doc(self, obj):
357 def doc(self, obj):
358 return self._doc
358 return self._doc
359
359
360 def attrtype(self, obj):
360 def attrtype(self, obj):
361 return "attr"
361 return "attr"
362
362
363 def valuetype(self, obj):
363 def valuetype(self, obj):
364 return type(getattr(obj, self._name))
364 return type(getattr(obj, self._name))
365
365
366 def value(self, obj):
366 def value(self, obj):
367 return getattr(obj, self._name)
367 return getattr(obj, self._name)
368
368
369 def __repr__(self):
369 def __repr__(self):
370 if self._doc is None:
370 if self._doc is None:
371 return "Attribute(%r)" % self._name
371 return "Attribute(%r)" % self._name
372 else:
372 else:
373 return "Attribute(%r, %r)" % (self._name, self._doc)
373 return "Attribute(%r, %r)" % (self._name, self._doc)
374
374
375
375
376 class IndexDescriptor(Descriptor):
376 class IndexDescriptor(Descriptor):
377 """
377 """
378 An ``IndexDescriptor`` describes an "attribute" of an object that is fetched
378 An ``IndexDescriptor`` describes an "attribute" of an object that is fetched
379 via ``__getitem__``.
379 via ``__getitem__``.
380 """
380 """
381 __slots__ = ("_index",)
381 __slots__ = ("_index",)
382
382
383 def __init__(self, index):
383 def __init__(self, index):
384 self._index = index
384 self._index = index
385
385
386 def key(self):
386 def key(self):
387 return self._index
387 return self._index
388
388
389 def attrtype(self, obj):
389 def attrtype(self, obj):
390 return "item"
390 return "item"
391
391
392 def valuetype(self, obj):
392 def valuetype(self, obj):
393 return type(obj[self._index])
393 return type(obj[self._index])
394
394
395 def value(self, obj):
395 def value(self, obj):
396 return obj[self._index]
396 return obj[self._index]
397
397
398 def __repr__(self):
398 def __repr__(self):
399 return "Index(%r)" % self._index
399 return "Index(%r)" % self._index
400
400
401
401
402 class MethodDescriptor(Descriptor):
402 class MethodDescriptor(Descriptor):
403 """
403 """
404 A ``MethodDescriptor`` describes a method of an object that can be called
404 A ``MethodDescriptor`` describes a method of an object that can be called
405 without argument. Note that this method shouldn't change the object.
405 without argument. Note that this method shouldn't change the object.
406 """
406 """
407 __slots__ = ("_name", "_doc")
407 __slots__ = ("_name", "_doc")
408
408
409 def __init__(self, name, doc=None):
409 def __init__(self, name, doc=None):
410 self._name = name
410 self._name = name
411 self._doc = doc
411 self._doc = doc
412
412
413 def key(self):
413 def key(self):
414 return self._name
414 return self._name
415
415
416 def doc(self, obj):
416 def doc(self, obj):
417 if self._doc is None:
417 if self._doc is None:
418 return getattr(obj, self._name).__doc__
418 return getattr(obj, self._name).__doc__
419 return self._doc
419 return self._doc
420
420
421 def attrtype(self, obj):
421 def attrtype(self, obj):
422 return "method"
422 return "method"
423
423
424 def valuetype(self, obj):
424 def valuetype(self, obj):
425 return type(self.value(obj))
425 return type(self.value(obj))
426
426
427 def value(self, obj):
427 def value(self, obj):
428 return getattr(obj, self._name)()
428 return getattr(obj, self._name)()
429
429
430 def __repr__(self):
430 def __repr__(self):
431 if self._doc is None:
431 if self._doc is None:
432 return "Method(%r)" % self._name
432 return "Method(%r)" % self._name
433 else:
433 else:
434 return "Method(%r, %r)" % (self._name, self._doc)
434 return "Method(%r, %r)" % (self._name, self._doc)
435
435
436
436
437 class IterAttributeDescriptor(Descriptor):
437 class IterAttributeDescriptor(Descriptor):
438 """
438 """
439 An ``IterAttributeDescriptor`` works like an ``AttributeDescriptor`` but
439 An ``IterAttributeDescriptor`` works like an ``AttributeDescriptor`` but
440 doesn't return an attribute values (because this value might be e.g. a large
440 doesn't return an attribute values (because this value might be e.g. a large
441 list).
441 list).
442 """
442 """
443 __slots__ = ("_name", "_doc")
443 __slots__ = ("_name", "_doc")
444
444
445 def __init__(self, name, doc=None):
445 def __init__(self, name, doc=None):
446 self._name = name
446 self._name = name
447 self._doc = doc
447 self._doc = doc
448
448
449 def key(self):
449 def key(self):
450 return self._name
450 return self._name
451
451
452 def doc(self, obj):
452 def doc(self, obj):
453 return self._doc
453 return self._doc
454
454
455 def attrtype(self, obj):
455 def attrtype(self, obj):
456 return "iter"
456 return "iter"
457
457
458 def valuetype(self, obj):
458 def valuetype(self, obj):
459 return noitem
459 return noitem
460
460
461 def value(self, obj):
461 def value(self, obj):
462 return noitem
462 return noitem
463
463
464 def iter(self, obj):
464 def iter(self, obj):
465 return xiter(getattr(obj, self._name))
465 return xiter(getattr(obj, self._name))
466
466
467 def __repr__(self):
467 def __repr__(self):
468 if self._doc is None:
468 if self._doc is None:
469 return "IterAttribute(%r)" % self._name
469 return "IterAttribute(%r)" % self._name
470 else:
470 else:
471 return "IterAttribute(%r, %r)" % (self._name, self._doc)
471 return "IterAttribute(%r, %r)" % (self._name, self._doc)
472
472
473
473
474 class IterMethodDescriptor(Descriptor):
474 class IterMethodDescriptor(Descriptor):
475 """
475 """
476 An ``IterMethodDescriptor`` works like an ``MethodDescriptor`` but doesn't
476 An ``IterMethodDescriptor`` works like an ``MethodDescriptor`` but doesn't
477 return an attribute values (because this value might be e.g. a large list).
477 return an attribute values (because this value might be e.g. a large list).
478 """
478 """
479 __slots__ = ("_name", "_doc")
479 __slots__ = ("_name", "_doc")
480
480
481 def __init__(self, name, doc=None):
481 def __init__(self, name, doc=None):
482 self._name = name
482 self._name = name
483 self._doc = doc
483 self._doc = doc
484
484
485 def key(self):
485 def key(self):
486 return self._name
486 return self._name
487
487
488 def doc(self, obj):
488 def doc(self, obj):
489 if self._doc is None:
489 if self._doc is None:
490 return getattr(obj, self._name).__doc__
490 return getattr(obj, self._name).__doc__
491 return self._doc
491 return self._doc
492
492
493 def attrtype(self, obj):
493 def attrtype(self, obj):
494 return "itermethod"
494 return "itermethod"
495
495
496 def valuetype(self, obj):
496 def valuetype(self, obj):
497 return noitem
497 return noitem
498
498
499 def value(self, obj):
499 def value(self, obj):
500 return noitem
500 return noitem
501
501
502 def iter(self, obj):
502 def iter(self, obj):
503 return xiter(getattr(obj, self._name)())
503 return xiter(getattr(obj, self._name)())
504
504
505 def __repr__(self):
505 def __repr__(self):
506 if self._doc is None:
506 if self._doc is None:
507 return "IterMethod(%r)" % self._name
507 return "IterMethod(%r)" % self._name
508 else:
508 else:
509 return "IterMethod(%r, %r)" % (self._name, self._doc)
509 return "IterMethod(%r, %r)" % (self._name, self._doc)
510
510
511
511
512 class FunctionDescriptor(Descriptor):
512 class FunctionDescriptor(Descriptor):
513 """
513 """
514 A ``FunctionDescriptor`` turns a function into a descriptor. The function
514 A ``FunctionDescriptor`` turns a function into a descriptor. The function
515 will be called with the object to get the type and value of the attribute.
515 will be called with the object to get the type and value of the attribute.
516 """
516 """
517 __slots__ = ("_function", "_name", "_doc")
517 __slots__ = ("_function", "_name", "_doc")
518
518
519 def __init__(self, function, name=None, doc=None):
519 def __init__(self, function, name=None, doc=None):
520 self._function = function
520 self._function = function
521 self._name = name
521 self._name = name
522 self._doc = doc
522 self._doc = doc
523
523
524 def key(self):
524 def key(self):
525 return self._function
525 return self._function
526
526
527 def name(self):
527 def name(self):
528 if self._name is not None:
528 if self._name is not None:
529 return self._name
529 return self._name
530 return getattr(self._function, "__xname__", self._function.__name__)
530 return getattr(self._function, "__xname__", self._function.__name__)
531
531
532 def doc(self, obj):
532 def doc(self, obj):
533 if self._doc is None:
533 if self._doc is None:
534 return self._function.__doc__
534 return self._function.__doc__
535 return self._doc
535 return self._doc
536
536
537 def attrtype(self, obj):
537 def attrtype(self, obj):
538 return "function"
538 return "function"
539
539
540 def valuetype(self, obj):
540 def valuetype(self, obj):
541 return type(self._function(obj))
541 return type(self._function(obj))
542
542
543 def value(self, obj):
543 def value(self, obj):
544 return self._function(obj)
544 return self._function(obj)
545
545
546 def __repr__(self):
546 def __repr__(self):
547 if self._doc is None:
547 if self._doc is None:
548 return "Function(%r)" % self._name
548 return "Function(%r)" % self._name
549 else:
549 else:
550 return "Function(%r, %r)" % (self._name, self._doc)
550 return "Function(%r, %r)" % (self._name, self._doc)
551
551
552
552
553 class Table(object):
553 class Table(object):
554 """
554 """
555 A ``Table`` is an object that produces items (just like a normal Python
555 A ``Table`` is an object that produces items (just like a normal Python
556 iterator/generator does) and can be used as the first object in a pipeline
556 iterator/generator does) and can be used as the first object in a pipeline
557 expression. The displayhook will open the default browser for such an object
557 expression. The displayhook will open the default browser for such an object
558 (instead of simply printing the ``repr()`` result).
558 (instead of simply printing the ``repr()`` result).
559 """
559 """
560
560
561 # We want to support ``foo`` and ``foo()`` in pipeline expression:
561 # We want to support ``foo`` and ``foo()`` in pipeline expression:
562 # So we implement the required operators (``|`` and ``+``) in the metaclass,
562 # So we implement the required operators (``|`` and ``+``) in the metaclass,
563 # instantiate the class and forward the operator to the instance
563 # instantiate the class and forward the operator to the instance
564 class __metaclass__(type):
564 class __metaclass__(type):
565 def __iter__(self):
565 def __iter__(self):
566 return iter(self())
566 return iter(self())
567
567
568 def __or__(self, other):
568 def __or__(self, other):
569 return self() | other
569 return self() | other
570
570
571 def __add__(self, other):
571 def __add__(self, other):
572 return self() + other
572 return self() + other
573
573
574 def __radd__(self, other):
574 def __radd__(self, other):
575 return other + self()
575 return other + self()
576
576
577 def __getitem__(self, index):
577 def __getitem__(self, index):
578 return self()[index]
578 return self()[index]
579
579
580 def __getitem__(self, index):
580 def __getitem__(self, index):
581 return item(self, index)
581 return item(self, index)
582
582
583 def __contains__(self, item):
583 def __contains__(self, item):
584 for haveitem in self:
584 for haveitem in self:
585 if item == haveitem:
585 if item == haveitem:
586 return True
586 return True
587 return False
587 return False
588
588
589 def __or__(self, other):
589 def __or__(self, other):
590 # autoinstantiate right hand side
590 # autoinstantiate right hand side
591 if isinstance(other, type) and issubclass(other, (Table, Display)):
591 if isinstance(other, type) and issubclass(other, (Table, Display)):
592 other = other()
592 other = other()
593 # treat simple strings and functions as ``ieval`` instances
593 # treat simple strings and functions as ``ieval`` instances
594 elif not isinstance(other, Display) and not isinstance(other, Table):
594 elif not isinstance(other, Display) and not isinstance(other, Table):
595 other = ieval(other)
595 other = ieval(other)
596 # forward operations to the right hand side
596 # forward operations to the right hand side
597 return other.__ror__(self)
597 return other.__ror__(self)
598
598
599 def __add__(self, other):
599 def __add__(self, other):
600 # autoinstantiate right hand side
600 # autoinstantiate right hand side
601 if isinstance(other, type) and issubclass(other, Table):
601 if isinstance(other, type) and issubclass(other, Table):
602 other = other()
602 other = other()
603 return ichain(self, other)
603 return ichain(self, other)
604
604
605 def __radd__(self, other):
605 def __radd__(self, other):
606 # autoinstantiate left hand side
606 # autoinstantiate left hand side
607 if isinstance(other, type) and issubclass(other, Table):
607 if isinstance(other, type) and issubclass(other, Table):
608 other = other()
608 other = other()
609 return ichain(other, self)
609 return ichain(other, self)
610
610
611
611
612 class Pipe(Table):
612 class Pipe(Table):
613 """
613 """
614 A ``Pipe`` is an object that can be used in a pipeline expression. It
614 A ``Pipe`` is an object that can be used in a pipeline expression. It
615 processes the objects it gets from its input ``Table``/``Pipe``. Note that
615 processes the objects it gets from its input ``Table``/``Pipe``. Note that
616 a ``Pipe`` object can't be used as the first object in a pipeline
616 a ``Pipe`` object can't be used as the first object in a pipeline
617 expression, as it doesn't produces items itself.
617 expression, as it doesn't produces items itself.
618 """
618 """
619 class __metaclass__(Table.__metaclass__):
619 class __metaclass__(Table.__metaclass__):
620 def __ror__(self, input):
620 def __ror__(self, input):
621 return input | self()
621 return input | self()
622
622
623 def __ror__(self, input):
623 def __ror__(self, input):
624 # autoinstantiate left hand side
624 # autoinstantiate left hand side
625 if isinstance(input, type) and issubclass(input, Table):
625 if isinstance(input, type) and issubclass(input, Table):
626 input = input()
626 input = input()
627 self.input = input
627 self.input = input
628 return self
628 return self
629
629
630
630
631 def xrepr(item, mode="default"):
631 def xrepr(item, mode="default"):
632 """
632 """
633 Generic function that adds color output and different display modes to ``repr``.
633 Generic function that adds color output and different display modes to ``repr``.
634
634
635 The result of an ``xrepr`` call is iterable and consists of ``(style, string)``
635 The result of an ``xrepr`` call is iterable and consists of ``(style, string)``
636 tuples. The ``style`` in this tuple must be a ``Style`` object from the
636 tuples. The ``style`` in this tuple must be a ``Style`` object from the
637 ``astring`` module. To reconfigure the output the first yielded tuple can be
637 ``astring`` module. To reconfigure the output the first yielded tuple can be
638 a ``(aligment, full)`` tuple instead of a ``(style, string)`` tuple.
638 a ``(aligment, full)`` tuple instead of a ``(style, string)`` tuple.
639 ``alignment`` can be -1 for left aligned, 0 for centered and 1 for right
639 ``alignment`` can be -1 for left aligned, 0 for centered and 1 for right
640 aligned (the default is left alignment). ``full`` is a boolean that specifies
640 aligned (the default is left alignment). ``full`` is a boolean that specifies
641 whether the complete output must be displayed or the ``Display`` object is
641 whether the complete output must be displayed or the ``Display`` object is
642 allowed to stop output after enough text has been produced (e.g. a syntax
642 allowed to stop output after enough text has been produced (e.g. a syntax
643 highlighted text line would use ``True``, but for a large data structure
643 highlighted text line would use ``True``, but for a large data structure
644 (i.e. a nested list, tuple or dictionary) ``False`` would be used).
644 (i.e. a nested list, tuple or dictionary) ``False`` would be used).
645 The default is full output.
645 The default is full output.
646
646
647 There are four different possible values for ``mode`` depending on where
647 There are four different possible values for ``mode`` depending on where
648 the ``Display`` object will display ``item``:
648 the ``Display`` object will display ``item``:
649
649
650 ``"header"``
650 ``"header"``
651 ``item`` will be displayed in a header line (this is used by ``ibrowse``).
651 ``item`` will be displayed in a header line (this is used by ``ibrowse``).
652
652
653 ``"footer"``
653 ``"footer"``
654 ``item`` will be displayed in a footer line (this is used by ``ibrowse``).
654 ``item`` will be displayed in a footer line (this is used by ``ibrowse``).
655
655
656 ``"cell"``
656 ``"cell"``
657 ``item`` will be displayed in a table cell/list.
657 ``item`` will be displayed in a table cell/list.
658
658
659 ``"default"``
659 ``"default"``
660 default mode. If an ``xrepr`` implementation recursively outputs objects,
660 default mode. If an ``xrepr`` implementation recursively outputs objects,
661 ``"default"`` must be passed in the recursive calls to ``xrepr``.
661 ``"default"`` must be passed in the recursive calls to ``xrepr``.
662
662
663 If no implementation is registered for ``item``, ``xrepr`` will try the
663 If no implementation is registered for ``item``, ``xrepr`` will try the
664 ``__xrepr__`` method on ``item``. If ``item`` doesn't have an ``__xrepr__``
664 ``__xrepr__`` method on ``item``. If ``item`` doesn't have an ``__xrepr__``
665 method it falls back to ``repr``/``__repr__`` for all modes.
665 method it falls back to ``repr``/``__repr__`` for all modes.
666 """
666 """
667 try:
667 try:
668 func = item.__xrepr__
668 func = item.__xrepr__
669 except AttributeError:
669 except AttributeError:
670 yield (astyle.style_default, repr(item))
670 yield (astyle.style_default, repr(item))
671 else:
671 else:
672 try:
672 try:
673 for x in func(mode):
673 for x in func(mode):
674 yield x
674 yield x
675 except (KeyboardInterrupt, SystemExit, GeneratorExit):
675 except (KeyboardInterrupt, SystemExit, GeneratorExit):
676 raise
676 raise
677 except Exception:
677 except Exception:
678 yield (astyle.style_default, repr(item))
678 yield (astyle.style_default, repr(item))
679 xrepr = simplegeneric.generic(xrepr)
679 xrepr = simplegeneric.generic(xrepr)
680
680
681
681
682 def xrepr_none(self, mode="default"):
682 def xrepr_none(self, mode="default"):
683 yield (astyle.style_type_none, repr(self))
683 yield (astyle.style_type_none, repr(self))
684 xrepr.when_object(None)(xrepr_none)
684 xrepr.when_object(None)(xrepr_none)
685
685
686
686
687 def xrepr_noitem(self, mode="default"):
687 def xrepr_noitem(self, mode="default"):
688 yield (2, True)
688 yield (2, True)
689 yield (astyle.style_nodata, "<?>")
689 yield (astyle.style_nodata, "<?>")
690 xrepr.when_object(noitem)(xrepr_noitem)
690 xrepr.when_object(noitem)(xrepr_noitem)
691
691
692
692
693 def xrepr_bool(self, mode="default"):
693 def xrepr_bool(self, mode="default"):
694 yield (astyle.style_type_bool, repr(self))
694 yield (astyle.style_type_bool, repr(self))
695 xrepr.when_type(bool)(xrepr_bool)
695 xrepr.when_type(bool)(xrepr_bool)
696
696
697
697
698 def xrepr_str(self, mode="default"):
698 def xrepr_str(self, mode="default"):
699 if mode == "cell":
699 if mode == "cell":
700 yield (astyle.style_default, repr(self.expandtabs(tab))[1:-1])
700 yield (astyle.style_default, repr(self.expandtabs(tab))[1:-1])
701 else:
701 else:
702 yield (astyle.style_default, repr(self))
702 yield (astyle.style_default, repr(self))
703 xrepr.when_type(str)(xrepr_str)
703 xrepr.when_type(str)(xrepr_str)
704
704
705
705
706 def xrepr_unicode(self, mode="default"):
706 def xrepr_unicode(self, mode="default"):
707 if mode == "cell":
707 if mode == "cell":
708 yield (astyle.style_default, repr(self.expandtabs(tab))[2:-1])
708 yield (astyle.style_default, repr(self.expandtabs(tab))[2:-1])
709 else:
709 else:
710 yield (astyle.style_default, repr(self))
710 yield (astyle.style_default, repr(self))
711 xrepr.when_type(unicode)(xrepr_unicode)
711 xrepr.when_type(unicode)(xrepr_unicode)
712
712
713
713
714 def xrepr_number(self, mode="default"):
714 def xrepr_number(self, mode="default"):
715 yield (1, True)
715 yield (1, True)
716 yield (astyle.style_type_number, repr(self))
716 yield (astyle.style_type_number, repr(self))
717 xrepr.when_type(int)(xrepr_number)
717 xrepr.when_type(int)(xrepr_number)
718 xrepr.when_type(long)(xrepr_number)
718 xrepr.when_type(long)(xrepr_number)
719 xrepr.when_type(float)(xrepr_number)
719 xrepr.when_type(float)(xrepr_number)
720
720
721
721
722 def xrepr_complex(self, mode="default"):
722 def xrepr_complex(self, mode="default"):
723 yield (astyle.style_type_number, repr(self))
723 yield (astyle.style_type_number, repr(self))
724 xrepr.when_type(complex)(xrepr_number)
724 xrepr.when_type(complex)(xrepr_number)
725
725
726
726
727 def xrepr_datetime(self, mode="default"):
727 def xrepr_datetime(self, mode="default"):
728 if mode == "cell":
728 if mode == "cell":
729 # Don't use strftime() here, as this requires year >= 1900
729 # Don't use strftime() here, as this requires year >= 1900
730 yield (astyle.style_type_datetime,
730 yield (astyle.style_type_datetime,
731 "%04d-%02d-%02d %02d:%02d:%02d.%06d" % \
731 "%04d-%02d-%02d %02d:%02d:%02d.%06d" % \
732 (self.year, self.month, self.day,
732 (self.year, self.month, self.day,
733 self.hour, self.minute, self.second,
733 self.hour, self.minute, self.second,
734 self.microsecond),
734 self.microsecond),
735 )
735 )
736 else:
736 else:
737 yield (astyle.style_type_datetime, repr(self))
737 yield (astyle.style_type_datetime, repr(self))
738 xrepr.when_type(datetime.datetime)(xrepr_datetime)
738 xrepr.when_type(datetime.datetime)(xrepr_datetime)
739
739
740
740
741 def xrepr_date(self, mode="default"):
741 def xrepr_date(self, mode="default"):
742 if mode == "cell":
742 if mode == "cell":
743 yield (astyle.style_type_datetime,
743 yield (astyle.style_type_datetime,
744 "%04d-%02d-%02d" % (self.year, self.month, self.day))
744 "%04d-%02d-%02d" % (self.year, self.month, self.day))
745 else:
745 else:
746 yield (astyle.style_type_datetime, repr(self))
746 yield (astyle.style_type_datetime, repr(self))
747 xrepr.when_type(datetime.date)(xrepr_date)
747 xrepr.when_type(datetime.date)(xrepr_date)
748
748
749
749
750 def xrepr_time(self, mode="default"):
750 def xrepr_time(self, mode="default"):
751 if mode == "cell":
751 if mode == "cell":
752 yield (astyle.style_type_datetime,
752 yield (astyle.style_type_datetime,
753 "%02d:%02d:%02d.%06d" % \
753 "%02d:%02d:%02d.%06d" % \
754 (self.hour, self.minute, self.second, self.microsecond))
754 (self.hour, self.minute, self.second, self.microsecond))
755 else:
755 else:
756 yield (astyle.style_type_datetime, repr(self))
756 yield (astyle.style_type_datetime, repr(self))
757 xrepr.when_type(datetime.time)(xrepr_time)
757 xrepr.when_type(datetime.time)(xrepr_time)
758
758
759
759
760 def xrepr_timedelta(self, mode="default"):
760 def xrepr_timedelta(self, mode="default"):
761 yield (astyle.style_type_datetime, repr(self))
761 yield (astyle.style_type_datetime, repr(self))
762 xrepr.when_type(datetime.timedelta)(xrepr_timedelta)
762 xrepr.when_type(datetime.timedelta)(xrepr_timedelta)
763
763
764
764
765 def xrepr_type(self, mode="default"):
765 def xrepr_type(self, mode="default"):
766 if self.__module__ == "__builtin__":
766 if self.__module__ == "__builtin__":
767 yield (astyle.style_type_type, self.__name__)
767 yield (astyle.style_type_type, self.__name__)
768 else:
768 else:
769 yield (astyle.style_type_type, "%s.%s" % (self.__module__, self.__name__))
769 yield (astyle.style_type_type, "%s.%s" % (self.__module__, self.__name__))
770 xrepr.when_type(type)(xrepr_type)
770 xrepr.when_type(type)(xrepr_type)
771
771
772
772
773 def xrepr_exception(self, mode="default"):
773 def xrepr_exception(self, mode="default"):
774 if self.__class__.__module__ == "exceptions":
774 if self.__class__.__module__ == "exceptions":
775 classname = self.__class__.__name__
775 classname = self.__class__.__name__
776 else:
776 else:
777 classname = "%s.%s" % \
777 classname = "%s.%s" % \
778 (self.__class__.__module__, self.__class__.__name__)
778 (self.__class__.__module__, self.__class__.__name__)
779 if mode == "header" or mode == "footer":
779 if mode == "header" or mode == "footer":
780 yield (astyle.style_error, "%s: %s" % (classname, self))
780 yield (astyle.style_error, "%s: %s" % (classname, self))
781 else:
781 else:
782 yield (astyle.style_error, classname)
782 yield (astyle.style_error, classname)
783 xrepr.when_type(Exception)(xrepr_exception)
783 xrepr.when_type(Exception)(xrepr_exception)
784
784
785
785
786 def xrepr_listtuple(self, mode="default"):
786 def xrepr_listtuple(self, mode="default"):
787 if mode == "header" or mode == "footer":
787 if mode == "header" or mode == "footer":
788 if self.__class__.__module__ == "__builtin__":
788 if self.__class__.__module__ == "__builtin__":
789 classname = self.__class__.__name__
789 classname = self.__class__.__name__
790 else:
790 else:
791 classname = "%s.%s" % \
791 classname = "%s.%s" % \
792 (self.__class__.__module__,self.__class__.__name__)
792 (self.__class__.__module__,self.__class__.__name__)
793 yield (astyle.style_default,
793 yield (astyle.style_default,
794 "<%s object with %d items at 0x%x>" % \
794 "<%s object with %d items at 0x%x>" % \
795 (classname, len(self), id(self)))
795 (classname, len(self), id(self)))
796 else:
796 else:
797 yield (-1, False)
797 yield (-1, False)
798 if isinstance(self, list):
798 if isinstance(self, list):
799 yield (astyle.style_default, "[")
799 yield (astyle.style_default, "[")
800 end = "]"
800 end = "]"
801 else:
801 else:
802 yield (astyle.style_default, "(")
802 yield (astyle.style_default, "(")
803 end = ")"
803 end = ")"
804 for (i, subself) in enumerate(self):
804 for (i, subself) in enumerate(self):
805 if i:
805 if i:
806 yield (astyle.style_default, ", ")
806 yield (astyle.style_default, ", ")
807 for part in xrepr(subself, "default"):
807 for part in xrepr(subself, "default"):
808 yield part
808 yield part
809 yield (astyle.style_default, end)
809 yield (astyle.style_default, end)
810 xrepr.when_type(list)(xrepr_listtuple)
810 xrepr.when_type(list)(xrepr_listtuple)
811 xrepr.when_type(tuple)(xrepr_listtuple)
811 xrepr.when_type(tuple)(xrepr_listtuple)
812
812
813
813
814 def xrepr_dict(self, mode="default"):
814 def xrepr_dict(self, mode="default"):
815 if mode == "header" or mode == "footer":
815 if mode == "header" or mode == "footer":
816 if self.__class__.__module__ == "__builtin__":
816 if self.__class__.__module__ == "__builtin__":
817 classname = self.__class__.__name__
817 classname = self.__class__.__name__
818 else:
818 else:
819 classname = "%s.%s" % \
819 classname = "%s.%s" % \
820 (self.__class__.__module__,self.__class__.__name__)
820 (self.__class__.__module__,self.__class__.__name__)
821 yield (astyle.style_default,
821 yield (astyle.style_default,
822 "<%s object with %d items at 0x%x>" % \
822 "<%s object with %d items at 0x%x>" % \
823 (classname, len(self), id(self)))
823 (classname, len(self), id(self)))
824 else:
824 else:
825 yield (-1, False)
825 yield (-1, False)
826 if isinstance(self, dict):
826 if isinstance(self, dict):
827 yield (astyle.style_default, "{")
827 yield (astyle.style_default, "{")
828 end = "}"
828 end = "}"
829 else:
829 else:
830 yield (astyle.style_default, "dictproxy((")
830 yield (astyle.style_default, "dictproxy((")
831 end = "})"
831 end = "})"
832 for (i, (key, value)) in enumerate(self.iteritems()):
832 for (i, (key, value)) in enumerate(self.iteritems()):
833 if i:
833 if i:
834 yield (astyle.style_default, ", ")
834 yield (astyle.style_default, ", ")
835 for part in xrepr(key, "default"):
835 for part in xrepr(key, "default"):
836 yield part
836 yield part
837 yield (astyle.style_default, ": ")
837 yield (astyle.style_default, ": ")
838 for part in xrepr(value, "default"):
838 for part in xrepr(value, "default"):
839 yield part
839 yield part
840 yield (astyle.style_default, end)
840 yield (astyle.style_default, end)
841 xrepr.when_type(dict)(xrepr_dict)
841 xrepr.when_type(dict)(xrepr_dict)
842 xrepr.when_type(types.DictProxyType)(xrepr_dict)
842 xrepr.when_type(types.DictProxyType)(xrepr_dict)
843
843
844
844
845 def upgradexattr(attr):
845 def upgradexattr(attr):
846 """
846 """
847 Convert an attribute descriptor string to a real descriptor object.
847 Convert an attribute descriptor string to a real descriptor object.
848
848
849 If attr already is a descriptor object return it unmodified. A
849 If attr already is a descriptor object return it unmodified. A
850 ``SelfDescriptor`` will be returned if ``attr`` is ``None``. ``"foo"``
850 ``SelfDescriptor`` will be returned if ``attr`` is ``None``. ``"foo"``
851 returns an ``AttributeDescriptor`` for the attribute named ``"foo"``.
851 returns an ``AttributeDescriptor`` for the attribute named ``"foo"``.
852 ``"foo()"`` returns a ``MethodDescriptor`` for the method named ``"foo"``.
852 ``"foo()"`` returns a ``MethodDescriptor`` for the method named ``"foo"``.
853 ``"-foo"`` will return an ``IterAttributeDescriptor`` for the attribute
853 ``"-foo"`` will return an ``IterAttributeDescriptor`` for the attribute
854 named ``"foo"`` and ``"-foo()"`` will return an ``IterMethodDescriptor``
854 named ``"foo"`` and ``"-foo()"`` will return an ``IterMethodDescriptor``
855 for the method named ``"foo"``. Furthermore integers will return the appropriate
855 for the method named ``"foo"``. Furthermore integers will return the appropriate
856 ``IndexDescriptor`` and callables will return a ``FunctionDescriptor``.
856 ``IndexDescriptor`` and callables will return a ``FunctionDescriptor``.
857 """
857 """
858 if attr is None:
858 if attr is None:
859 return selfdescriptor
859 return selfdescriptor
860 elif isinstance(attr, Descriptor):
860 elif isinstance(attr, Descriptor):
861 return attr
861 return attr
862 elif isinstance(attr, basestring):
862 elif isinstance(attr, basestring):
863 if attr.endswith("()"):
863 if attr.endswith("()"):
864 if attr.startswith("-"):
864 if attr.startswith("-"):
865 return IterMethodDescriptor(attr[1:-2])
865 return IterMethodDescriptor(attr[1:-2])
866 else:
866 else:
867 return MethodDescriptor(attr[:-2])
867 return MethodDescriptor(attr[:-2])
868 else:
868 else:
869 if attr.startswith("-"):
869 if attr.startswith("-"):
870 return IterAttributeDescriptor(attr[1:])
870 return IterAttributeDescriptor(attr[1:])
871 else:
871 else:
872 return AttributeDescriptor(attr)
872 return AttributeDescriptor(attr)
873 elif isinstance(attr, (int, long)):
873 elif isinstance(attr, (int, long)):
874 return IndexDescriptor(attr)
874 return IndexDescriptor(attr)
875 elif callable(attr):
875 elif callable(attr):
876 return FunctionDescriptor(attr)
876 return FunctionDescriptor(attr)
877 else:
877 else:
878 raise TypeError("can't handle descriptor %r" % attr)
878 raise TypeError("can't handle descriptor %r" % attr)
879
879
880
880
881 def xattrs(item, mode="default"):
881 def xattrs(item, mode="default"):
882 """
882 """
883 Generic function that returns an iterable of attribute descriptors
883 Generic function that returns an iterable of attribute descriptors
884 to be used for displaying the attributes ob the object ``item`` in display
884 to be used for displaying the attributes ob the object ``item`` in display
885 mode ``mode``.
885 mode ``mode``.
886
886
887 There are two possible modes:
887 There are two possible modes:
888
888
889 ``"detail"``
889 ``"detail"``
890 The ``Display`` object wants to display a detailed list of the object
890 The ``Display`` object wants to display a detailed list of the object
891 attributes.
891 attributes.
892
892
893 ``"default"``
893 ``"default"``
894 The ``Display`` object wants to display the object in a list view.
894 The ``Display`` object wants to display the object in a list view.
895
895
896 If no implementation is registered for the object ``item`` ``xattrs`` falls
896 If no implementation is registered for the object ``item`` ``xattrs`` falls
897 back to trying the ``__xattrs__`` method of the object. If this doesn't
897 back to trying the ``__xattrs__`` method of the object. If this doesn't
898 exist either, ``dir(item)`` is used for ``"detail"`` mode and ``(None,)``
898 exist either, ``dir(item)`` is used for ``"detail"`` mode and ``(None,)``
899 for ``"default"`` mode.
899 for ``"default"`` mode.
900
900
901 The implementation must yield attribute descriptors (see the class
901 The implementation must yield attribute descriptors (see the class
902 ``Descriptor`` for more info). The ``__xattrs__`` method may also return
902 ``Descriptor`` for more info). The ``__xattrs__`` method may also return
903 attribute descriptor strings (and ``None``) which will be converted to real
903 attribute descriptor strings (and ``None``) which will be converted to real
904 descriptors by ``upgradexattr()``.
904 descriptors by ``upgradexattr()``.
905 """
905 """
906 try:
906 try:
907 func = item.__xattrs__
907 func = item.__xattrs__
908 except AttributeError:
908 except AttributeError:
909 if mode == "detail":
909 if mode == "detail":
910 for attrname in dir(item):
910 for attrname in dir(item):
911 yield AttributeDescriptor(attrname)
911 yield AttributeDescriptor(attrname)
912 else:
912 else:
913 yield selfdescriptor
913 yield selfdescriptor
914 else:
914 else:
915 for attr in func(mode):
915 for attr in func(mode):
916 yield upgradexattr(attr)
916 yield upgradexattr(attr)
917 xattrs = simplegeneric.generic(xattrs)
917 xattrs = simplegeneric.generic(xattrs)
918
918
919
919
920 def xattrs_complex(self, mode="default"):
920 def xattrs_complex(self, mode="default"):
921 if mode == "detail":
921 if mode == "detail":
922 return (AttributeDescriptor("real"), AttributeDescriptor("imag"))
922 return (AttributeDescriptor("real"), AttributeDescriptor("imag"))
923 return (selfdescriptor,)
923 return (selfdescriptor,)
924 xattrs.when_type(complex)(xattrs_complex)
924 xattrs.when_type(complex)(xattrs_complex)
925
925
926
926
927 def _isdict(item):
927 def _isdict(item):
928 try:
928 try:
929 itermeth = item.__class__.__iter__
929 itermeth = item.__class__.__iter__
930 except (AttributeError, TypeError):
930 except (AttributeError, TypeError):
931 return False
931 return False
932 return itermeth is dict.__iter__ or itermeth is types.DictProxyType.__iter__
932 return itermeth is dict.__iter__ or itermeth is types.DictProxyType.__iter__
933
933
934
934
935 def _isstr(item):
935 def _isstr(item):
936 if not isinstance(item, basestring):
936 if not isinstance(item, basestring):
937 return False
937 return False
938 try:
938 try:
939 itermeth = item.__class__.__iter__
939 itermeth = item.__class__.__iter__
940 except AttributeError:
940 except AttributeError:
941 return True
941 return True
942 return False # ``__iter__`` has been redefined
942 return False # ``__iter__`` has been redefined
943
943
944
944
945 def xiter(item):
945 def xiter(item):
946 """
946 """
947 Generic function that implements iteration for pipeline expression. If no
947 Generic function that implements iteration for pipeline expression. If no
948 implementation is registered for ``item`` ``xiter`` falls back to ``iter``.
948 implementation is registered for ``item`` ``xiter`` falls back to ``iter``.
949 """
949 """
950 try:
950 try:
951 func = item.__xiter__
951 func = item.__xiter__
952 except AttributeError:
952 except AttributeError:
953 if _isdict(item):
953 if _isdict(item):
954 def items(item):
954 def items(item):
955 fields = ("key", "value")
955 fields = ("key", "value")
956 for (key, value) in item.iteritems():
956 for (key, value) in item.iteritems():
957 yield Fields(fields, key=key, value=value)
957 yield Fields(fields, key=key, value=value)
958 return items(item)
958 return items(item)
959 elif isinstance(item, new.module):
959 elif isinstance(item, new.module):
960 def items(item):
960 def items(item):
961 fields = ("key", "value")
961 fields = ("key", "value")
962 for key in sorted(item.__dict__):
962 for key in sorted(item.__dict__):
963 yield Fields(fields, key=key, value=getattr(item, key))
963 yield Fields(fields, key=key, value=getattr(item, key))
964 return items(item)
964 return items(item)
965 elif _isstr(item):
965 elif _isstr(item):
966 if not item:
966 if not item:
967 raise ValueError("can't enter empty string")
967 raise ValueError("can't enter empty string")
968 lines = item.splitlines()
968 lines = item.splitlines()
969 if len(lines) == 1:
969 if len(lines) == 1:
970 def iterone(item):
970 def iterone(item):
971 yield item
971 yield item
972 return iterone(item)
972 return iterone(item)
973 else:
973 else:
974 return iter(lines)
974 return iter(lines)
975 return iter(item)
975 return iter(item)
976 else:
976 else:
977 return iter(func()) # iter() just to be safe
977 return iter(func()) # iter() just to be safe
978 xiter = simplegeneric.generic(xiter)
978 xiter = simplegeneric.generic(xiter)
979
979
980
980
981 class ichain(Pipe):
981 class ichain(Pipe):
982 """
982 """
983 Chains multiple ``Table``s into one.
983 Chains multiple ``Table``s into one.
984 """
984 """
985
985
986 def __init__(self, *iters):
986 def __init__(self, *iters):
987 self.iters = iters
987 self.iters = iters
988
988
989 def __iter__(self):
989 def __iter__(self):
990 return itertools.chain(*self.iters)
990 return itertools.chain(*self.iters)
991
991
992 def __xrepr__(self, mode="default"):
992 def __xrepr__(self, mode="default"):
993 if mode == "header" or mode == "footer":
993 if mode == "header" or mode == "footer":
994 for (i, item) in enumerate(self.iters):
994 for (i, item) in enumerate(self.iters):
995 if i:
995 if i:
996 yield (astyle.style_default, "+")
996 yield (astyle.style_default, "+")
997 if isinstance(item, Pipe):
997 if isinstance(item, Pipe):
998 yield (astyle.style_default, "(")
998 yield (astyle.style_default, "(")
999 for part in xrepr(item, mode):
999 for part in xrepr(item, mode):
1000 yield part
1000 yield part
1001 if isinstance(item, Pipe):
1001 if isinstance(item, Pipe):
1002 yield (astyle.style_default, ")")
1002 yield (astyle.style_default, ")")
1003 else:
1003 else:
1004 yield (astyle.style_default, repr(self))
1004 yield (astyle.style_default, repr(self))
1005
1005
1006 def __repr__(self):
1006 def __repr__(self):
1007 args = ", ".join([repr(it) for it in self.iters])
1007 args = ", ".join([repr(it) for it in self.iters])
1008 return "%s.%s(%s)" % \
1008 return "%s.%s(%s)" % \
1009 (self.__class__.__module__, self.__class__.__name__, args)
1009 (self.__class__.__module__, self.__class__.__name__, args)
1010
1010
1011
1011
1012 class ifile(path.path):
1012 class ifile(path.path):
1013 """
1013 """
1014 file (or directory) object.
1014 file (or directory) object.
1015 """
1015 """
1016
1016
1017 def getmode(self):
1017 def getmode(self):
1018 return self.stat().st_mode
1018 return self.stat().st_mode
1019 mode = property(getmode, None, None, "Access mode")
1019 mode = property(getmode, None, None, "Access mode")
1020
1020
1021 def gettype(self):
1021 def gettype(self):
1022 data = [
1022 data = [
1023 (stat.S_ISREG, "file"),
1023 (stat.S_ISREG, "file"),
1024 (stat.S_ISDIR, "dir"),
1024 (stat.S_ISDIR, "dir"),
1025 (stat.S_ISCHR, "chardev"),
1025 (stat.S_ISCHR, "chardev"),
1026 (stat.S_ISBLK, "blockdev"),
1026 (stat.S_ISBLK, "blockdev"),
1027 (stat.S_ISFIFO, "fifo"),
1027 (stat.S_ISFIFO, "fifo"),
1028 (stat.S_ISLNK, "symlink"),
1028 (stat.S_ISLNK, "symlink"),
1029 (stat.S_ISSOCK,"socket"),
1029 (stat.S_ISSOCK,"socket"),
1030 ]
1030 ]
1031 lstat = self.lstat()
1031 lstat = self.lstat()
1032 if lstat is not None:
1032 if lstat is not None:
1033 types = set([text for (func, text) in data if func(lstat.st_mode)])
1033 types = set([text for (func, text) in data if func(lstat.st_mode)])
1034 else:
1034 else:
1035 types = set()
1035 types = set()
1036 m = self.mode
1036 m = self.mode
1037 types.update([text for (func, text) in data if func(m)])
1037 types.update([text for (func, text) in data if func(m)])
1038 return ", ".join(types)
1038 return ", ".join(types)
1039 type = property(gettype, None, None, "file type (file, directory, link, etc.)")
1039 type = property(gettype, None, None, "file type (file, directory, link, etc.)")
1040
1040
1041 def getmodestr(self):
1041 def getmodestr(self):
1042 m = self.mode
1042 m = self.mode
1043 data = [
1043 data = [
1044 (stat.S_IRUSR, "-r"),
1044 (stat.S_IRUSR, "-r"),
1045 (stat.S_IWUSR, "-w"),
1045 (stat.S_IWUSR, "-w"),
1046 (stat.S_IXUSR, "-x"),
1046 (stat.S_IXUSR, "-x"),
1047 (stat.S_IRGRP, "-r"),
1047 (stat.S_IRGRP, "-r"),
1048 (stat.S_IWGRP, "-w"),
1048 (stat.S_IWGRP, "-w"),
1049 (stat.S_IXGRP, "-x"),
1049 (stat.S_IXGRP, "-x"),
1050 (stat.S_IROTH, "-r"),
1050 (stat.S_IROTH, "-r"),
1051 (stat.S_IWOTH, "-w"),
1051 (stat.S_IWOTH, "-w"),
1052 (stat.S_IXOTH, "-x"),
1052 (stat.S_IXOTH, "-x"),
1053 ]
1053 ]
1054 return "".join([text[bool(m&bit)] for (bit, text) in data])
1054 return "".join([text[bool(m&bit)] for (bit, text) in data])
1055
1055
1056 modestr = property(getmodestr, None, None, "Access mode as string")
1056 modestr = property(getmodestr, None, None, "Access mode as string")
1057
1057
1058 def getblocks(self):
1058 def getblocks(self):
1059 return self.stat().st_blocks
1059 return self.stat().st_blocks
1060 blocks = property(getblocks, None, None, "File size in blocks")
1060 blocks = property(getblocks, None, None, "File size in blocks")
1061
1061
1062 def getblksize(self):
1062 def getblksize(self):
1063 return self.stat().st_blksize
1063 return self.stat().st_blksize
1064 blksize = property(getblksize, None, None, "Filesystem block size")
1064 blksize = property(getblksize, None, None, "Filesystem block size")
1065
1065
1066 def getdev(self):
1066 def getdev(self):
1067 return self.stat().st_dev
1067 return self.stat().st_dev
1068 dev = property(getdev)
1068 dev = property(getdev)
1069
1069
1070 def getnlink(self):
1070 def getnlink(self):
1071 return self.stat().st_nlink
1071 return self.stat().st_nlink
1072 nlink = property(getnlink, None, None, "Number of links")
1072 nlink = property(getnlink, None, None, "Number of links")
1073
1073
1074 def getuid(self):
1074 def getuid(self):
1075 return self.stat().st_uid
1075 return self.stat().st_uid
1076 uid = property(getuid, None, None, "User id of file owner")
1076 uid = property(getuid, None, None, "User id of file owner")
1077
1077
1078 def getgid(self):
1078 def getgid(self):
1079 return self.stat().st_gid
1079 return self.stat().st_gid
1080 gid = property(getgid, None, None, "Group id of file owner")
1080 gid = property(getgid, None, None, "Group id of file owner")
1081
1081
1082 def getowner(self):
1082 def getowner(self):
1083 stat = self.stat()
1083 stat = self.stat()
1084 try:
1084 try:
1085 return pwd.getpwuid(stat.st_uid).pw_name
1085 return pwd.getpwuid(stat.st_uid).pw_name
1086 except KeyError:
1086 except KeyError:
1087 return stat.st_uid
1087 return stat.st_uid
1088 owner = property(getowner, None, None, "Owner name (or id)")
1088 owner = property(getowner, None, None, "Owner name (or id)")
1089
1089
1090 def getgroup(self):
1090 def getgroup(self):
1091 stat = self.stat()
1091 stat = self.stat()
1092 try:
1092 try:
1093 return grp.getgrgid(stat.st_gid).gr_name
1093 return grp.getgrgid(stat.st_gid).gr_name
1094 except KeyError:
1094 except KeyError:
1095 return stat.st_gid
1095 return stat.st_gid
1096 group = property(getgroup, None, None, "Group name (or id)")
1096 group = property(getgroup, None, None, "Group name (or id)")
1097
1097
1098 def getadate(self):
1098 def getadate(self):
1099 return datetime.datetime.utcfromtimestamp(self.atime)
1099 return datetime.datetime.utcfromtimestamp(self.atime)
1100 adate = property(getadate, None, None, "Access date")
1100 adate = property(getadate, None, None, "Access date")
1101
1101
1102 def getcdate(self):
1102 def getcdate(self):
1103 return datetime.datetime.utcfromtimestamp(self.ctime)
1103 return datetime.datetime.utcfromtimestamp(self.ctime)
1104 cdate = property(getcdate, None, None, "Creation date")
1104 cdate = property(getcdate, None, None, "Creation date")
1105
1105
1106 def getmdate(self):
1106 def getmdate(self):
1107 return datetime.datetime.utcfromtimestamp(self.mtime)
1107 return datetime.datetime.utcfromtimestamp(self.mtime)
1108 mdate = property(getmdate, None, None, "Modification date")
1108 mdate = property(getmdate, None, None, "Modification date")
1109
1109
1110 def mimetype(self):
1110 def mimetype(self):
1111 """
1111 """
1112 Return MIME type guessed from the extension.
1112 Return MIME type guessed from the extension.
1113 """
1113 """
1114 return mimetypes.guess_type(self.basename())[0]
1114 return mimetypes.guess_type(self.basename())[0]
1115
1115
1116 def encoding(self):
1116 def encoding(self):
1117 """
1117 """
1118 Return guessed compression (like "compress" or "gzip").
1118 Return guessed compression (like "compress" or "gzip").
1119 """
1119 """
1120 return mimetypes.guess_type(self.basename())[1]
1120 return mimetypes.guess_type(self.basename())[1]
1121
1121
1122 def __repr__(self):
1122 def __repr__(self):
1123 return "ifile(%s)" % path._base.__repr__(self)
1123 return "ifile(%s)" % path._base.__repr__(self)
1124
1124
1125 if sys.platform == "win32":
1125 if sys.platform == "win32":
1126 defaultattrs = (None, "type", "size", "modestr", "mdate")
1126 defaultattrs = (None, "type", "size", "modestr", "mdate")
1127 else:
1127 else:
1128 defaultattrs = (None, "type", "size", "modestr", "owner", "group", "mdate")
1128 defaultattrs = (None, "type", "size", "modestr", "owner", "group", "mdate")
1129
1129
1130 def __xattrs__(self, mode="default"):
1130 def __xattrs__(self, mode="default"):
1131 if mode == "detail":
1131 if mode == "detail":
1132 return (
1132 return (
1133 "name",
1133 "name",
1134 "basename()",
1134 "basename()",
1135 "abspath()",
1135 "abspath()",
1136 "realpath()",
1136 "realpath()",
1137 "type",
1137 "type",
1138 "mode",
1138 "mode",
1139 "modestr",
1139 "modestr",
1140 "stat()",
1140 "stat()",
1141 "lstat()",
1141 "lstat()",
1142 "uid",
1142 "uid",
1143 "gid",
1143 "gid",
1144 "owner",
1144 "owner",
1145 "group",
1145 "group",
1146 "dev",
1146 "dev",
1147 "nlink",
1147 "nlink",
1148 "ctime",
1148 "ctime",
1149 "mtime",
1149 "mtime",
1150 "atime",
1150 "atime",
1151 "cdate",
1151 "cdate",
1152 "mdate",
1152 "mdate",
1153 "adate",
1153 "adate",
1154 "size",
1154 "size",
1155 "blocks",
1155 "blocks",
1156 "blksize",
1156 "blksize",
1157 "isdir()",
1157 "isdir()",
1158 "islink()",
1158 "islink()",
1159 "mimetype()",
1159 "mimetype()",
1160 "encoding()",
1160 "encoding()",
1161 "-listdir()",
1161 "-listdir()",
1162 "-dirs()",
1162 "-dirs()",
1163 "-files()",
1163 "-files()",
1164 "-walk()",
1164 "-walk()",
1165 "-walkdirs()",
1165 "-walkdirs()",
1166 "-walkfiles()",
1166 "-walkfiles()",
1167 )
1167 )
1168 else:
1168 else:
1169 return self.defaultattrs
1169 return self.defaultattrs
1170
1170
1171
1171
1172 def xiter_ifile(self):
1172 def xiter_ifile(self):
1173 if self.isdir():
1173 if self.isdir():
1174 yield (self / os.pardir).abspath()
1174 yield (self / os.pardir).abspath()
1175 for child in sorted(self.listdir()):
1175 for child in sorted(self.listdir()):
1176 yield child
1176 yield child
1177 else:
1177 else:
1178 f = self.open("rb")
1178 f = self.open("rb")
1179 for line in f:
1179 for line in f:
1180 yield line
1180 yield line
1181 f.close()
1181 f.close()
1182 xiter.when_type(ifile)(xiter_ifile)
1182 xiter.when_type(ifile)(xiter_ifile)
1183
1183
1184
1184
1185 # We need to implement ``xrepr`` for ``ifile`` as a generic function, because
1185 # We need to implement ``xrepr`` for ``ifile`` as a generic function, because
1186 # otherwise ``xrepr_str`` would kick in.
1186 # otherwise ``xrepr_str`` would kick in.
1187 def xrepr_ifile(self, mode="default"):
1187 def xrepr_ifile(self, mode="default"):
1188 try:
1188 try:
1189 if self.isdir():
1189 if self.isdir():
1190 name = "idir"
1190 name = "idir"
1191 style = astyle.style_dir
1191 style = astyle.style_dir
1192 else:
1192 else:
1193 name = "ifile"
1193 name = "ifile"
1194 style = astyle.style_file
1194 style = astyle.style_file
1195 except IOError:
1195 except IOError:
1196 name = "ifile"
1196 name = "ifile"
1197 style = astyle.style_default
1197 style = astyle.style_default
1198 if mode in ("cell", "header", "footer"):
1198 if mode in ("cell", "header", "footer"):
1199 abspath = repr(path._base(self.normpath()))
1199 abspath = repr(path._base(self.normpath()))
1200 if abspath.startswith("u"):
1200 if abspath.startswith("u"):
1201 abspath = abspath[2:-1]
1201 abspath = abspath[2:-1]
1202 else:
1202 else:
1203 abspath = abspath[1:-1]
1203 abspath = abspath[1:-1]
1204 if mode == "cell":
1204 if mode == "cell":
1205 yield (style, abspath)
1205 yield (style, abspath)
1206 else:
1206 else:
1207 yield (style, "%s(%s)" % (name, abspath))
1207 yield (style, "%s(%s)" % (name, abspath))
1208 else:
1208 else:
1209 yield (style, repr(self))
1209 yield (style, repr(self))
1210 xrepr.when_type(ifile)(xrepr_ifile)
1210 xrepr.when_type(ifile)(xrepr_ifile)
1211
1211
1212
1212
1213 class ils(Table):
1213 class ils(Table):
1214 """
1214 """
1215 List the current (or a specified) directory.
1215 List the current (or a specified) directory.
1216
1216
1217 Examples::
1217 Examples::
1218
1218
1219 >>> ils
1219 >>> ils
1220 <class 'IPython.Extensions.ipipe.ils'>
1220 <class 'IPython.Extensions.ipipe.ils'>
1221 >>> ils("/usr/local/lib/python2.4")
1221 >>> ils("/usr/local/lib/python2.4")
1222 IPython.Extensions.ipipe.ils('/usr/local/lib/python2.4')
1222 IPython.Extensions.ipipe.ils('/usr/local/lib/python2.4')
1223 >>> ils("~")
1223 >>> ils("~")
1224 IPython.Extensions.ipipe.ils('/home/fperez')
1224 IPython.Extensions.ipipe.ils('/home/fperez')
1225 # all-random
1225 # all-random
1226 """
1226 """
1227 def __init__(self, base=os.curdir, dirs=True, files=True):
1227 def __init__(self, base=os.curdir, dirs=True, files=True):
1228 self.base = os.path.expanduser(base)
1228 self.base = os.path.expanduser(base)
1229 self.dirs = dirs
1229 self.dirs = dirs
1230 self.files = files
1230 self.files = files
1231
1231
1232 def __iter__(self):
1232 def __iter__(self):
1233 base = ifile(self.base)
1233 base = ifile(self.base)
1234 yield (base / os.pardir).abspath()
1234 yield (base / os.pardir).abspath()
1235 for child in sorted(base.listdir()):
1235 for child in sorted(base.listdir()):
1236 if self.dirs:
1236 if self.dirs:
1237 if self.files:
1237 if self.files:
1238 yield child
1238 yield child
1239 else:
1239 else:
1240 if child.isdir():
1240 if child.isdir():
1241 yield child
1241 yield child
1242 elif self.files:
1242 elif self.files:
1243 if not child.isdir():
1243 if not child.isdir():
1244 yield child
1244 yield child
1245
1245
1246 def __xrepr__(self, mode="default"):
1246 def __xrepr__(self, mode="default"):
1247 return xrepr(ifile(self.base), mode)
1247 return xrepr(ifile(self.base), mode)
1248
1248
1249 def __repr__(self):
1249 def __repr__(self):
1250 return "%s.%s(%r)" % \
1250 return "%s.%s(%r)" % \
1251 (self.__class__.__module__, self.__class__.__name__, self.base)
1251 (self.__class__.__module__, self.__class__.__name__, self.base)
1252
1252
1253
1253
1254 class iglob(Table):
1254 class iglob(Table):
1255 """
1255 """
1256 List all files and directories matching a specified pattern.
1256 List all files and directories matching a specified pattern.
1257 (See ``glob.glob()`` for more info.).
1257 (See ``glob.glob()`` for more info.).
1258
1258
1259 Examples::
1259 Examples::
1260
1260
1261 >>> iglob("*.py")
1261 >>> iglob("*.py")
1262 IPython.Extensions.ipipe.iglob('*.py')
1262 IPython.Extensions.ipipe.iglob('*.py')
1263 """
1263 """
1264 def __init__(self, glob):
1264 def __init__(self, glob):
1265 self.glob = glob
1265 self.glob = glob
1266
1266
1267 def __iter__(self):
1267 def __iter__(self):
1268 for name in glob.glob(self.glob):
1268 for name in glob.glob(self.glob):
1269 yield ifile(name)
1269 yield ifile(name)
1270
1270
1271 def __xrepr__(self, mode="default"):
1271 def __xrepr__(self, mode="default"):
1272 if mode == "header" or mode == "footer" or mode == "cell":
1272 if mode == "header" or mode == "footer" or mode == "cell":
1273 yield (astyle.style_default,
1273 yield (astyle.style_default,
1274 "%s(%r)" % (self.__class__.__name__, self.glob))
1274 "%s(%r)" % (self.__class__.__name__, self.glob))
1275 else:
1275 else:
1276 yield (astyle.style_default, repr(self))
1276 yield (astyle.style_default, repr(self))
1277
1277
1278 def __repr__(self):
1278 def __repr__(self):
1279 return "%s.%s(%r)" % \
1279 return "%s.%s(%r)" % \
1280 (self.__class__.__module__, self.__class__.__name__, self.glob)
1280 (self.__class__.__module__, self.__class__.__name__, self.glob)
1281
1281
1282
1282
1283 class iwalk(Table):
1283 class iwalk(Table):
1284 """
1284 """
1285 List all files and directories in a directory and it's subdirectory::
1285 List all files and directories in a directory and it's subdirectory::
1286
1286
1287 >>> iwalk
1287 >>> iwalk
1288 <class 'IPython.Extensions.ipipe.iwalk'>
1288 <class 'IPython.Extensions.ipipe.iwalk'>
1289 >>> iwalk("/usr/lib")
1289 >>> iwalk("/usr/lib")
1290 IPython.Extensions.ipipe.iwalk('/usr/lib')
1290 IPython.Extensions.ipipe.iwalk('/usr/lib')
1291 >>> iwalk("~")
1291 >>> iwalk("~")
1292 IPython.Extensions.ipipe.iwalk('/home/fperez') # random
1292 IPython.Extensions.ipipe.iwalk('/home/fperez') # random
1293
1293
1294 """
1294 """
1295 def __init__(self, base=os.curdir, dirs=True, files=True):
1295 def __init__(self, base=os.curdir, dirs=True, files=True):
1296 self.base = os.path.expanduser(base)
1296 self.base = os.path.expanduser(base)
1297 self.dirs = dirs
1297 self.dirs = dirs
1298 self.files = files
1298 self.files = files
1299
1299
1300 def __iter__(self):
1300 def __iter__(self):
1301 for (dirpath, dirnames, filenames) in os.walk(self.base):
1301 for (dirpath, dirnames, filenames) in os.walk(self.base):
1302 if self.dirs:
1302 if self.dirs:
1303 for name in sorted(dirnames):
1303 for name in sorted(dirnames):
1304 yield ifile(os.path.join(dirpath, name))
1304 yield ifile(os.path.join(dirpath, name))
1305 if self.files:
1305 if self.files:
1306 for name in sorted(filenames):
1306 for name in sorted(filenames):
1307 yield ifile(os.path.join(dirpath, name))
1307 yield ifile(os.path.join(dirpath, name))
1308
1308
1309 def __xrepr__(self, mode="default"):
1309 def __xrepr__(self, mode="default"):
1310 if mode == "header" or mode == "footer" or mode == "cell":
1310 if mode == "header" or mode == "footer" or mode == "cell":
1311 yield (astyle.style_default,
1311 yield (astyle.style_default,
1312 "%s(%r)" % (self.__class__.__name__, self.base))
1312 "%s(%r)" % (self.__class__.__name__, self.base))
1313 else:
1313 else:
1314 yield (astyle.style_default, repr(self))
1314 yield (astyle.style_default, repr(self))
1315
1315
1316 def __repr__(self):
1316 def __repr__(self):
1317 return "%s.%s(%r)" % \
1317 return "%s.%s(%r)" % \
1318 (self.__class__.__module__, self.__class__.__name__, self.base)
1318 (self.__class__.__module__, self.__class__.__name__, self.base)
1319
1319
1320
1320
1321 class ipwdentry(object):
1321 class ipwdentry(object):
1322 """
1322 """
1323 ``ipwdentry`` objects encapsulate entries in the Unix user account and
1323 ``ipwdentry`` objects encapsulate entries in the Unix user account and
1324 password database.
1324 password database.
1325 """
1325 """
1326 def __init__(self, id):
1326 def __init__(self, id):
1327 self._id = id
1327 self._id = id
1328 self._entry = None
1328 self._entry = None
1329
1329
1330 def __eq__(self, other):
1330 def __eq__(self, other):
1331 return self.__class__ is other.__class__ and self._id == other._id
1331 return self.__class__ is other.__class__ and self._id == other._id
1332
1332
1333 def __ne__(self, other):
1333 def __ne__(self, other):
1334 return self.__class__ is not other.__class__ or self._id != other._id
1334 return self.__class__ is not other.__class__ or self._id != other._id
1335
1335
1336 def _getentry(self):
1336 def _getentry(self):
1337 if self._entry is None:
1337 if self._entry is None:
1338 if isinstance(self._id, basestring):
1338 if isinstance(self._id, basestring):
1339 self._entry = pwd.getpwnam(self._id)
1339 self._entry = pwd.getpwnam(self._id)
1340 else:
1340 else:
1341 self._entry = pwd.getpwuid(self._id)
1341 self._entry = pwd.getpwuid(self._id)
1342 return self._entry
1342 return self._entry
1343
1343
1344 def getname(self):
1344 def getname(self):
1345 if isinstance(self._id, basestring):
1345 if isinstance(self._id, basestring):
1346 return self._id
1346 return self._id
1347 else:
1347 else:
1348 return self._getentry().pw_name
1348 return self._getentry().pw_name
1349 name = property(getname, None, None, "User name")
1349 name = property(getname, None, None, "User name")
1350
1350
1351 def getpasswd(self):
1351 def getpasswd(self):
1352 return self._getentry().pw_passwd
1352 return self._getentry().pw_passwd
1353 passwd = property(getpasswd, None, None, "Password")
1353 passwd = property(getpasswd, None, None, "Password")
1354
1354
1355 def getuid(self):
1355 def getuid(self):
1356 if isinstance(self._id, basestring):
1356 if isinstance(self._id, basestring):
1357 return self._getentry().pw_uid
1357 return self._getentry().pw_uid
1358 else:
1358 else:
1359 return self._id
1359 return self._id
1360 uid = property(getuid, None, None, "User id")
1360 uid = property(getuid, None, None, "User id")
1361
1361
1362 def getgid(self):
1362 def getgid(self):
1363 return self._getentry().pw_gid
1363 return self._getentry().pw_gid
1364 gid = property(getgid, None, None, "Primary group id")
1364 gid = property(getgid, None, None, "Primary group id")
1365
1365
1366 def getgroup(self):
1366 def getgroup(self):
1367 return igrpentry(self.gid)
1367 return igrpentry(self.gid)
1368 group = property(getgroup, None, None, "Group")
1368 group = property(getgroup, None, None, "Group")
1369
1369
1370 def getgecos(self):
1370 def getgecos(self):
1371 return self._getentry().pw_gecos
1371 return self._getentry().pw_gecos
1372 gecos = property(getgecos, None, None, "Information (e.g. full user name)")
1372 gecos = property(getgecos, None, None, "Information (e.g. full user name)")
1373
1373
1374 def getdir(self):
1374 def getdir(self):
1375 return self._getentry().pw_dir
1375 return self._getentry().pw_dir
1376 dir = property(getdir, None, None, "$HOME directory")
1376 dir = property(getdir, None, None, "$HOME directory")
1377
1377
1378 def getshell(self):
1378 def getshell(self):
1379 return self._getentry().pw_shell
1379 return self._getentry().pw_shell
1380 shell = property(getshell, None, None, "Login shell")
1380 shell = property(getshell, None, None, "Login shell")
1381
1381
1382 def __xattrs__(self, mode="default"):
1382 def __xattrs__(self, mode="default"):
1383 return ("name", "passwd", "uid", "gid", "gecos", "dir", "shell")
1383 return ("name", "passwd", "uid", "gid", "gecos", "dir", "shell")
1384
1384
1385 def __repr__(self):
1385 def __repr__(self):
1386 return "%s.%s(%r)" % \
1386 return "%s.%s(%r)" % \
1387 (self.__class__.__module__, self.__class__.__name__, self._id)
1387 (self.__class__.__module__, self.__class__.__name__, self._id)
1388
1388
1389
1389
1390 class ipwd(Table):
1390 class ipwd(Table):
1391 """
1391 """
1392 List all entries in the Unix user account and password database.
1392 List all entries in the Unix user account and password database.
1393
1393
1394 Example::
1394 Example::
1395
1395
1396 >>> ipwd | isort("uid")
1396 >>> ipwd | isort("uid")
1397 <IPython.Extensions.ipipe.isort key='uid' reverse=False at 0x849efec>
1397 <IPython.Extensions.ipipe.isort key='uid' reverse=False at 0x849efec>
1398 # random
1398 # random
1399 """
1399 """
1400 def __iter__(self):
1400 def __iter__(self):
1401 for entry in pwd.getpwall():
1401 for entry in pwd.getpwall():
1402 yield ipwdentry(entry.pw_name)
1402 yield ipwdentry(entry.pw_name)
1403
1403
1404 def __xrepr__(self, mode="default"):
1404 def __xrepr__(self, mode="default"):
1405 if mode == "header" or mode == "footer" or mode == "cell":
1405 if mode == "header" or mode == "footer" or mode == "cell":
1406 yield (astyle.style_default, "%s()" % self.__class__.__name__)
1406 yield (astyle.style_default, "%s()" % self.__class__.__name__)
1407 else:
1407 else:
1408 yield (astyle.style_default, repr(self))
1408 yield (astyle.style_default, repr(self))
1409
1409
1410
1410
1411 class igrpentry(object):
1411 class igrpentry(object):
1412 """
1412 """
1413 ``igrpentry`` objects encapsulate entries in the Unix group database.
1413 ``igrpentry`` objects encapsulate entries in the Unix group database.
1414 """
1414 """
1415 def __init__(self, id):
1415 def __init__(self, id):
1416 self._id = id
1416 self._id = id
1417 self._entry = None
1417 self._entry = None
1418
1418
1419 def __eq__(self, other):
1419 def __eq__(self, other):
1420 return self.__class__ is other.__class__ and self._id == other._id
1420 return self.__class__ is other.__class__ and self._id == other._id
1421
1421
1422 def __ne__(self, other):
1422 def __ne__(self, other):
1423 return self.__class__ is not other.__class__ or self._id != other._id
1423 return self.__class__ is not other.__class__ or self._id != other._id
1424
1424
1425 def _getentry(self):
1425 def _getentry(self):
1426 if self._entry is None:
1426 if self._entry is None:
1427 if isinstance(self._id, basestring):
1427 if isinstance(self._id, basestring):
1428 self._entry = grp.getgrnam(self._id)
1428 self._entry = grp.getgrnam(self._id)
1429 else:
1429 else:
1430 self._entry = grp.getgrgid(self._id)
1430 self._entry = grp.getgrgid(self._id)
1431 return self._entry
1431 return self._entry
1432
1432
1433 def getname(self):
1433 def getname(self):
1434 if isinstance(self._id, basestring):
1434 if isinstance(self._id, basestring):
1435 return self._id
1435 return self._id
1436 else:
1436 else:
1437 return self._getentry().gr_name
1437 return self._getentry().gr_name
1438 name = property(getname, None, None, "Group name")
1438 name = property(getname, None, None, "Group name")
1439
1439
1440 def getpasswd(self):
1440 def getpasswd(self):
1441 return self._getentry().gr_passwd
1441 return self._getentry().gr_passwd
1442 passwd = property(getpasswd, None, None, "Password")
1442 passwd = property(getpasswd, None, None, "Password")
1443
1443
1444 def getgid(self):
1444 def getgid(self):
1445 if isinstance(self._id, basestring):
1445 if isinstance(self._id, basestring):
1446 return self._getentry().gr_gid
1446 return self._getentry().gr_gid
1447 else:
1447 else:
1448 return self._id
1448 return self._id
1449 gid = property(getgid, None, None, "Group id")
1449 gid = property(getgid, None, None, "Group id")
1450
1450
1451 def getmem(self):
1451 def getmem(self):
1452 return self._getentry().gr_mem
1452 return self._getentry().gr_mem
1453 mem = property(getmem, None, None, "Members")
1453 mem = property(getmem, None, None, "Members")
1454
1454
1455 def __xattrs__(self, mode="default"):
1455 def __xattrs__(self, mode="default"):
1456 return ("name", "passwd", "gid", "mem")
1456 return ("name", "passwd", "gid", "mem")
1457
1457
1458 def __xrepr__(self, mode="default"):
1458 def __xrepr__(self, mode="default"):
1459 if mode == "header" or mode == "footer" or mode == "cell":
1459 if mode == "header" or mode == "footer" or mode == "cell":
1460 yield (astyle.style_default, "group ")
1460 yield (astyle.style_default, "group ")
1461 try:
1461 try:
1462 yield (astyle.style_default, self.name)
1462 yield (astyle.style_default, self.name)
1463 except KeyError:
1463 except KeyError:
1464 if isinstance(self._id, basestring):
1464 if isinstance(self._id, basestring):
1465 yield (astyle.style_default, self.name_id)
1465 yield (astyle.style_default, self.name_id)
1466 else:
1466 else:
1467 yield (astyle.style_type_number, str(self._id))
1467 yield (astyle.style_type_number, str(self._id))
1468 else:
1468 else:
1469 yield (astyle.style_default, repr(self))
1469 yield (astyle.style_default, repr(self))
1470
1470
1471 def __iter__(self):
1471 def __iter__(self):
1472 for member in self.mem:
1472 for member in self.mem:
1473 yield ipwdentry(member)
1473 yield ipwdentry(member)
1474
1474
1475 def __repr__(self):
1475 def __repr__(self):
1476 return "%s.%s(%r)" % \
1476 return "%s.%s(%r)" % \
1477 (self.__class__.__module__, self.__class__.__name__, self._id)
1477 (self.__class__.__module__, self.__class__.__name__, self._id)
1478
1478
1479
1479
1480 class igrp(Table):
1480 class igrp(Table):
1481 """
1481 """
1482 This ``Table`` lists all entries in the Unix group database.
1482 This ``Table`` lists all entries in the Unix group database.
1483 """
1483 """
1484 def __iter__(self):
1484 def __iter__(self):
1485 for entry in grp.getgrall():
1485 for entry in grp.getgrall():
1486 yield igrpentry(entry.gr_name)
1486 yield igrpentry(entry.gr_name)
1487
1487
1488 def __xrepr__(self, mode="default"):
1488 def __xrepr__(self, mode="default"):
1489 if mode == "header" or mode == "footer":
1489 if mode == "header" or mode == "footer":
1490 yield (astyle.style_default, "%s()" % self.__class__.__name__)
1490 yield (astyle.style_default, "%s()" % self.__class__.__name__)
1491 else:
1491 else:
1492 yield (astyle.style_default, repr(self))
1492 yield (astyle.style_default, repr(self))
1493
1493
1494
1494
1495 class Fields(object):
1495 class Fields(object):
1496 def __init__(self, fieldnames, **fields):
1496 def __init__(self, fieldnames, **fields):
1497 self.__fieldnames = [upgradexattr(fieldname) for fieldname in fieldnames]
1497 self.__fieldnames = [upgradexattr(fieldname) for fieldname in fieldnames]
1498 for (key, value) in fields.iteritems():
1498 for (key, value) in fields.iteritems():
1499 setattr(self, key, value)
1499 setattr(self, key, value)
1500
1500
1501 def __xattrs__(self, mode="default"):
1501 def __xattrs__(self, mode="default"):
1502 return self.__fieldnames
1502 return self.__fieldnames
1503
1503
1504 def __xrepr__(self, mode="default"):
1504 def __xrepr__(self, mode="default"):
1505 yield (-1, False)
1505 yield (-1, False)
1506 if mode == "header" or mode == "cell":
1506 if mode == "header" or mode == "cell":
1507 yield (astyle.style_default, self.__class__.__name__)
1507 yield (astyle.style_default, self.__class__.__name__)
1508 yield (astyle.style_default, "(")
1508 yield (astyle.style_default, "(")
1509 for (i, f) in enumerate(self.__fieldnames):
1509 for (i, f) in enumerate(self.__fieldnames):
1510 if i:
1510 if i:
1511 yield (astyle.style_default, ", ")
1511 yield (astyle.style_default, ", ")
1512 yield (astyle.style_default, f.name())
1512 yield (astyle.style_default, f.name())
1513 yield (astyle.style_default, "=")
1513 yield (astyle.style_default, "=")
1514 for part in xrepr(getattr(self, f), "default"):
1514 for part in xrepr(getattr(self, f), "default"):
1515 yield part
1515 yield part
1516 yield (astyle.style_default, ")")
1516 yield (astyle.style_default, ")")
1517 elif mode == "footer":
1517 elif mode == "footer":
1518 yield (astyle.style_default, self.__class__.__name__)
1518 yield (astyle.style_default, self.__class__.__name__)
1519 yield (astyle.style_default, "(")
1519 yield (astyle.style_default, "(")
1520 for (i, f) in enumerate(self.__fieldnames):
1520 for (i, f) in enumerate(self.__fieldnames):
1521 if i:
1521 if i:
1522 yield (astyle.style_default, ", ")
1522 yield (astyle.style_default, ", ")
1523 yield (astyle.style_default, f.name())
1523 yield (astyle.style_default, f.name())
1524 yield (astyle.style_default, ")")
1524 yield (astyle.style_default, ")")
1525 else:
1525 else:
1526 yield (astyle.style_default, repr(self))
1526 yield (astyle.style_default, repr(self))
1527
1527
1528
1528
1529 class FieldTable(Table, list):
1529 class FieldTable(Table, list):
1530 def __init__(self, *fields):
1530 def __init__(self, *fields):
1531 Table.__init__(self)
1531 Table.__init__(self)
1532 list.__init__(self)
1532 list.__init__(self)
1533 self.fields = fields
1533 self.fields = fields
1534
1534
1535 def add(self, **fields):
1535 def add(self, **fields):
1536 self.append(Fields(self.fields, **fields))
1536 self.append(Fields(self.fields, **fields))
1537
1537
1538 def __xrepr__(self, mode="default"):
1538 def __xrepr__(self, mode="default"):
1539 yield (-1, False)
1539 yield (-1, False)
1540 if mode == "header" or mode == "footer":
1540 if mode == "header" or mode == "footer":
1541 yield (astyle.style_default, self.__class__.__name__)
1541 yield (astyle.style_default, self.__class__.__name__)
1542 yield (astyle.style_default, "(")
1542 yield (astyle.style_default, "(")
1543 for (i, f) in enumerate(self.__fieldnames):
1543 for (i, f) in enumerate(self.__fieldnames):
1544 if i:
1544 if i:
1545 yield (astyle.style_default, ", ")
1545 yield (astyle.style_default, ", ")
1546 yield (astyle.style_default, f)
1546 yield (astyle.style_default, f)
1547 yield (astyle.style_default, ")")
1547 yield (astyle.style_default, ")")
1548 else:
1548 else:
1549 yield (astyle.style_default, repr(self))
1549 yield (astyle.style_default, repr(self))
1550
1550
1551 def __repr__(self):
1551 def __repr__(self):
1552 return "<%s.%s object with fields=%r at 0x%x>" % \
1552 return "<%s.%s object with fields=%r at 0x%x>" % \
1553 (self.__class__.__module__, self.__class__.__name__,
1553 (self.__class__.__module__, self.__class__.__name__,
1554 ", ".join(map(repr, self.fields)), id(self))
1554 ", ".join(map(repr, self.fields)), id(self))
1555
1555
1556
1556
1557 class List(list):
1557 class List(list):
1558 def __xattrs__(self, mode="default"):
1558 def __xattrs__(self, mode="default"):
1559 return xrange(len(self))
1559 return xrange(len(self))
1560
1560
1561 def __xrepr__(self, mode="default"):
1561 def __xrepr__(self, mode="default"):
1562 yield (-1, False)
1562 yield (-1, False)
1563 if mode == "header" or mode == "cell" or mode == "footer" or mode == "default":
1563 if mode == "header" or mode == "cell" or mode == "footer" or mode == "default":
1564 yield (astyle.style_default, self.__class__.__name__)
1564 yield (astyle.style_default, self.__class__.__name__)
1565 yield (astyle.style_default, "(")
1565 yield (astyle.style_default, "(")
1566 for (i, item) in enumerate(self):
1566 for (i, item) in enumerate(self):
1567 if i:
1567 if i:
1568 yield (astyle.style_default, ", ")
1568 yield (astyle.style_default, ", ")
1569 for part in xrepr(item, "default"):
1569 for part in xrepr(item, "default"):
1570 yield part
1570 yield part
1571 yield (astyle.style_default, ")")
1571 yield (astyle.style_default, ")")
1572 else:
1572 else:
1573 yield (astyle.style_default, repr(self))
1573 yield (astyle.style_default, repr(self))
1574
1574
1575
1575
1576 class ienv(Table):
1576 class ienv(Table):
1577 """
1577 """
1578 List environment variables.
1578 List environment variables.
1579
1579
1580 Example::
1580 Example::
1581
1581
1582 >>> ienv
1582 >>> ienv
1583 <class 'IPython.Extensions.ipipe.ienv'>
1583 <class 'IPython.Extensions.ipipe.ienv'>
1584 """
1584 """
1585
1585
1586 def __iter__(self):
1586 def __iter__(self):
1587 fields = ("key", "value")
1587 fields = ("key", "value")
1588 for (key, value) in os.environ.iteritems():
1588 for (key, value) in os.environ.iteritems():
1589 yield Fields(fields, key=key, value=value)
1589 yield Fields(fields, key=key, value=value)
1590
1590
1591 def __xrepr__(self, mode="default"):
1591 def __xrepr__(self, mode="default"):
1592 if mode == "header" or mode == "cell":
1592 if mode == "header" or mode == "cell":
1593 yield (astyle.style_default, "%s()" % self.__class__.__name__)
1593 yield (astyle.style_default, "%s()" % self.__class__.__name__)
1594 else:
1594 else:
1595 yield (astyle.style_default, repr(self))
1595 yield (astyle.style_default, repr(self))
1596
1596
1597
1597
1598 class ihist(Table):
1598 class ihist(Table):
1599 """
1599 """
1600 IPython input history
1600 IPython input history
1601
1601
1602 Example::
1602 Example::
1603
1603
1604 >>> ihist
1604 >>> ihist
1605 <class 'IPython.Extensions.ipipe.ihist'>
1605 <class 'IPython.Extensions.ipipe.ihist'>
1606 >>> ihist(True) # raw mode
1606 >>> ihist(True) # raw mode
1607 <IPython.Extensions.ipipe.ihist object at 0x849602c> # random
1607 <IPython.Extensions.ipipe.ihist object at 0x849602c> # random
1608 """
1608 """
1609 def __init__(self, raw=True):
1609 def __init__(self, raw=True):
1610 self.raw = raw
1610 self.raw = raw
1611
1611
1612 def __iter__(self):
1612 def __iter__(self):
1613 api = ipapi.get()
1613 api = ipapi.get()
1614 if self.raw:
1614 if self.raw:
1615 for line in api.IP.input_hist_raw:
1615 for line in api.IP.input_hist_raw:
1616 yield line.rstrip("\n")
1616 yield line.rstrip("\n")
1617 else:
1617 else:
1618 for line in api.IP.input_hist:
1618 for line in api.IP.input_hist:
1619 yield line.rstrip("\n")
1619 yield line.rstrip("\n")
1620
1620
1621
1621
1622 class Alias(object):
1622 class Alias(object):
1623 """
1623 """
1624 Entry in the alias table
1624 Entry in the alias table
1625 """
1625 """
1626 def __init__(self, name, args, command):
1626 def __init__(self, name, args, command):
1627 self.name = name
1627 self.name = name
1628 self.args = args
1628 self.args = args
1629 self.command = command
1629 self.command = command
1630
1630
1631 def __xattrs__(self, mode="default"):
1631 def __xattrs__(self, mode="default"):
1632 return ("name", "args", "command")
1632 return ("name", "args", "command")
1633
1633
1634
1634
1635 class ialias(Table):
1635 class ialias(Table):
1636 """
1636 """
1637 IPython alias list
1637 IPython alias list
1638
1638
1639 Example::
1639 Example::
1640
1640
1641 >>> ialias
1641 >>> ialias
1642 <class 'IPython.Extensions.ipipe.ialias'>
1642 <class 'IPython.Extensions.ipipe.ialias'>
1643 """
1643 """
1644 def __iter__(self):
1644 def __iter__(self):
1645 api = ipapi.get()
1645 api = ipapi.get()
1646
1646
1647 for (name, (args, command)) in api.IP.alias_table.iteritems():
1647 for (name, (args, command)) in api.IP.alias_table.iteritems():
1648 yield Alias(name, args, command)
1648 yield Alias(name, args, command)
1649
1649
1650
1650
1651 class icsv(Pipe):
1651 class icsv(Pipe):
1652 """
1652 """
1653 This ``Pipe`` turns the input (with must be a pipe outputting lines
1653 This ``Pipe`` turns the input (with must be a pipe outputting lines
1654 or an ``ifile``) into lines of CVS columns.
1654 or an ``ifile``) into lines of CVS columns.
1655 """
1655 """
1656 def __init__(self, **csvargs):
1656 def __init__(self, **csvargs):
1657 """
1657 """
1658 Create an ``icsv`` object. ``cvsargs`` will be passed through as
1658 Create an ``icsv`` object. ``cvsargs`` will be passed through as
1659 keyword arguments to ``cvs.reader()``.
1659 keyword arguments to ``cvs.reader()``.
1660 """
1660 """
1661 self.csvargs = csvargs
1661 self.csvargs = csvargs
1662
1662
1663 def __iter__(self):
1663 def __iter__(self):
1664 input = self.input
1664 input = self.input
1665 if isinstance(input, ifile):
1665 if isinstance(input, ifile):
1666 input = input.open("rb")
1666 input = input.open("rb")
1667 reader = csv.reader(input, **self.csvargs)
1667 reader = csv.reader(input, **self.csvargs)
1668 for line in reader:
1668 for line in reader:
1669 yield List(line)
1669 yield List(line)
1670
1670
1671 def __xrepr__(self, mode="default"):
1671 def __xrepr__(self, mode="default"):
1672 yield (-1, False)
1672 yield (-1, False)
1673 if mode == "header" or mode == "footer":
1673 if mode == "header" or mode == "footer":
1674 input = getattr(self, "input", None)
1674 input = getattr(self, "input", None)
1675 if input is not None:
1675 if input is not None:
1676 for part in xrepr(input, mode):
1676 for part in xrepr(input, mode):
1677 yield part
1677 yield part
1678 yield (astyle.style_default, " | ")
1678 yield (astyle.style_default, " | ")
1679 yield (astyle.style_default, "%s(" % self.__class__.__name__)
1679 yield (astyle.style_default, "%s(" % self.__class__.__name__)
1680 for (i, (name, value)) in enumerate(self.csvargs.iteritems()):
1680 for (i, (name, value)) in enumerate(self.csvargs.iteritems()):
1681 if i:
1681 if i:
1682 yield (astyle.style_default, ", ")
1682 yield (astyle.style_default, ", ")
1683 yield (astyle.style_default, name)
1683 yield (astyle.style_default, name)
1684 yield (astyle.style_default, "=")
1684 yield (astyle.style_default, "=")
1685 for part in xrepr(value, "default"):
1685 for part in xrepr(value, "default"):
1686 yield part
1686 yield part
1687 yield (astyle.style_default, ")")
1687 yield (astyle.style_default, ")")
1688 else:
1688 else:
1689 yield (astyle.style_default, repr(self))
1689 yield (astyle.style_default, repr(self))
1690
1690
1691 def __repr__(self):
1691 def __repr__(self):
1692 args = ", ".join(["%s=%r" % item for item in self.csvargs.iteritems()])
1692 args = ", ".join(["%s=%r" % item for item in self.csvargs.iteritems()])
1693 return "<%s.%s %s at 0x%x>" % \
1693 return "<%s.%s %s at 0x%x>" % \
1694 (self.__class__.__module__, self.__class__.__name__, args, id(self))
1694 (self.__class__.__module__, self.__class__.__name__, args, id(self))
1695
1695
1696
1696
1697 class ix(Table):
1697 class ix(Table):
1698 """
1698 """
1699 Execute a system command and list its output as lines
1699 Execute a system command and list its output as lines
1700 (similar to ``os.popen()``).
1700 (similar to ``os.popen()``).
1701
1701
1702 Examples::
1702 Examples::
1703
1703
1704 >>> ix("ps x")
1704 >>> ix("ps x")
1705 IPython.Extensions.ipipe.ix('ps x')
1705 IPython.Extensions.ipipe.ix('ps x')
1706
1706
1707 >>> ix("find .") | ifile
1707 >>> ix("find .") | ifile
1708 <IPython.Extensions.ipipe.ieval expr=<class 'IPython.Extensions.ipipe.ifile'> at 0x8509d2c>
1708 <IPython.Extensions.ipipe.ieval expr=<class 'IPython.Extensions.ipipe.ifile'> at 0x8509d2c>
1709 # random
1709 # random
1710 """
1710 """
1711 def __init__(self, cmd):
1711 def __init__(self, cmd):
1712 self.cmd = cmd
1712 self.cmd = cmd
1713 self._pipeout = None
1713 self._pipeout = None
1714
1714
1715 def __iter__(self):
1715 def __iter__(self):
1716 (_pipein, self._pipeout) = os.popen4(self.cmd)
1716 (_pipein, self._pipeout) = os.popen4(self.cmd)
1717 _pipein.close()
1717 _pipein.close()
1718 for l in self._pipeout:
1718 for l in self._pipeout:
1719 yield l.rstrip("\r\n")
1719 yield l.rstrip("\r\n")
1720 self._pipeout.close()
1720 self._pipeout.close()
1721 self._pipeout = None
1721 self._pipeout = None
1722
1722
1723 def __del__(self):
1723 def __del__(self):
1724 if self._pipeout is not None and not self._pipeout.closed:
1724 if self._pipeout is not None and not self._pipeout.closed:
1725 self._pipeout.close()
1725 self._pipeout.close()
1726 self._pipeout = None
1726 self._pipeout = None
1727
1727
1728 def __xrepr__(self, mode="default"):
1728 def __xrepr__(self, mode="default"):
1729 if mode == "header" or mode == "footer":
1729 if mode == "header" or mode == "footer":
1730 yield (astyle.style_default,
1730 yield (astyle.style_default,
1731 "%s(%r)" % (self.__class__.__name__, self.cmd))
1731 "%s(%r)" % (self.__class__.__name__, self.cmd))
1732 else:
1732 else:
1733 yield (astyle.style_default, repr(self))
1733 yield (astyle.style_default, repr(self))
1734
1734
1735 def __repr__(self):
1735 def __repr__(self):
1736 return "%s.%s(%r)" % \
1736 return "%s.%s(%r)" % \
1737 (self.__class__.__module__, self.__class__.__name__, self.cmd)
1737 (self.__class__.__module__, self.__class__.__name__, self.cmd)
1738
1738
1739
1739
1740 class ifilter(Pipe):
1740 class ifilter(Pipe):
1741 """
1741 """
1742 Filter an input pipe. Only objects where an expression evaluates to true
1742 Filter an input pipe. Only objects where an expression evaluates to true
1743 (and doesn't raise an exception) are listed.
1743 (and doesn't raise an exception) are listed.
1744
1744
1745 Examples::
1745 Examples::
1746
1746
1747 >>> ils | ifilter("_.isfile() and size>1000")
1747 >>> ils | ifilter("_.isfile() and size>1000")
1748 >>> igrp | ifilter("len(mem)")
1748 >>> igrp | ifilter("len(mem)")
1749 >>> sys.modules | ifilter(lambda _:_.value is not None)
1749 >>> sys.modules | ifilter(lambda _:_.value is not None)
1750 # all-random
1750 # all-random
1751 """
1751 """
1752
1752
1753 def __init__(self, expr, globals=None, errors="raiseifallfail"):
1753 def __init__(self, expr, globals=None, errors="raiseifallfail"):
1754 """
1754 """
1755 Create an ``ifilter`` object. ``expr`` can be a callable or a string
1755 Create an ``ifilter`` object. ``expr`` can be a callable or a string
1756 containing an expression. ``globals`` will be used as the global
1756 containing an expression. ``globals`` will be used as the global
1757 namespace for calling string expressions (defaulting to IPython's
1757 namespace for calling string expressions (defaulting to IPython's
1758 user namespace). ``errors`` specifies how exception during evaluation
1758 user namespace). ``errors`` specifies how exception during evaluation
1759 of ``expr`` are handled:
1759 of ``expr`` are handled:
1760
1760
1761 ``"drop"``
1761 ``"drop"``
1762 drop all items that have errors;
1762 drop all items that have errors;
1763
1763
1764 ``"keep"``
1764 ``"keep"``
1765 keep all items that have errors;
1765 keep all items that have errors;
1766
1766
1767 ``"keeperror"``
1767 ``"keeperror"``
1768 keep the exception of all items that have errors;
1768 keep the exception of all items that have errors;
1769
1769
1770 ``"raise"``
1770 ``"raise"``
1771 raise the exception;
1771 raise the exception;
1772
1772
1773 ``"raiseifallfail"``
1773 ``"raiseifallfail"``
1774 raise the first exception if all items have errors; otherwise drop
1774 raise the first exception if all items have errors; otherwise drop
1775 those with errors (this is the default).
1775 those with errors (this is the default).
1776 """
1776 """
1777 self.expr = expr
1777 self.expr = expr
1778 self.globals = globals
1778 self.globals = globals
1779 self.errors = errors
1779 self.errors = errors
1780
1780
1781 def __iter__(self):
1781 def __iter__(self):
1782 if callable(self.expr):
1782 if callable(self.expr):
1783 test = self.expr
1783 test = self.expr
1784 else:
1784 else:
1785 g = getglobals(self.globals)
1785 g = getglobals(self.globals)
1786 expr = compile(self.expr, "ipipe-expression", "eval")
1786 expr = compile(self.expr, "ipipe-expression", "eval")
1787 def test(item):
1787 def test(item):
1788 return eval(expr, g, AttrNamespace(item))
1788 return eval(expr, g, AttrNamespace(item))
1789
1789
1790 ok = 0
1790 ok = 0
1791 exc_info = None
1791 exc_info = None
1792 for item in xiter(self.input):
1792 for item in xiter(self.input):
1793 try:
1793 try:
1794 if test(item):
1794 if test(item):
1795 yield item
1795 yield item
1796 ok += 1
1796 ok += 1
1797 except (KeyboardInterrupt, SystemExit):
1797 except (KeyboardInterrupt, SystemExit):
1798 raise
1798 raise
1799 except Exception, exc:
1799 except Exception, exc:
1800 if self.errors == "drop":
1800 if self.errors == "drop":
1801 pass # Ignore errors
1801 pass # Ignore errors
1802 elif self.errors == "keep":
1802 elif self.errors == "keep":
1803 yield item
1803 yield item
1804 elif self.errors == "keeperror":
1804 elif self.errors == "keeperror":
1805 yield exc
1805 yield exc
1806 elif self.errors == "raise":
1806 elif self.errors == "raise":
1807 raise
1807 raise
1808 elif self.errors == "raiseifallfail":
1808 elif self.errors == "raiseifallfail":
1809 if exc_info is None:
1809 if exc_info is None:
1810 exc_info = sys.exc_info()
1810 exc_info = sys.exc_info()
1811 if not ok and exc_info is not None:
1811 if not ok and exc_info is not None:
1812 raise exc_info[0], exc_info[1], exc_info[2]
1812 raise exc_info[0], exc_info[1], exc_info[2]
1813
1813
1814 def __xrepr__(self, mode="default"):
1814 def __xrepr__(self, mode="default"):
1815 if mode == "header" or mode == "footer":
1815 if mode == "header" or mode == "footer":
1816 input = getattr(self, "input", None)
1816 input = getattr(self, "input", None)
1817 if input is not None:
1817 if input is not None:
1818 for part in xrepr(input, mode):
1818 for part in xrepr(input, mode):
1819 yield part
1819 yield part
1820 yield (astyle.style_default, " | ")
1820 yield (astyle.style_default, " | ")
1821 yield (astyle.style_default, "%s(" % self.__class__.__name__)
1821 yield (astyle.style_default, "%s(" % self.__class__.__name__)
1822 for part in xrepr(self.expr, "default"):
1822 for part in xrepr(self.expr, "default"):
1823 yield part
1823 yield part
1824 yield (astyle.style_default, ")")
1824 yield (astyle.style_default, ")")
1825 else:
1825 else:
1826 yield (astyle.style_default, repr(self))
1826 yield (astyle.style_default, repr(self))
1827
1827
1828 def __repr__(self):
1828 def __repr__(self):
1829 return "<%s.%s expr=%r at 0x%x>" % \
1829 return "<%s.%s expr=%r at 0x%x>" % \
1830 (self.__class__.__module__, self.__class__.__name__,
1830 (self.__class__.__module__, self.__class__.__name__,
1831 self.expr, id(self))
1831 self.expr, id(self))
1832
1832
1833
1833
1834 class ieval(Pipe):
1834 class ieval(Pipe):
1835 """
1835 """
1836 Evaluate an expression for each object in the input pipe.
1836 Evaluate an expression for each object in the input pipe.
1837
1837
1838 Examples::
1838 Examples::
1839
1839
1840 >>> ils | ieval("_.abspath()")
1840 >>> ils | ieval("_.abspath()")
1841 # random
1841 # random
1842 >>> sys.path | ieval(ifile)
1842 >>> sys.path | ieval(ifile)
1843 # random
1843 # random
1844 """
1844 """
1845
1845
1846 def __init__(self, expr, globals=None, errors="raiseifallfail"):
1846 def __init__(self, expr, globals=None, errors="raiseifallfail"):
1847 """
1847 """
1848 Create an ``ieval`` object. ``expr`` can be a callable or a string
1848 Create an ``ieval`` object. ``expr`` can be a callable or a string
1849 containing an expression. For the meaning of ``globals`` and
1849 containing an expression. For the meaning of ``globals`` and
1850 ``errors`` see ``ifilter``.
1850 ``errors`` see ``ifilter``.
1851 """
1851 """
1852 self.expr = expr
1852 self.expr = expr
1853 self.globals = globals
1853 self.globals = globals
1854 self.errors = errors
1854 self.errors = errors
1855
1855
1856 def __iter__(self):
1856 def __iter__(self):
1857 if callable(self.expr):
1857 if callable(self.expr):
1858 do = self.expr
1858 do = self.expr
1859 else:
1859 else:
1860 g = getglobals(self.globals)
1860 g = getglobals(self.globals)
1861 expr = compile(self.expr, "ipipe-expression", "eval")
1861 expr = compile(self.expr, "ipipe-expression", "eval")
1862 def do(item):
1862 def do(item):
1863 return eval(expr, g, AttrNamespace(item))
1863 return eval(expr, g, AttrNamespace(item))
1864
1864
1865 ok = 0
1865 ok = 0
1866 exc_info = None
1866 exc_info = None
1867 for item in xiter(self.input):
1867 for item in xiter(self.input):
1868 try:
1868 try:
1869 yield do(item)
1869 yield do(item)
1870 except (KeyboardInterrupt, SystemExit):
1870 except (KeyboardInterrupt, SystemExit):
1871 raise
1871 raise
1872 except Exception, exc:
1872 except Exception, exc:
1873 if self.errors == "drop":
1873 if self.errors == "drop":
1874 pass # Ignore errors
1874 pass # Ignore errors
1875 elif self.errors == "keep":
1875 elif self.errors == "keep":
1876 yield item
1876 yield item
1877 elif self.errors == "keeperror":
1877 elif self.errors == "keeperror":
1878 yield exc
1878 yield exc
1879 elif self.errors == "raise":
1879 elif self.errors == "raise":
1880 raise
1880 raise
1881 elif self.errors == "raiseifallfail":
1881 elif self.errors == "raiseifallfail":
1882 if exc_info is None:
1882 if exc_info is None:
1883 exc_info = sys.exc_info()
1883 exc_info = sys.exc_info()
1884 if not ok and exc_info is not None:
1884 if not ok and exc_info is not None:
1885 raise exc_info[0], exc_info[1], exc_info[2]
1885 raise exc_info[0], exc_info[1], exc_info[2]
1886
1886
1887 def __xrepr__(self, mode="default"):
1887 def __xrepr__(self, mode="default"):
1888 if mode == "header" or mode == "footer":
1888 if mode == "header" or mode == "footer":
1889 input = getattr(self, "input", None)
1889 input = getattr(self, "input", None)
1890 if input is not None:
1890 if input is not None:
1891 for part in xrepr(input, mode):
1891 for part in xrepr(input, mode):
1892 yield part
1892 yield part
1893 yield (astyle.style_default, " | ")
1893 yield (astyle.style_default, " | ")
1894 yield (astyle.style_default, "%s(" % self.__class__.__name__)
1894 yield (astyle.style_default, "%s(" % self.__class__.__name__)
1895 for part in xrepr(self.expr, "default"):
1895 for part in xrepr(self.expr, "default"):
1896 yield part
1896 yield part
1897 yield (astyle.style_default, ")")
1897 yield (astyle.style_default, ")")
1898 else:
1898 else:
1899 yield (astyle.style_default, repr(self))
1899 yield (astyle.style_default, repr(self))
1900
1900
1901 def __repr__(self):
1901 def __repr__(self):
1902 return "<%s.%s expr=%r at 0x%x>" % \
1902 return "<%s.%s expr=%r at 0x%x>" % \
1903 (self.__class__.__module__, self.__class__.__name__,
1903 (self.__class__.__module__, self.__class__.__name__,
1904 self.expr, id(self))
1904 self.expr, id(self))
1905
1905
1906
1906
1907 class ienum(Pipe):
1907 class ienum(Pipe):
1908 """
1908 """
1909 Enumerate the input pipe (i.e. wrap each input object in an object
1909 Enumerate the input pipe (i.e. wrap each input object in an object
1910 with ``index`` and ``object`` attributes).
1910 with ``index`` and ``object`` attributes).
1911
1911
1912 Examples::
1912 Examples::
1913
1913
1914 >>> xrange(20) | ieval("_,_*_") | ienum | ifilter("index % 2 == 0") | ieval("object")
1914 >>> xrange(20) | ieval("_,_*_") | ienum | ifilter("index % 2 == 0") | ieval("object")
1915 """
1915 """
1916 skip_doctest = True
1916 skip_doctest = True
1917
1917
1918 def __iter__(self):
1918 def __iter__(self):
1919 fields = ("index", "object")
1919 fields = ("index", "object")
1920 for (index, object) in enumerate(xiter(self.input)):
1920 for (index, object) in enumerate(xiter(self.input)):
1921 yield Fields(fields, index=index, object=object)
1921 yield Fields(fields, index=index, object=object)
1922
1922
1923
1923
1924 class isort(Pipe):
1924 class isort(Pipe):
1925 """
1925 """
1926 Sorts the input pipe.
1926 Sorts the input pipe.
1927
1927
1928 Examples::
1928 Examples::
1929
1929
1930 >>> ils | isort("size")
1930 >>> ils | isort("size")
1931 <IPython.Extensions.ipipe.isort key='size' reverse=False at 0x849ec2c>
1931 <IPython.Extensions.ipipe.isort key='size' reverse=False at 0x849ec2c>
1932 >>> ils | isort("_.isdir(), _.lower()", reverse=True)
1932 >>> ils | isort("_.isdir(), _.lower()", reverse=True)
1933 <IPython.Extensions.ipipe.isort key='_.isdir(), _.lower()' reverse=True at 0x849eacc>
1933 <IPython.Extensions.ipipe.isort key='_.isdir(), _.lower()' reverse=True at 0x849eacc>
1934 # all-random
1934 # all-random
1935 """
1935 """
1936
1936
1937 def __init__(self, key=None, globals=None, reverse=False):
1937 def __init__(self, key=None, globals=None, reverse=False):
1938 """
1938 """
1939 Create an ``isort`` object. ``key`` can be a callable or a string
1939 Create an ``isort`` object. ``key`` can be a callable or a string
1940 containing an expression (or ``None`` in which case the items
1940 containing an expression (or ``None`` in which case the items
1941 themselves will be sorted). If ``reverse`` is true the sort order
1941 themselves will be sorted). If ``reverse`` is true the sort order
1942 will be reversed. For the meaning of ``globals`` see ``ifilter``.
1942 will be reversed. For the meaning of ``globals`` see ``ifilter``.
1943 """
1943 """
1944 self.key = key
1944 self.key = key
1945 self.globals = globals
1945 self.globals = globals
1946 self.reverse = reverse
1946 self.reverse = reverse
1947
1947
1948 def __iter__(self):
1948 def __iter__(self):
1949 if self.key is None:
1949 if self.key is None:
1950 items = sorted(xiter(self.input), reverse=self.reverse)
1950 items = sorted(xiter(self.input), reverse=self.reverse)
1951 elif callable(self.key):
1951 elif callable(self.key):
1952 items = sorted(xiter(self.input), key=self.key, reverse=self.reverse)
1952 items = sorted(xiter(self.input), key=self.key, reverse=self.reverse)
1953 else:
1953 else:
1954 g = getglobals(self.globals)
1954 g = getglobals(self.globals)
1955 key = compile(self.key, "ipipe-expression", "eval")
1955 key = compile(self.key, "ipipe-expression", "eval")
1956 def realkey(item):
1956 def realkey(item):
1957 return eval(key, g, AttrNamespace(item))
1957 return eval(key, g, AttrNamespace(item))
1958 items = sorted(xiter(self.input), key=realkey, reverse=self.reverse)
1958 items = sorted(xiter(self.input), key=realkey, reverse=self.reverse)
1959 for item in items:
1959 for item in items:
1960 yield item
1960 yield item
1961
1961
1962 def __xrepr__(self, mode="default"):
1962 def __xrepr__(self, mode="default"):
1963 if mode == "header" or mode == "footer":
1963 if mode == "header" or mode == "footer":
1964 input = getattr(self, "input", None)
1964 input = getattr(self, "input", None)
1965 if input is not None:
1965 if input is not None:
1966 for part in xrepr(input, mode):
1966 for part in xrepr(input, mode):
1967 yield part
1967 yield part
1968 yield (astyle.style_default, " | ")
1968 yield (astyle.style_default, " | ")
1969 yield (astyle.style_default, "%s(" % self.__class__.__name__)
1969 yield (astyle.style_default, "%s(" % self.__class__.__name__)
1970 for part in xrepr(self.key, "default"):
1970 for part in xrepr(self.key, "default"):
1971 yield part
1971 yield part
1972 if self.reverse:
1972 if self.reverse:
1973 yield (astyle.style_default, ", ")
1973 yield (astyle.style_default, ", ")
1974 for part in xrepr(True, "default"):
1974 for part in xrepr(True, "default"):
1975 yield part
1975 yield part
1976 yield (astyle.style_default, ")")
1976 yield (astyle.style_default, ")")
1977 else:
1977 else:
1978 yield (astyle.style_default, repr(self))
1978 yield (astyle.style_default, repr(self))
1979
1979
1980 def __repr__(self):
1980 def __repr__(self):
1981 return "<%s.%s key=%r reverse=%r at 0x%x>" % \
1981 return "<%s.%s key=%r reverse=%r at 0x%x>" % \
1982 (self.__class__.__module__, self.__class__.__name__,
1982 (self.__class__.__module__, self.__class__.__name__,
1983 self.key, self.reverse, id(self))
1983 self.key, self.reverse, id(self))
1984
1984
1985
1985
1986 tab = 3 # for expandtabs()
1986 tab = 3 # for expandtabs()
1987
1987
1988 def _format(field):
1988 def _format(field):
1989 if isinstance(field, str):
1989 if isinstance(field, str):
1990 text = repr(field.expandtabs(tab))[1:-1]
1990 text = repr(field.expandtabs(tab))[1:-1]
1991 elif isinstance(field, unicode):
1991 elif isinstance(field, unicode):
1992 text = repr(field.expandtabs(tab))[2:-1]
1992 text = repr(field.expandtabs(tab))[2:-1]
1993 elif isinstance(field, datetime.datetime):
1993 elif isinstance(field, datetime.datetime):
1994 # Don't use strftime() here, as this requires year >= 1900
1994 # Don't use strftime() here, as this requires year >= 1900
1995 text = "%04d-%02d-%02d %02d:%02d:%02d.%06d" % \
1995 text = "%04d-%02d-%02d %02d:%02d:%02d.%06d" % \
1996 (field.year, field.month, field.day,
1996 (field.year, field.month, field.day,
1997 field.hour, field.minute, field.second, field.microsecond)
1997 field.hour, field.minute, field.second, field.microsecond)
1998 elif isinstance(field, datetime.date):
1998 elif isinstance(field, datetime.date):
1999 text = "%04d-%02d-%02d" % (field.year, field.month, field.day)
1999 text = "%04d-%02d-%02d" % (field.year, field.month, field.day)
2000 else:
2000 else:
2001 text = repr(field)
2001 text = repr(field)
2002 return text
2002 return text
2003
2003
2004
2004
2005 class Display(object):
2005 class Display(object):
2006 class __metaclass__(type):
2006 class __metaclass__(type):
2007 def __ror__(self, input):
2007 def __ror__(self, input):
2008 return input | self()
2008 return input | self()
2009
2009
2010 def __init__(self, input=None):
2010 def __init__(self, input=None):
2011 self.input = input
2011 self.input = input
2012
2012
2013 def __ror__(self, input):
2013 def __ror__(self, input):
2014 self.input = input
2014 self.input = input
2015 return self
2015 return self
2016
2016
2017 def display(self):
2017 def display(self):
2018 pass
2018 pass
2019
2019
2020
2020
2021 class iless(Display):
2021 class iless(Display):
2022 cmd = "less --quit-if-one-screen --LONG-PROMPT --LINE-NUMBERS --chop-long-lines --shift=8 --RAW-CONTROL-CHARS"
2022 cmd = "less --quit-if-one-screen --LONG-PROMPT --LINE-NUMBERS --chop-long-lines --shift=8 --RAW-CONTROL-CHARS"
2023
2023
2024 def display(self):
2024 def display(self):
2025 try:
2025 try:
2026 pager = os.popen(self.cmd, "w")
2026 pager = os.popen(self.cmd, "w")
2027 try:
2027 try:
2028 for item in xiter(self.input):
2028 for item in xiter(self.input):
2029 first = False
2029 first = False
2030 for attr in xattrs(item, "default"):
2030 for attr in xattrs(item, "default"):
2031 if first:
2031 if first:
2032 first = False
2032 first = False
2033 else:
2033 else:
2034 pager.write(" ")
2034 pager.write(" ")
2035 attr = upgradexattr(attr)
2035 attr = upgradexattr(attr)
2036 if not isinstance(attr, SelfDescriptor):
2036 if not isinstance(attr, SelfDescriptor):
2037 pager.write(attr.name())
2037 pager.write(attr.name())
2038 pager.write("=")
2038 pager.write("=")
2039 pager.write(str(attr.value(item)))
2039 pager.write(str(attr.value(item)))
2040 pager.write("\n")
2040 pager.write("\n")
2041 finally:
2041 finally:
2042 pager.close()
2042 pager.close()
2043 except Exception, exc:
2043 except Exception, exc:
2044 print "%s: %s" % (exc.__class__.__name__, str(exc))
2044 print "%s: %s" % (exc.__class__.__name__, str(exc))
2045
2045
2046
2046
2047 class _RedirectIO(object):
2047 class _RedirectIO(object):
2048 def __init__(self,*args,**kwargs):
2048 def __init__(self,*args,**kwargs):
2049 """
2049 """
2050 Map the system output streams to self.
2050 Map the system output streams to self.
2051 """
2051 """
2052 self.stream = StringIO.StringIO()
2052 self.stream = StringIO.StringIO()
2053 self.stdout = sys.stdout
2053 self.stdout = sys.stdout
2054 sys.stdout = self
2054 sys.stdout = self
2055 self.stderr = sys.stderr
2055 self.stderr = sys.stderr
2056 sys.stderr = self
2056 sys.stderr = self
2057
2057
2058 def write(self, text):
2058 def write(self, text):
2059 """
2059 """
2060 Write both to screen and to self.
2060 Write both to screen and to self.
2061 """
2061 """
2062 self.stream.write(text)
2062 self.stream.write(text)
2063 self.stdout.write(text)
2063 self.stdout.write(text)
2064 if "\n" in text:
2064 if "\n" in text:
2065 self.stdout.flush()
2065 self.stdout.flush()
2066
2066
2067 def writelines(self, lines):
2067 def writelines(self, lines):
2068 """
2068 """
2069 Write lines both to screen and to self.
2069 Write lines both to screen and to self.
2070 """
2070 """
2071 self.stream.writelines(lines)
2071 self.stream.writelines(lines)
2072 self.stdout.writelines(lines)
2072 self.stdout.writelines(lines)
2073 self.stdout.flush()
2073 self.stdout.flush()
2074
2074
2075 def restore(self):
2075 def restore(self):
2076 """
2076 """
2077 Restore the default system streams.
2077 Restore the default system streams.
2078 """
2078 """
2079 self.stdout.flush()
2079 self.stdout.flush()
2080 self.stderr.flush()
2080 self.stderr.flush()
2081 sys.stdout = self.stdout
2081 sys.stdout = self.stdout
2082 sys.stderr = self.stderr
2082 sys.stderr = self.stderr
2083
2083
2084
2084
2085 class icap(Table):
2085 class icap(Table):
2086 """
2086 """
2087 Execute a python string and capture any output to stderr/stdout.
2087 Execute a python string and capture any output to stderr/stdout.
2088
2088
2089 Examples::
2089 Examples::
2090
2090
2091 >>> import time
2091 >>> import time
2092 >>> icap("for i in range(10): print i, time.sleep(0.1)")
2092 >>> icap("for i in range(10): print i, time.sleep(0.1)")
2093
2093
2094 """
2094 """
2095 skip_doctest = True
2095 skip_doctest = True
2096
2096
2097 def __init__(self, expr, globals=None):
2097 def __init__(self, expr, globals=None):
2098 self.expr = expr
2098 self.expr = expr
2099 self.globals = globals
2099 self.globals = globals
2100 log = _RedirectIO()
2100 log = _RedirectIO()
2101 try:
2101 try:
2102 exec(expr, getglobals(globals))
2102 exec(expr, getglobals(globals))
2103 finally:
2103 finally:
2104 log.restore()
2104 log.restore()
2105 self.stream = log.stream
2105 self.stream = log.stream
2106
2106
2107 def __iter__(self):
2107 def __iter__(self):
2108 self.stream.seek(0)
2108 self.stream.seek(0)
2109 for line in self.stream:
2109 for line in self.stream:
2110 yield line.rstrip("\r\n")
2110 yield line.rstrip("\r\n")
2111
2111
2112 def __xrepr__(self, mode="default"):
2112 def __xrepr__(self, mode="default"):
2113 if mode == "header" or mode == "footer":
2113 if mode == "header" or mode == "footer":
2114 yield (astyle.style_default,
2114 yield (astyle.style_default,
2115 "%s(%r)" % (self.__class__.__name__, self.expr))
2115 "%s(%r)" % (self.__class__.__name__, self.expr))
2116 else:
2116 else:
2117 yield (astyle.style_default, repr(self))
2117 yield (astyle.style_default, repr(self))
2118
2118
2119 def __repr__(self):
2119 def __repr__(self):
2120 return "%s.%s(%r)" % \
2120 return "%s.%s(%r)" % \
2121 (self.__class__.__module__, self.__class__.__name__, self.expr)
2121 (self.__class__.__module__, self.__class__.__name__, self.expr)
2122
2122
2123
2123
2124 def xformat(value, mode, maxlength):
2124 def xformat(value, mode, maxlength):
2125 align = None
2125 align = None
2126 full = True
2126 full = True
2127 width = 0
2127 width = 0
2128 text = astyle.Text()
2128 text = astyle.Text()
2129 for (style, part) in xrepr(value, mode):
2129 for (style, part) in xrepr(value, mode):
2130 # only consider the first result
2130 # only consider the first result
2131 if align is None:
2131 if align is None:
2132 if isinstance(style, int):
2132 if isinstance(style, int):
2133 # (style, text) really is (alignment, stop)
2133 # (style, text) really is (alignment, stop)
2134 align = style
2134 align = style
2135 full = part
2135 full = part
2136 continue
2136 continue
2137 else:
2137 else:
2138 align = -1
2138 align = -1
2139 full = True
2139 full = True
2140 if not isinstance(style, int):
2140 if not isinstance(style, int):
2141 text.append((style, part))
2141 text.append((style, part))
2142 width += len(part)
2142 width += len(part)
2143 if width >= maxlength and not full:
2143 if width >= maxlength and not full:
2144 text.append((astyle.style_ellisis, "..."))
2144 text.append((astyle.style_ellisis, "..."))
2145 width += 3
2145 width += 3
2146 break
2146 break
2147 if align is None: # default to left alignment
2147 if align is None: # default to left alignment
2148 align = -1
2148 align = -1
2149 return (align, width, text)
2149 return (align, width, text)
2150
2150
2151
2151
2152
2152
2153 import astyle
2153 import astyle
2154
2154
2155 class idump(Display):
2155 class idump(Display):
2156 # The approximate maximum length of a column entry
2156 # The approximate maximum length of a column entry
2157 maxattrlength = 200
2157 maxattrlength = 200
2158
2158
2159 # Style for column names
2159 # Style for column names
2160 style_header = astyle.Style.fromstr("white:black:bold")
2160 style_header = astyle.Style.fromstr("white:black:bold")
2161
2161
2162 def __init__(self, input=None, *attrs):
2162 def __init__(self, input=None, *attrs):
2163 Display.__init__(self, input)
2163 Display.__init__(self, input)
2164 self.attrs = [upgradexattr(attr) for attr in attrs]
2164 self.attrs = [upgradexattr(attr) for attr in attrs]
2165 self.headerpadchar = " "
2165 self.headerpadchar = " "
2166 self.headersepchar = "|"
2166 self.headersepchar = "|"
2167 self.datapadchar = " "
2167 self.datapadchar = " "
2168 self.datasepchar = "|"
2168 self.datasepchar = "|"
2169
2169
2170 def display(self):
2170 def display(self):
2171 stream = genutils.Term.cout
2171 stream = genutils.Term.cout
2172 allattrs = []
2172 allattrs = []
2173 attrset = set()
2173 attrset = set()
2174 colwidths = {}
2174 colwidths = {}
2175 rows = []
2175 rows = []
2176 for item in xiter(self.input):
2176 for item in xiter(self.input):
2177 row = {}
2177 row = {}
2178 attrs = self.attrs
2178 attrs = self.attrs
2179 if not attrs:
2179 if not attrs:
2180 attrs = xattrs(item, "default")
2180 attrs = xattrs(item, "default")
2181 for attr in attrs:
2181 for attr in attrs:
2182 if attr not in attrset:
2182 if attr not in attrset:
2183 allattrs.append(attr)
2183 allattrs.append(attr)
2184 attrset.add(attr)
2184 attrset.add(attr)
2185 colwidths[attr] = len(attr.name())
2185 colwidths[attr] = len(attr.name())
2186 try:
2186 try:
2187 value = attr.value(item)
2187 value = attr.value(item)
2188 except (KeyboardInterrupt, SystemExit):
2188 except (KeyboardInterrupt, SystemExit):
2189 raise
2189 raise
2190 except Exception, exc:
2190 except Exception, exc:
2191 value = exc
2191 value = exc
2192 (align, width, text) = xformat(value, "cell", self.maxattrlength)
2192 (align, width, text) = xformat(value, "cell", self.maxattrlength)
2193 colwidths[attr] = max(colwidths[attr], width)
2193 colwidths[attr] = max(colwidths[attr], width)
2194 # remember alignment, length and colored parts
2194 # remember alignment, length and colored parts
2195 row[attr] = (align, width, text)
2195 row[attr] = (align, width, text)
2196 rows.append(row)
2196 rows.append(row)
2197
2197
2198 stream.write("\n")
2198 stream.write("\n")
2199 for (i, attr) in enumerate(allattrs):
2199 for (i, attr) in enumerate(allattrs):
2200 attrname = attr.name()
2200 attrname = attr.name()
2201 self.style_header(attrname).write(stream)
2201 self.style_header(attrname).write(stream)
2202 spc = colwidths[attr] - len(attrname)
2202 spc = colwidths[attr] - len(attrname)
2203 if i < len(colwidths)-1:
2203 if i < len(colwidths)-1:
2204 stream.write(self.headerpadchar*spc)
2204 stream.write(self.headerpadchar*spc)
2205 stream.write(self.headersepchar)
2205 stream.write(self.headersepchar)
2206 stream.write("\n")
2206 stream.write("\n")
2207
2207
2208 for row in rows:
2208 for row in rows:
2209 for (i, attr) in enumerate(allattrs):
2209 for (i, attr) in enumerate(allattrs):
2210 (align, width, text) = row[attr]
2210 (align, width, text) = row[attr]
2211 spc = colwidths[attr] - width
2211 spc = colwidths[attr] - width
2212 if align == -1:
2212 if align == -1:
2213 text.write(stream)
2213 text.write(stream)
2214 if i < len(colwidths)-1:
2214 if i < len(colwidths)-1:
2215 stream.write(self.datapadchar*spc)
2215 stream.write(self.datapadchar*spc)
2216 elif align == 0:
2216 elif align == 0:
2217 spc = colwidths[attr] - width
2217 spc = colwidths[attr] - width
2218 spc1 = spc//2
2218 spc1 = spc//2
2219 spc2 = spc-spc1
2219 spc2 = spc-spc1
2220 stream.write(self.datapadchar*spc1)
2220 stream.write(self.datapadchar*spc1)
2221 text.write(stream)
2221 text.write(stream)
2222 if i < len(colwidths)-1:
2222 if i < len(colwidths)-1:
2223 stream.write(self.datapadchar*spc2)
2223 stream.write(self.datapadchar*spc2)
2224 else:
2224 else:
2225 stream.write(self.datapadchar*spc)
2225 stream.write(self.datapadchar*spc)
2226 text.write(stream)
2226 text.write(stream)
2227 if i < len(colwidths)-1:
2227 if i < len(colwidths)-1:
2228 stream.write(self.datasepchar)
2228 stream.write(self.datasepchar)
2229 stream.write("\n")
2229 stream.write("\n")
2230
2230
2231
2231
2232 class AttributeDetail(Table):
2232 class AttributeDetail(Table):
2233 """
2233 """
2234 ``AttributeDetail`` objects are use for displaying a detailed list of object
2234 ``AttributeDetail`` objects are use for displaying a detailed list of object
2235 attributes.
2235 attributes.
2236 """
2236 """
2237 def __init__(self, object, descriptor):
2237 def __init__(self, object, descriptor):
2238 self.object = object
2238 self.object = object
2239 self.descriptor = descriptor
2239 self.descriptor = descriptor
2240
2240
2241 def __iter__(self):
2241 def __iter__(self):
2242 return self.descriptor.iter(self.object)
2242 return self.descriptor.iter(self.object)
2243
2243
2244 def name(self):
2244 def name(self):
2245 return self.descriptor.name()
2245 return self.descriptor.name()
2246
2246
2247 def attrtype(self):
2247 def attrtype(self):
2248 return self.descriptor.attrtype(self.object)
2248 return self.descriptor.attrtype(self.object)
2249
2249
2250 def valuetype(self):
2250 def valuetype(self):
2251 return self.descriptor.valuetype(self.object)
2251 return self.descriptor.valuetype(self.object)
2252
2252
2253 def doc(self):
2253 def doc(self):
2254 return self.descriptor.doc(self.object)
2254 return self.descriptor.doc(self.object)
2255
2255
2256 def shortdoc(self):
2256 def shortdoc(self):
2257 return self.descriptor.shortdoc(self.object)
2257 return self.descriptor.shortdoc(self.object)
2258
2258
2259 def value(self):
2259 def value(self):
2260 return self.descriptor.value(self.object)
2260 return self.descriptor.value(self.object)
2261
2261
2262 def __xattrs__(self, mode="default"):
2262 def __xattrs__(self, mode="default"):
2263 attrs = ("name()", "attrtype()", "valuetype()", "value()", "shortdoc()")
2263 attrs = ("name()", "attrtype()", "valuetype()", "value()", "shortdoc()")
2264 if mode == "detail":
2264 if mode == "detail":
2265 attrs += ("doc()",)
2265 attrs += ("doc()",)
2266 return attrs
2266 return attrs
2267
2267
2268 def __xrepr__(self, mode="default"):
2268 def __xrepr__(self, mode="default"):
2269 yield (-1, True)
2269 yield (-1, True)
2270 valuetype = self.valuetype()
2270 valuetype = self.valuetype()
2271 if valuetype is not noitem:
2271 if valuetype is not noitem:
2272 for part in xrepr(valuetype):
2272 for part in xrepr(valuetype):
2273 yield part
2273 yield part
2274 yield (astyle.style_default, " ")
2274 yield (astyle.style_default, " ")
2275 yield (astyle.style_default, self.attrtype())
2275 yield (astyle.style_default, self.attrtype())
2276 yield (astyle.style_default, " ")
2276 yield (astyle.style_default, " ")
2277 yield (astyle.style_default, self.name())
2277 yield (astyle.style_default, self.name())
2278 yield (astyle.style_default, " of ")
2278 yield (astyle.style_default, " of ")
2279 for part in xrepr(self.object):
2279 for part in xrepr(self.object):
2280 yield part
2280 yield part
2281
2281
2282
2282
2283 try:
2283 try:
2284 from ibrowse import ibrowse
2284 from ibrowse import ibrowse
2285 except ImportError:
2285 except ImportError:
2286 # No curses (probably Windows) => try igrid
2286 # No curses (probably Windows) => try igrid
2287 try:
2287 try:
2288 from igrid import igrid
2288 from igrid import igrid
2289 except ImportError:
2289 except ImportError:
2290 # no wx either => use ``idump`` as the default display.
2290 # no wx either => use ``idump`` as the default display.
2291 defaultdisplay = idump
2291 defaultdisplay = idump
2292 else:
2292 else:
2293 defaultdisplay = igrid
2293 defaultdisplay = igrid
2294 __all__.append("igrid")
2294 __all__.append("igrid")
2295 else:
2295 else:
2296 defaultdisplay = ibrowse
2296 defaultdisplay = ibrowse
2297 __all__.append("ibrowse")
2297 __all__.append("ibrowse")
2298
2298
2299
2299
2300 # If we're running under IPython, register our objects with IPython's
2300 # If we're running under IPython, register our objects with IPython's
2301 # generic function ``result_display``, else install a displayhook
2301 # generic function ``result_display``, else install a displayhook
2302 # directly as sys.displayhook
2302 # directly as sys.displayhook
2303 if generics is not None:
2303 if generics is not None:
2304 def display_display(obj):
2304 def display_display(obj):
2305 return obj.display()
2305 return obj.display()
2306 generics.result_display.when_type(Display)(display_display)
2306 generics.result_display.when_type(Display)(display_display)
2307
2307
2308 def display_tableobject(obj):
2308 def display_tableobject(obj):
2309 return display_display(defaultdisplay(obj))
2309 return display_display(defaultdisplay(obj))
2310 generics.result_display.when_type(Table)(display_tableobject)
2310 generics.result_display.when_type(Table)(display_tableobject)
2311
2311
2312 def display_tableclass(obj):
2312 def display_tableclass(obj):
2313 return display_tableobject(obj())
2313 return display_tableobject(obj())
2314 generics.result_display.when_type(Table.__metaclass__)(display_tableclass)
2314 generics.result_display.when_type(Table.__metaclass__)(display_tableclass)
2315 else:
2315 else:
2316 def installdisplayhook():
2316 def installdisplayhook():
2317 _originalhook = sys.displayhook
2317 _originalhook = sys.displayhook
2318 def displayhook(obj):
2318 def displayhook(obj):
2319 if isinstance(obj, type) and issubclass(obj, Table):
2319 if isinstance(obj, type) and issubclass(obj, Table):
2320 obj = obj()
2320 obj = obj()
2321 if isinstance(obj, Table):
2321 if isinstance(obj, Table):
2322 obj = defaultdisplay(obj)
2322 obj = defaultdisplay(obj)
2323 if isinstance(obj, Display):
2323 if isinstance(obj, Display):
2324 return obj.display()
2324 return obj.display()
2325 else:
2325 else:
2326 _originalhook(obj)
2326 _originalhook(obj)
2327 sys.displayhook = displayhook
2327 sys.displayhook = displayhook
2328 installdisplayhook()
2328 installdisplayhook()
@@ -1,76 +1,76 b''
1 """ Greedy completer extension for IPython
1 """ Greedy completer extension for IPython
2
2
3 Normal tab completer refuses to evaluate nonsafe stuff. This will evaluate
3 Normal tab completer refuses to evaluate nonsafe stuff. This will evaluate
4 everything, so you need to consider the consequences of pressing tab
4 everything, so you need to consider the consequences of pressing tab
5 yourself!
5 yourself!
6
6
7 Note that this extension simplifies readline interaction by setting
7 Note that this extension simplifies readline interaction by setting
8 only whitespace as completer delimiter. If this works well, we will
8 only whitespace as completer delimiter. If this works well, we will
9 do the same in default completer.
9 do the same in default completer.
10
10
11 """
11 """
12 from IPython import ipapi
12 from IPython import ipapi
13 from IPython.utils import generics
13 from IPython.utils import generics
14 from IPython.genutils import dir2
14 from IPython.utils.genutils import dir2
15
15
16 def attr_matches(self, text):
16 def attr_matches(self, text):
17 """Compute matches when text contains a dot.
17 """Compute matches when text contains a dot.
18
18
19 MONKEYPATCHED VERSION (ipy_greedycompleter.py)
19 MONKEYPATCHED VERSION (ipy_greedycompleter.py)
20
20
21 Assuming the text is of the form NAME.NAME....[NAME], and is
21 Assuming the text is of the form NAME.NAME....[NAME], and is
22 evaluatable in self.namespace or self.global_namespace, it will be
22 evaluatable in self.namespace or self.global_namespace, it will be
23 evaluated and its attributes (as revealed by dir()) are used as
23 evaluated and its attributes (as revealed by dir()) are used as
24 possible completions. (For class instances, class members are are
24 possible completions. (For class instances, class members are are
25 also considered.)
25 also considered.)
26
26
27 WARNING: this can still invoke arbitrary C code, if an object
27 WARNING: this can still invoke arbitrary C code, if an object
28 with a __getattr__ hook is evaluated.
28 with a __getattr__ hook is evaluated.
29
29
30 """
30 """
31 import re
31 import re
32
32
33 force_complete = 1
33 force_complete = 1
34 # Another option, seems to work great. Catches things like ''.<tab>
34 # Another option, seems to work great. Catches things like ''.<tab>
35 m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
35 m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
36
36
37 if m:
37 if m:
38 expr, attr = m.group(1, 3)
38 expr, attr = m.group(1, 3)
39 else:
39 else:
40 # force match - eval anything that ends with colon
40 # force match - eval anything that ends with colon
41 if not force_complete:
41 if not force_complete:
42 return []
42 return []
43
43
44 m2 = re.match(r"(.+)\.(\w*)$", self.lbuf)
44 m2 = re.match(r"(.+)\.(\w*)$", self.lbuf)
45 if not m2:
45 if not m2:
46 return []
46 return []
47 expr, attr = m2.group(1,2)
47 expr, attr = m2.group(1,2)
48
48
49
49
50 try:
50 try:
51 obj = eval(expr, self.namespace)
51 obj = eval(expr, self.namespace)
52 except:
52 except:
53 try:
53 try:
54 obj = eval(expr, self.global_namespace)
54 obj = eval(expr, self.global_namespace)
55 except:
55 except:
56 return []
56 return []
57
57
58 words = dir2(obj)
58 words = dir2(obj)
59
59
60 try:
60 try:
61 words = generics.complete_object(obj, words)
61 words = generics.complete_object(obj, words)
62 except ipapi.TryNext:
62 except ipapi.TryNext:
63 pass
63 pass
64 # Build match list to return
64 # Build match list to return
65 n = len(attr)
65 n = len(attr)
66 res = ["%s.%s" % (expr, w) for w in words if w[:n] == attr ]
66 res = ["%s.%s" % (expr, w) for w in words if w[:n] == attr ]
67 return res
67 return res
68
68
69 def main():
69 def main():
70 import IPython.rlineimpl as readline
70 import IPython.rlineimpl as readline
71 readline.set_completer_delims(" \n\t")
71 readline.set_completer_delims(" \n\t")
72 # monkeypatch - the code will be folded to normal completer later on
72 # monkeypatch - the code will be folded to normal completer later on
73 import IPython.core.completer
73 import IPython.core.completer
74 IPython.core.completer.Completer.attr_matches = attr_matches
74 IPython.core.completer.Completer.attr_matches = attr_matches
75
75
76 main() No newline at end of file
76 main()
@@ -1,62 +1,62 b''
1 """ Legacy stuff
1 """ Legacy stuff
2
2
3 Various stuff that are there for historical / familiarity reasons.
3 Various stuff that are there for historical / familiarity reasons.
4
4
5 This is automatically imported by default profile, though not other profiles
5 This is automatically imported by default profile, though not other profiles
6 (e.g. 'sh' profile).
6 (e.g. 'sh' profile).
7
7
8 Stuff that is considered obsolete / redundant is gradually moved here.
8 Stuff that is considered obsolete / redundant is gradually moved here.
9
9
10 """
10 """
11
11
12 import IPython.ipapi
12 import IPython.ipapi
13 ip = IPython.ipapi.get()
13 ip = IPython.ipapi.get()
14
14
15 import os,sys
15 import os,sys
16
16
17 from IPython.genutils import *
17 from IPython.utils.genutils import *
18
18
19 # use rehashx
19 # use rehashx
20
20
21 def magic_rehash(self, parameter_s = ''):
21 def magic_rehash(self, parameter_s = ''):
22 """Update the alias table with all entries in $PATH.
22 """Update the alias table with all entries in $PATH.
23
23
24 This version does no checks on execute permissions or whether the
24 This version does no checks on execute permissions or whether the
25 contents of $PATH are truly files (instead of directories or something
25 contents of $PATH are truly files (instead of directories or something
26 else). For such a safer (but slower) version, use %rehashx."""
26 else). For such a safer (but slower) version, use %rehashx."""
27
27
28 # This function (and rehashx) manipulate the alias_table directly
28 # This function (and rehashx) manipulate the alias_table directly
29 # rather than calling magic_alias, for speed reasons. A rehash on a
29 # rather than calling magic_alias, for speed reasons. A rehash on a
30 # typical Linux box involves several thousand entries, so efficiency
30 # typical Linux box involves several thousand entries, so efficiency
31 # here is a top concern.
31 # here is a top concern.
32
32
33 path = filter(os.path.isdir,os.environ.get('PATH','').split(os.pathsep))
33 path = filter(os.path.isdir,os.environ.get('PATH','').split(os.pathsep))
34 alias_table = self.shell.alias_table
34 alias_table = self.shell.alias_table
35 for pdir in path:
35 for pdir in path:
36 for ff in os.listdir(pdir):
36 for ff in os.listdir(pdir):
37 # each entry in the alias table must be (N,name), where
37 # each entry in the alias table must be (N,name), where
38 # N is the number of positional arguments of the alias.
38 # N is the number of positional arguments of the alias.
39 alias_table[ff] = (0,ff)
39 alias_table[ff] = (0,ff)
40 # Make sure the alias table doesn't contain keywords or builtins
40 # Make sure the alias table doesn't contain keywords or builtins
41 self.shell.alias_table_validate()
41 self.shell.alias_table_validate()
42 # Call again init_auto_alias() so we get 'rm -i' and other modified
42 # Call again init_auto_alias() so we get 'rm -i' and other modified
43 # aliases since %rehash will probably clobber them
43 # aliases since %rehash will probably clobber them
44 self.shell.init_auto_alias()
44 self.shell.init_auto_alias()
45
45
46 ip.expose_magic("rehash", magic_rehash)
46 ip.expose_magic("rehash", magic_rehash)
47
47
48 # Exit
48 # Exit
49 def magic_Quit(self, parameter_s=''):
49 def magic_Quit(self, parameter_s=''):
50 """Exit IPython without confirmation (like %Exit)."""
50 """Exit IPython without confirmation (like %Exit)."""
51
51
52 self.shell.ask_exit()
52 self.shell.ask_exit()
53
53
54 ip.expose_magic("Quit", magic_Quit)
54 ip.expose_magic("Quit", magic_Quit)
55
55
56
56
57 # make it autocallable fn if you really need it
57 # make it autocallable fn if you really need it
58 def magic_p(self, parameter_s=''):
58 def magic_p(self, parameter_s=''):
59 """Just a short alias for Python's 'print'."""
59 """Just a short alias for Python's 'print'."""
60 exec 'print ' + parameter_s in self.shell.user_ns
60 exec 'print ' + parameter_s in self.shell.user_ns
61
61
62 ip.expose_magic("p", magic_p)
62 ip.expose_magic("p", magic_p)
@@ -1,132 +1,132 b''
1 """ Use pretty.py for configurable pretty-printing.
1 """ Use pretty.py for configurable pretty-printing.
2
2
3 Register pretty-printers for types using ipy_pretty.for_type() or
3 Register pretty-printers for types using ipy_pretty.for_type() or
4 ipy_pretty.for_type_by_name(). For example, to use the example pretty-printer
4 ipy_pretty.for_type_by_name(). For example, to use the example pretty-printer
5 for numpy dtype objects, add the following to your ipy_user_conf.py::
5 for numpy dtype objects, add the following to your ipy_user_conf.py::
6
6
7 from IPython.Extensions import ipy_pretty
7 from IPython.Extensions import ipy_pretty
8
8
9 ipy_pretty.activate()
9 ipy_pretty.activate()
10
10
11 # If you want to have numpy always imported anyways:
11 # If you want to have numpy always imported anyways:
12 import numpy
12 import numpy
13 ipy_pretty.for_type(numpy.dtype, ipy_pretty.dtype_pprinter)
13 ipy_pretty.for_type(numpy.dtype, ipy_pretty.dtype_pprinter)
14
14
15 # If you don't want to have numpy imported until it needs to be:
15 # If you don't want to have numpy imported until it needs to be:
16 ipy_pretty.for_type_by_name('numpy', 'dtype', ipy_pretty.dtype_pprinter)
16 ipy_pretty.for_type_by_name('numpy', 'dtype', ipy_pretty.dtype_pprinter)
17 """
17 """
18
18
19 import IPython.ipapi
19 import IPython.ipapi
20 from IPython.genutils import Term
20 from IPython.utils.genutils import Term
21
21
22 from IPython.external import pretty
22 from IPython.external import pretty
23
23
24 ip = IPython.ipapi.get()
24 ip = IPython.ipapi.get()
25
25
26
26
27 #### Implementation ############################################################
27 #### Implementation ############################################################
28
28
29 def pretty_result_display(self, arg):
29 def pretty_result_display(self, arg):
30 """ Uber-pretty-printing display hook.
30 """ Uber-pretty-printing display hook.
31
31
32 Called for displaying the result to the user.
32 Called for displaying the result to the user.
33 """
33 """
34
34
35 if ip.options.pprint:
35 if ip.options.pprint:
36 verbose = getattr(ip.options, 'pretty_verbose', False)
36 verbose = getattr(ip.options, 'pretty_verbose', False)
37 out = pretty.pretty(arg, verbose=verbose)
37 out = pretty.pretty(arg, verbose=verbose)
38 if '\n' in out:
38 if '\n' in out:
39 # So that multi-line strings line up with the left column of
39 # So that multi-line strings line up with the left column of
40 # the screen, instead of having the output prompt mess up
40 # the screen, instead of having the output prompt mess up
41 # their first line.
41 # their first line.
42 Term.cout.write('\n')
42 Term.cout.write('\n')
43 print >>Term.cout, out
43 print >>Term.cout, out
44 else:
44 else:
45 raise TryNext
45 raise TryNext
46
46
47
47
48 #### API #######################################################################
48 #### API #######################################################################
49
49
50 # Expose the for_type and for_type_by_name functions for easier use.
50 # Expose the for_type and for_type_by_name functions for easier use.
51 for_type = pretty.for_type
51 for_type = pretty.for_type
52 for_type_by_name = pretty.for_type_by_name
52 for_type_by_name = pretty.for_type_by_name
53
53
54
54
55 # FIXME: write deactivate(). We need a way to remove a hook.
55 # FIXME: write deactivate(). We need a way to remove a hook.
56 def activate():
56 def activate():
57 """ Activate this extension.
57 """ Activate this extension.
58 """
58 """
59 ip.set_hook('result_display', pretty_result_display, priority=99)
59 ip.set_hook('result_display', pretty_result_display, priority=99)
60
60
61
61
62 #### Example pretty-printers ###################################################
62 #### Example pretty-printers ###################################################
63
63
64 def dtype_pprinter(obj, p, cycle):
64 def dtype_pprinter(obj, p, cycle):
65 """ A pretty-printer for numpy dtype objects.
65 """ A pretty-printer for numpy dtype objects.
66 """
66 """
67 if cycle:
67 if cycle:
68 return p.text('dtype(...)')
68 return p.text('dtype(...)')
69 if obj.fields is None:
69 if obj.fields is None:
70 p.text(repr(obj))
70 p.text(repr(obj))
71 else:
71 else:
72 p.begin_group(7, 'dtype([')
72 p.begin_group(7, 'dtype([')
73 for i, field in enumerate(obj.descr):
73 for i, field in enumerate(obj.descr):
74 if i > 0:
74 if i > 0:
75 p.text(',')
75 p.text(',')
76 p.breakable()
76 p.breakable()
77 p.pretty(field)
77 p.pretty(field)
78 p.end_group(7, '])')
78 p.end_group(7, '])')
79
79
80
80
81 #### Tests #####################################################################
81 #### Tests #####################################################################
82
82
83 def test_pretty():
83 def test_pretty():
84 """
84 """
85 In [1]: from IPython.Extensions import ipy_pretty
85 In [1]: from IPython.Extensions import ipy_pretty
86
86
87 In [2]: ipy_pretty.activate()
87 In [2]: ipy_pretty.activate()
88
88
89 In [3]: class A(object):
89 In [3]: class A(object):
90 ...: def __repr__(self):
90 ...: def __repr__(self):
91 ...: return 'A()'
91 ...: return 'A()'
92 ...:
92 ...:
93 ...:
93 ...:
94
94
95 In [4]: a = A()
95 In [4]: a = A()
96
96
97 In [5]: a
97 In [5]: a
98 Out[5]: A()
98 Out[5]: A()
99
99
100 In [6]: def a_pretty_printer(obj, p, cycle):
100 In [6]: def a_pretty_printer(obj, p, cycle):
101 ...: p.text('<A>')
101 ...: p.text('<A>')
102 ...:
102 ...:
103 ...:
103 ...:
104
104
105 In [7]: ipy_pretty.for_type(A, a_pretty_printer)
105 In [7]: ipy_pretty.for_type(A, a_pretty_printer)
106
106
107 In [8]: a
107 In [8]: a
108 Out[8]: <A>
108 Out[8]: <A>
109
109
110 In [9]: class B(object):
110 In [9]: class B(object):
111 ...: def __repr__(self):
111 ...: def __repr__(self):
112 ...: return 'B()'
112 ...: return 'B()'
113 ...:
113 ...:
114 ...:
114 ...:
115
115
116 In [10]: B.__module__, B.__name__
116 In [10]: B.__module__, B.__name__
117 Out[10]: ('__main__', 'B')
117 Out[10]: ('__main__', 'B')
118
118
119 In [11]: def b_pretty_printer(obj, p, cycle):
119 In [11]: def b_pretty_printer(obj, p, cycle):
120 ....: p.text('<B>')
120 ....: p.text('<B>')
121 ....:
121 ....:
122 ....:
122 ....:
123
123
124 In [12]: ipy_pretty.for_type_by_name('__main__', 'B', b_pretty_printer)
124 In [12]: ipy_pretty.for_type_by_name('__main__', 'B', b_pretty_printer)
125
125
126 In [13]: b = B()
126 In [13]: b = B()
127
127
128 In [14]: b
128 In [14]: b
129 Out[14]: <B>
129 Out[14]: <B>
130 """
130 """
131 assert False, "This should only be doctested, not run."
131 assert False, "This should only be doctested, not run."
132
132
@@ -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 import ipapi
10 from IPython 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 import IPython.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(" + IPython.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.Itpl import ItplNS
177 from IPython.genutils import shell
177 from IPython.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,31 +1,31 b''
1 import inspect
1 import inspect
2 import IPython.ipapi
2 import IPython.ipapi
3 from IPython.genutils import arg_split
3 from IPython.utils.genutils import arg_split
4 ip = IPython.ipapi.get()
4 ip = IPython.ipapi.get()
5
5
6 from IPython.core import debugger
6 from IPython.core import debugger
7
7
8 def call_pydb(self, args):
8 def call_pydb(self, args):
9 """Invoke pydb with the supplied parameters."""
9 """Invoke pydb with the supplied parameters."""
10 try:
10 try:
11 import pydb
11 import pydb
12 except ImportError:
12 except ImportError:
13 raise ImportError("pydb doesn't seem to be installed.")
13 raise ImportError("pydb doesn't seem to be installed.")
14
14
15 if not hasattr(pydb.pydb, "runv"):
15 if not hasattr(pydb.pydb, "runv"):
16 raise ImportError("You need pydb version 1.19 or later installed.")
16 raise ImportError("You need pydb version 1.19 or later installed.")
17
17
18 argl = arg_split(args)
18 argl = arg_split(args)
19 # print argl # dbg
19 # print argl # dbg
20 if len(inspect.getargspec(pydb.runv)[0]) == 2:
20 if len(inspect.getargspec(pydb.runv)[0]) == 2:
21 pdb = debugger.Pdb(color_scheme=self.rc.colors)
21 pdb = debugger.Pdb(color_scheme=self.rc.colors)
22 ip.IP.history_saving_wrapper( lambda : pydb.runv(argl, pdb) )()
22 ip.IP.history_saving_wrapper( lambda : pydb.runv(argl, pdb) )()
23 else:
23 else:
24 ip.IP.history_saving_wrapper( lambda : pydb.runv(argl) )()
24 ip.IP.history_saving_wrapper( lambda : pydb.runv(argl) )()
25
25
26
26
27 ip.expose_magic("pydb",call_pydb)
27 ip.expose_magic("pydb",call_pydb)
28
28
29
29
30
30
31
31
@@ -1,184 +1,184 b''
1 """Traits-aware tab completion.
1 """Traits-aware tab completion.
2
2
3 This module provides a custom tab-completer that intelligently hides the names
3 This module provides a custom tab-completer that intelligently hides the names
4 that the enthought.traits library (http://code.enthought.com/traits)
4 that the enthought.traits library (http://code.enthought.com/traits)
5 automatically adds to all objects that inherit from its base HasTraits class.
5 automatically adds to all objects that inherit from its base HasTraits class.
6
6
7
7
8 Activation
8 Activation
9 ==========
9 ==========
10
10
11 To use this, put in your ~/.ipython/ipy_user_conf.py file:
11 To use this, put in your ~/.ipython/ipy_user_conf.py file:
12
12
13 from ipy_traits_completer import activate
13 from ipy_traits_completer import activate
14 activate([complete_threshold])
14 activate([complete_threshold])
15
15
16 The optional complete_threshold argument is the minimal length of text you need
16 The optional complete_threshold argument is the minimal length of text you need
17 to type for tab-completion to list names that are automatically generated by
17 to type for tab-completion to list names that are automatically generated by
18 traits. The default value is 3. Note that at runtime, you can change this
18 traits. The default value is 3. Note that at runtime, you can change this
19 value simply by doing:
19 value simply by doing:
20
20
21 import ipy_traits_completer
21 import ipy_traits_completer
22 ipy_traits_completer.COMPLETE_THRESHOLD = 4
22 ipy_traits_completer.COMPLETE_THRESHOLD = 4
23
23
24
24
25 Usage
25 Usage
26 =====
26 =====
27
27
28 The system works as follows. If t is an empty object that HasTraits, then
28 The system works as follows. If t is an empty object that HasTraits, then
29 (assuming the threshold is at the default value of 3):
29 (assuming the threshold is at the default value of 3):
30
30
31 In [7]: t.ed<TAB>
31 In [7]: t.ed<TAB>
32
32
33 doesn't show anything at all, but:
33 doesn't show anything at all, but:
34
34
35 In [7]: t.edi<TAB>
35 In [7]: t.edi<TAB>
36 t.edit_traits t.editable_traits
36 t.edit_traits t.editable_traits
37
37
38 shows these two names that come from traits. This allows you to complete on
38 shows these two names that come from traits. This allows you to complete on
39 the traits-specific names by typing at least 3 letters from them (or whatever
39 the traits-specific names by typing at least 3 letters from them (or whatever
40 you set your threshold to), but to otherwise not see them in normal completion.
40 you set your threshold to), but to otherwise not see them in normal completion.
41
41
42
42
43 Notes
43 Notes
44 =====
44 =====
45
45
46 - This requires Python 2.4 to work (I use sets). I don't think anyone is
46 - This requires Python 2.4 to work (I use sets). I don't think anyone is
47 using traits with 2.3 anyway, so that's OK.
47 using traits with 2.3 anyway, so that's OK.
48 """
48 """
49
49
50 #############################################################################
50 #############################################################################
51 # External imports
51 # External imports
52 from enthought.traits import api as T
52 from enthought.traits import api as T
53
53
54 # IPython imports
54 # IPython imports
55 from IPython.ipapi import TryNext, get as ipget
55 from IPython.ipapi import TryNext, get as ipget
56 from IPython.genutils import dir2
56 from IPython.utils.genutils import dir2
57 try:
57 try:
58 set
58 set
59 except:
59 except:
60 from sets import Set as set
60 from sets import Set as set
61
61
62 #############################################################################
62 #############################################################################
63 # Module constants
63 # Module constants
64
64
65 # The completion threshold
65 # The completion threshold
66 # This is currently implemented as a module global, since this sytem isn't
66 # This is currently implemented as a module global, since this sytem isn't
67 # likely to be modified at runtime by multiple instances. If needed in the
67 # likely to be modified at runtime by multiple instances. If needed in the
68 # future, we can always make it local to the completer as a function attribute.
68 # future, we can always make it local to the completer as a function attribute.
69 COMPLETE_THRESHOLD = 3
69 COMPLETE_THRESHOLD = 3
70
70
71 # Set of names that Traits automatically adds to ANY traits-inheriting object.
71 # Set of names that Traits automatically adds to ANY traits-inheriting object.
72 # These are the names we'll filter out.
72 # These are the names we'll filter out.
73 TRAIT_NAMES = set( dir2(T.HasTraits()) ) - set( dir2(object()) )
73 TRAIT_NAMES = set( dir2(T.HasTraits()) ) - set( dir2(object()) )
74
74
75 #############################################################################
75 #############################################################################
76 # Code begins
76 # Code begins
77
77
78 def trait_completer(self,event):
78 def trait_completer(self,event):
79 """A custom IPython tab-completer that is traits-aware.
79 """A custom IPython tab-completer that is traits-aware.
80
80
81 It tries to hide the internal traits attributes, and reveal them only when
81 It tries to hide the internal traits attributes, and reveal them only when
82 it can reasonably guess that the user really is after one of them.
82 it can reasonably guess that the user really is after one of them.
83 """
83 """
84
84
85 #print '\nevent is:',event # dbg
85 #print '\nevent is:',event # dbg
86 symbol_parts = event.symbol.split('.')
86 symbol_parts = event.symbol.split('.')
87 base = '.'.join(symbol_parts[:-1])
87 base = '.'.join(symbol_parts[:-1])
88 #print 'base:',base # dbg
88 #print 'base:',base # dbg
89
89
90 oinfo = self._ofind(base)
90 oinfo = self._ofind(base)
91 if not oinfo['found']:
91 if not oinfo['found']:
92 raise TryNext
92 raise TryNext
93
93
94 obj = oinfo['obj']
94 obj = oinfo['obj']
95 # OK, we got the object. See if it's traits, else punt
95 # OK, we got the object. See if it's traits, else punt
96 if not isinstance(obj,T.HasTraits):
96 if not isinstance(obj,T.HasTraits):
97 raise TryNext
97 raise TryNext
98
98
99 # it's a traits object, don't show the tr* attributes unless the completion
99 # it's a traits object, don't show the tr* attributes unless the completion
100 # begins with 'tr'
100 # begins with 'tr'
101 attrs = dir2(obj)
101 attrs = dir2(obj)
102 # Now, filter out the attributes that start with the user's request
102 # Now, filter out the attributes that start with the user's request
103 attr_start = symbol_parts[-1]
103 attr_start = symbol_parts[-1]
104 if attr_start:
104 if attr_start:
105 attrs = [a for a in attrs if a.startswith(attr_start)]
105 attrs = [a for a in attrs if a.startswith(attr_start)]
106
106
107 # Let's also respect the user's readline_omit__names setting:
107 # Let's also respect the user's readline_omit__names setting:
108 omit__names = ipget().options.readline_omit__names
108 omit__names = ipget().options.readline_omit__names
109 if omit__names == 1:
109 if omit__names == 1:
110 attrs = [a for a in attrs if not a.startswith('__')]
110 attrs = [a for a in attrs if not a.startswith('__')]
111 elif omit__names == 2:
111 elif omit__names == 2:
112 attrs = [a for a in attrs if not a.startswith('_')]
112 attrs = [a for a in attrs if not a.startswith('_')]
113
113
114 #print '\nastart:<%r>' % attr_start # dbg
114 #print '\nastart:<%r>' % attr_start # dbg
115
115
116 if len(attr_start)<COMPLETE_THRESHOLD:
116 if len(attr_start)<COMPLETE_THRESHOLD:
117 attrs = list(set(attrs) - TRAIT_NAMES)
117 attrs = list(set(attrs) - TRAIT_NAMES)
118
118
119 # The base of the completion, so we can form the final results list
119 # The base of the completion, so we can form the final results list
120 bdot = base+'.'
120 bdot = base+'.'
121
121
122 tcomp = [bdot+a for a in attrs]
122 tcomp = [bdot+a for a in attrs]
123 #print 'tcomp:',tcomp
123 #print 'tcomp:',tcomp
124 return tcomp
124 return tcomp
125
125
126 def activate(complete_threshold = COMPLETE_THRESHOLD):
126 def activate(complete_threshold = COMPLETE_THRESHOLD):
127 """Activate the Traits completer.
127 """Activate the Traits completer.
128
128
129 :Keywords:
129 :Keywords:
130 complete_threshold : int
130 complete_threshold : int
131 The minimum number of letters that a user must type in order to
131 The minimum number of letters that a user must type in order to
132 activate completion of traits-private names."""
132 activate completion of traits-private names."""
133
133
134 if not (isinstance(complete_threshold,int) and
134 if not (isinstance(complete_threshold,int) and
135 complete_threshold>0):
135 complete_threshold>0):
136 e='complete_threshold must be a positive integer, not %r' % \
136 e='complete_threshold must be a positive integer, not %r' % \
137 complete_threshold
137 complete_threshold
138 raise ValueError(e)
138 raise ValueError(e)
139
139
140 # Set the module global
140 # Set the module global
141 global COMPLETE_THRESHOLD
141 global COMPLETE_THRESHOLD
142 COMPLETE_THRESHOLD = complete_threshold
142 COMPLETE_THRESHOLD = complete_threshold
143
143
144 # Activate the traits aware completer
144 # Activate the traits aware completer
145 ip = ipget()
145 ip = ipget()
146 ip.set_hook('complete_command', trait_completer, re_key = '.*')
146 ip.set_hook('complete_command', trait_completer, re_key = '.*')
147
147
148
148
149 #############################################################################
149 #############################################################################
150 if __name__ == '__main__':
150 if __name__ == '__main__':
151 # Testing/debugging
151 # Testing/debugging
152
152
153 # A sorted list of the names we'll filter out
153 # A sorted list of the names we'll filter out
154 TNL = list(TRAIT_NAMES)
154 TNL = list(TRAIT_NAMES)
155 TNL.sort()
155 TNL.sort()
156
156
157 # Make a few objects for testing
157 # Make a few objects for testing
158 class TClean(T.HasTraits): pass
158 class TClean(T.HasTraits): pass
159 class Bunch(object): pass
159 class Bunch(object): pass
160 # A clean traits object
160 # A clean traits object
161 t = TClean()
161 t = TClean()
162 # A nested object containing t
162 # A nested object containing t
163 f = Bunch()
163 f = Bunch()
164 f.t = t
164 f.t = t
165 # And a naked new-style object
165 # And a naked new-style object
166 o = object()
166 o = object()
167
167
168 ip = ipget().IP
168 ip = ipget().IP
169
169
170 # A few simplistic tests
170 # A few simplistic tests
171
171
172 # Reset the threshold to the default, in case the test is running inside an
172 # Reset the threshold to the default, in case the test is running inside an
173 # instance of ipython that changed it
173 # instance of ipython that changed it
174 import ipy_traits_completer
174 import ipy_traits_completer
175 ipy_traits_completer.COMPLETE_THRESHOLD = 3
175 ipy_traits_completer.COMPLETE_THRESHOLD = 3
176
176
177 assert ip.complete('t.ed') ==[]
177 assert ip.complete('t.ed') ==[]
178
178
179 # For some bizarre reason, these fail on the first time I run them, but not
179 # For some bizarre reason, these fail on the first time I run them, but not
180 # afterwards. Traits does some really weird stuff at object instantiation
180 # afterwards. Traits does some really weird stuff at object instantiation
181 # time...
181 # time...
182 ta = ip.complete('t.edi')
182 ta = ip.complete('t.edi')
183 assert ta == ['t.edit_traits', 't.editable_traits']
183 assert ta == ['t.edit_traits', 't.editable_traits']
184 print 'Tests OK'
184 print 'Tests OK'
@@ -1,242 +1,242 b''
1 """ Preliminary "job control" extensions for IPython
1 """ Preliminary "job control" extensions for IPython
2
2
3 requires python 2.4 (or separate 'subprocess' module
3 requires python 2.4 (or separate 'subprocess' module
4
4
5 This provides 2 features, launching background jobs and killing foreground jobs from another IPython instance.
5 This provides 2 features, launching background jobs and killing foreground jobs from another IPython instance.
6
6
7 Launching background jobs:
7 Launching background jobs:
8
8
9 Usage:
9 Usage:
10
10
11 [ipython]|2> import jobctrl
11 [ipython]|2> import jobctrl
12 [ipython]|3> &ls
12 [ipython]|3> &ls
13 <3> <jobctrl.IpyPopen object at 0x00D87FD0>
13 <3> <jobctrl.IpyPopen object at 0x00D87FD0>
14 [ipython]|4> _3.go
14 [ipython]|4> _3.go
15 -----------> _3.go()
15 -----------> _3.go()
16 ChangeLog
16 ChangeLog
17 IPython
17 IPython
18 MANIFEST.in
18 MANIFEST.in
19 README
19 README
20 README_Windows.txt
20 README_Windows.txt
21
21
22 ...
22 ...
23
23
24 Killing foreground tasks:
24 Killing foreground tasks:
25
25
26 Launch IPython instance, run a blocking command:
26 Launch IPython instance, run a blocking command:
27
27
28 [Q:/ipython]|1> import jobctrl
28 [Q:/ipython]|1> import jobctrl
29 [Q:/ipython]|2> cat
29 [Q:/ipython]|2> cat
30
30
31 Now launch a new IPython prompt and kill the process:
31 Now launch a new IPython prompt and kill the process:
32
32
33 IPython 0.8.3.svn.r2919 [on Py 2.5]
33 IPython 0.8.3.svn.r2919 [on Py 2.5]
34 [Q:/ipython]|1> import jobctrl
34 [Q:/ipython]|1> import jobctrl
35 [Q:/ipython]|2> %tasks
35 [Q:/ipython]|2> %tasks
36 6020: 'cat ' (Q:\ipython)
36 6020: 'cat ' (Q:\ipython)
37 [Q:/ipython]|3> %kill
37 [Q:/ipython]|3> %kill
38 SUCCESS: The process with PID 6020 has been terminated.
38 SUCCESS: The process with PID 6020 has been terminated.
39 [Q:/ipython]|4>
39 [Q:/ipython]|4>
40
40
41 (you don't need to specify PID for %kill if only one task is running)
41 (you don't need to specify PID for %kill if only one task is running)
42 """
42 """
43
43
44 from subprocess import *
44 from subprocess import *
45 import os,shlex,sys,time
45 import os,shlex,sys,time
46 import threading,Queue
46 import threading,Queue
47
47
48 from IPython import genutils
48 from IPython.utils import genutils
49
49
50 import IPython.ipapi
50 import IPython.ipapi
51
51
52 if os.name == 'nt':
52 if os.name == 'nt':
53 def kill_process(pid):
53 def kill_process(pid):
54 os.system('taskkill /F /PID %d' % pid)
54 os.system('taskkill /F /PID %d' % pid)
55 else:
55 else:
56 def kill_process(pid):
56 def kill_process(pid):
57 os.system('kill -9 %d' % pid)
57 os.system('kill -9 %d' % pid)
58
58
59
59
60
60
61 class IpyPopen(Popen):
61 class IpyPopen(Popen):
62 def go(self):
62 def go(self):
63 print self.communicate()[0]
63 print self.communicate()[0]
64 def __repr__(self):
64 def __repr__(self):
65 return '<IPython job "%s" PID=%d>' % (self.line, self.pid)
65 return '<IPython job "%s" PID=%d>' % (self.line, self.pid)
66
66
67 def kill(self):
67 def kill(self):
68 kill_process(self.pid)
68 kill_process(self.pid)
69
69
70 def startjob(job):
70 def startjob(job):
71 p = IpyPopen(shlex.split(job), stdout=PIPE, shell = False)
71 p = IpyPopen(shlex.split(job), stdout=PIPE, shell = False)
72 p.line = job
72 p.line = job
73 return p
73 return p
74
74
75 class AsyncJobQ(threading.Thread):
75 class AsyncJobQ(threading.Thread):
76 def __init__(self):
76 def __init__(self):
77 threading.Thread.__init__(self)
77 threading.Thread.__init__(self)
78 self.q = Queue.Queue()
78 self.q = Queue.Queue()
79 self.output = []
79 self.output = []
80 self.stop = False
80 self.stop = False
81 def run(self):
81 def run(self):
82 while 1:
82 while 1:
83 cmd,cwd = self.q.get()
83 cmd,cwd = self.q.get()
84 if self.stop:
84 if self.stop:
85 self.output.append("** Discarding: '%s' - %s" % (cmd,cwd))
85 self.output.append("** Discarding: '%s' - %s" % (cmd,cwd))
86 continue
86 continue
87 self.output.append("** Task started: '%s' - %s" % (cmd,cwd))
87 self.output.append("** Task started: '%s' - %s" % (cmd,cwd))
88
88
89 p = Popen(cmd, shell=True, stdout=PIPE, stderr=STDOUT, cwd = cwd)
89 p = Popen(cmd, shell=True, stdout=PIPE, stderr=STDOUT, cwd = cwd)
90 out = p.stdout.read()
90 out = p.stdout.read()
91 self.output.append("** Task complete: '%s'\n" % cmd)
91 self.output.append("** Task complete: '%s'\n" % cmd)
92 self.output.append(out)
92 self.output.append(out)
93
93
94 def add(self,cmd):
94 def add(self,cmd):
95 self.q.put_nowait((cmd, os.getcwd()))
95 self.q.put_nowait((cmd, os.getcwd()))
96
96
97 def dumpoutput(self):
97 def dumpoutput(self):
98 while self.output:
98 while self.output:
99 item = self.output.pop(0)
99 item = self.output.pop(0)
100 print item
100 print item
101
101
102 _jobq = None
102 _jobq = None
103
103
104 def jobqueue_f(self, line):
104 def jobqueue_f(self, line):
105
105
106 global _jobq
106 global _jobq
107 if not _jobq:
107 if not _jobq:
108 print "Starting jobqueue - do '&some_long_lasting_system_command' to enqueue"
108 print "Starting jobqueue - do '&some_long_lasting_system_command' to enqueue"
109 _jobq = AsyncJobQ()
109 _jobq = AsyncJobQ()
110 _jobq.setDaemon(True)
110 _jobq.setDaemon(True)
111 _jobq.start()
111 _jobq.start()
112 ip.jobq = _jobq.add
112 ip.jobq = _jobq.add
113 return
113 return
114 if line.strip() == 'stop':
114 if line.strip() == 'stop':
115 print "Stopping and clearing jobqueue, %jobqueue start to start again"
115 print "Stopping and clearing jobqueue, %jobqueue start to start again"
116 _jobq.stop = True
116 _jobq.stop = True
117 return
117 return
118 if line.strip() == 'start':
118 if line.strip() == 'start':
119 _jobq.stop = False
119 _jobq.stop = False
120 return
120 return
121
121
122 def jobctrl_prefilter_f(self,line):
122 def jobctrl_prefilter_f(self,line):
123 if line.startswith('&'):
123 if line.startswith('&'):
124 pre,fn,rest = self.split_user_input(line[1:])
124 pre,fn,rest = self.split_user_input(line[1:])
125
125
126 line = ip.IP.expand_aliases(fn,rest)
126 line = ip.IP.expand_aliases(fn,rest)
127 if not _jobq:
127 if not _jobq:
128 return '_ip.startjob(%s)' % genutils.make_quoted_expr(line)
128 return '_ip.startjob(%s)' % genutils.make_quoted_expr(line)
129 return '_ip.jobq(%s)' % genutils.make_quoted_expr(line)
129 return '_ip.jobq(%s)' % genutils.make_quoted_expr(line)
130
130
131 raise IPython.ipapi.TryNext
131 raise IPython.ipapi.TryNext
132
132
133 def jobq_output_hook(self):
133 def jobq_output_hook(self):
134 if not _jobq:
134 if not _jobq:
135 return
135 return
136 _jobq.dumpoutput()
136 _jobq.dumpoutput()
137
137
138
138
139
139
140 def job_list(ip):
140 def job_list(ip):
141 keys = ip.db.keys('tasks/*')
141 keys = ip.db.keys('tasks/*')
142 ents = [ip.db[k] for k in keys]
142 ents = [ip.db[k] for k in keys]
143 return ents
143 return ents
144
144
145 def magic_tasks(self,line):
145 def magic_tasks(self,line):
146 """ Show a list of tasks.
146 """ Show a list of tasks.
147
147
148 A 'task' is a process that has been started in IPython when 'jobctrl' extension is enabled.
148 A 'task' is a process that has been started in IPython when 'jobctrl' extension is enabled.
149 Tasks can be killed with %kill.
149 Tasks can be killed with %kill.
150
150
151 '%tasks clear' clears the task list (from stale tasks)
151 '%tasks clear' clears the task list (from stale tasks)
152 """
152 """
153 ip = self.getapi()
153 ip = self.getapi()
154 if line.strip() == 'clear':
154 if line.strip() == 'clear':
155 for k in ip.db.keys('tasks/*'):
155 for k in ip.db.keys('tasks/*'):
156 print "Clearing",ip.db[k]
156 print "Clearing",ip.db[k]
157 del ip.db[k]
157 del ip.db[k]
158 return
158 return
159
159
160 ents = job_list(ip)
160 ents = job_list(ip)
161 if not ents:
161 if not ents:
162 print "No tasks running"
162 print "No tasks running"
163 for pid,cmd,cwd,t in ents:
163 for pid,cmd,cwd,t in ents:
164 dur = int(time.time()-t)
164 dur = int(time.time()-t)
165 print "%d: '%s' (%s) %d:%02d" % (pid,cmd,cwd, dur / 60,dur%60)
165 print "%d: '%s' (%s) %d:%02d" % (pid,cmd,cwd, dur / 60,dur%60)
166
166
167 def magic_kill(self,line):
167 def magic_kill(self,line):
168 """ Kill a task
168 """ Kill a task
169
169
170 Without args, either kill one task (if only one running) or show list (if many)
170 Without args, either kill one task (if only one running) or show list (if many)
171 With arg, assume it's the process id.
171 With arg, assume it's the process id.
172
172
173 %kill is typically (much) more powerful than trying to terminate a process with ctrl+C.
173 %kill is typically (much) more powerful than trying to terminate a process with ctrl+C.
174 """
174 """
175 ip = self.getapi()
175 ip = self.getapi()
176 jobs = job_list(ip)
176 jobs = job_list(ip)
177
177
178 if not line.strip():
178 if not line.strip():
179 if len(jobs) == 1:
179 if len(jobs) == 1:
180 kill_process(jobs[0][0])
180 kill_process(jobs[0][0])
181 else:
181 else:
182 magic_tasks(self,line)
182 magic_tasks(self,line)
183 return
183 return
184
184
185 try:
185 try:
186 pid = int(line)
186 pid = int(line)
187 kill_process(pid)
187 kill_process(pid)
188 except ValueError:
188 except ValueError:
189 magic_tasks(self,line)
189 magic_tasks(self,line)
190
190
191 if sys.platform == 'win32':
191 if sys.platform == 'win32':
192 shell_internal_commands = 'break chcp cls copy ctty date del erase dir md mkdir path prompt rd rmdir start time type ver vol'.split()
192 shell_internal_commands = 'break chcp cls copy ctty date del erase dir md mkdir path prompt rd rmdir start time type ver vol'.split()
193 PopenExc = WindowsError
193 PopenExc = WindowsError
194 else:
194 else:
195 # todo linux commands
195 # todo linux commands
196 shell_internal_commands = []
196 shell_internal_commands = []
197 PopenExc = OSError
197 PopenExc = OSError
198
198
199
199
200 def jobctrl_shellcmd(ip,cmd):
200 def jobctrl_shellcmd(ip,cmd):
201 """ os.system replacement that stores process info to db['tasks/t1234'] """
201 """ os.system replacement that stores process info to db['tasks/t1234'] """
202 cmd = cmd.strip()
202 cmd = cmd.strip()
203 cmdname = cmd.split(None,1)[0]
203 cmdname = cmd.split(None,1)[0]
204 if cmdname in shell_internal_commands or '|' in cmd or '>' in cmd or '<' in cmd:
204 if cmdname in shell_internal_commands or '|' in cmd or '>' in cmd or '<' in cmd:
205 use_shell = True
205 use_shell = True
206 else:
206 else:
207 use_shell = False
207 use_shell = False
208
208
209 jobentry = None
209 jobentry = None
210 try:
210 try:
211 try:
211 try:
212 p = Popen(cmd,shell = use_shell)
212 p = Popen(cmd,shell = use_shell)
213 except PopenExc :
213 except PopenExc :
214 if use_shell:
214 if use_shell:
215 # try with os.system
215 # try with os.system
216 os.system(cmd)
216 os.system(cmd)
217 return
217 return
218 else:
218 else:
219 # have to go via shell, sucks
219 # have to go via shell, sucks
220 p = Popen(cmd,shell = True)
220 p = Popen(cmd,shell = True)
221
221
222 jobentry = 'tasks/t' + str(p.pid)
222 jobentry = 'tasks/t' + str(p.pid)
223 ip.db[jobentry] = (p.pid,cmd,os.getcwd(),time.time())
223 ip.db[jobentry] = (p.pid,cmd,os.getcwd(),time.time())
224 p.communicate()
224 p.communicate()
225
225
226 finally:
226 finally:
227 if jobentry:
227 if jobentry:
228 del ip.db[jobentry]
228 del ip.db[jobentry]
229
229
230
230
231 def install():
231 def install():
232 global ip
232 global ip
233 ip = IPython.ipapi.get()
233 ip = IPython.ipapi.get()
234 # needed to make startjob visible as _ip.startjob('blah')
234 # needed to make startjob visible as _ip.startjob('blah')
235 ip.startjob = startjob
235 ip.startjob = startjob
236 ip.set_hook('input_prefilter', jobctrl_prefilter_f)
236 ip.set_hook('input_prefilter', jobctrl_prefilter_f)
237 ip.set_hook('shell_hook', jobctrl_shellcmd)
237 ip.set_hook('shell_hook', jobctrl_shellcmd)
238 ip.expose_magic('kill',magic_kill)
238 ip.expose_magic('kill',magic_kill)
239 ip.expose_magic('tasks',magic_tasks)
239 ip.expose_magic('tasks',magic_tasks)
240 ip.expose_magic('jobqueue',jobqueue_f)
240 ip.expose_magic('jobqueue',jobqueue_f)
241 ip.set_hook('pre_prompt_hook', jobq_output_hook)
241 ip.set_hook('pre_prompt_hook', jobq_output_hook)
242 install()
242 install()
@@ -1,665 +1,665 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Improved replacement for the Gnuplot.Gnuplot class.
2 """Improved replacement for the Gnuplot.Gnuplot class.
3
3
4 This module imports Gnuplot and replaces some of its functionality with
4 This module imports Gnuplot and replaces some of its functionality with
5 improved versions. They add better handling of arrays for plotting and more
5 improved versions. They add better handling of arrays for plotting and more
6 convenient PostScript generation, plus some fixes for hardcopy().
6 convenient PostScript generation, plus some fixes for hardcopy().
7
7
8 It also adds a convenient plot2 method for plotting dictionaries and
8 It also adds a convenient plot2 method for plotting dictionaries and
9 lists/tuples of arrays.
9 lists/tuples of arrays.
10
10
11 This module is meant to be used as a drop-in replacement to the original
11 This module is meant to be used as a drop-in replacement to the original
12 Gnuplot, so it should be safe to do:
12 Gnuplot, so it should be safe to do:
13
13
14 import IPython.Gnuplot2 as Gnuplot
14 import IPython.Gnuplot2 as Gnuplot
15 """
15 """
16
16
17 import cStringIO
17 import cStringIO
18 import os
18 import os
19 import string
19 import string
20 import sys
20 import sys
21 import tempfile
21 import tempfile
22 import time
22 import time
23 import types
23 import types
24
24
25 import Gnuplot as Gnuplot_ori
25 import Gnuplot as Gnuplot_ori
26 import Numeric
26 import Numeric
27
27
28 from IPython.genutils import popkey,xsys
28 from IPython.utils.genutils import popkey,xsys
29
29
30 # needed by hardcopy():
30 # needed by hardcopy():
31 gp = Gnuplot_ori.gp
31 gp = Gnuplot_ori.gp
32
32
33 # Patch for Gnuplot.py 1.6 compatibility.
33 # Patch for Gnuplot.py 1.6 compatibility.
34 # Thanks to Hayden Callow <h.callow@elec.canterbury.ac.nz>
34 # Thanks to Hayden Callow <h.callow@elec.canterbury.ac.nz>
35 try:
35 try:
36 OptionException = Gnuplot_ori.PlotItems.OptionException
36 OptionException = Gnuplot_ori.PlotItems.OptionException
37 except AttributeError:
37 except AttributeError:
38 OptionException = Gnuplot_ori.Errors.OptionError
38 OptionException = Gnuplot_ori.Errors.OptionError
39
39
40 # exhibit a similar interface to Gnuplot so it can be somewhat drop-in
40 # exhibit a similar interface to Gnuplot so it can be somewhat drop-in
41 Data = Gnuplot_ori.Data
41 Data = Gnuplot_ori.Data
42 Func = Gnuplot_ori.Func
42 Func = Gnuplot_ori.Func
43 GridData = Gnuplot_ori.GridData
43 GridData = Gnuplot_ori.GridData
44 PlotItem = Gnuplot_ori.PlotItem
44 PlotItem = Gnuplot_ori.PlotItem
45 PlotItems = Gnuplot_ori.PlotItems
45 PlotItems = Gnuplot_ori.PlotItems
46
46
47 # Modify some of Gnuplot's functions with improved versions (or bugfixed, in
47 # Modify some of Gnuplot's functions with improved versions (or bugfixed, in
48 # hardcopy's case). In order to preserve the docstrings at runtime, I've
48 # hardcopy's case). In order to preserve the docstrings at runtime, I've
49 # copied them from the original code.
49 # copied them from the original code.
50
50
51 # After some significant changes in v 1.7 of Gnuplot.py, we need to do a bit
51 # After some significant changes in v 1.7 of Gnuplot.py, we need to do a bit
52 # of version checking.
52 # of version checking.
53
53
54 if Gnuplot_ori.__version__ <= '1.6':
54 if Gnuplot_ori.__version__ <= '1.6':
55 _BaseFileItem = PlotItems.File
55 _BaseFileItem = PlotItems.File
56 _BaseTempFileItem = PlotItems.TempFile
56 _BaseTempFileItem = PlotItems.TempFile
57
57
58 # Fix the File class to add the 'index' option for Gnuplot versions < 1.7
58 # Fix the File class to add the 'index' option for Gnuplot versions < 1.7
59 class File(_BaseFileItem):
59 class File(_BaseFileItem):
60
60
61 _option_list = _BaseFileItem._option_list.copy()
61 _option_list = _BaseFileItem._option_list.copy()
62 _option_list.update({
62 _option_list.update({
63 'index' : lambda self, index: self.set_option_index(index),
63 'index' : lambda self, index: self.set_option_index(index),
64 })
64 })
65
65
66 # A new initializer is needed b/c we want to add a modified
66 # A new initializer is needed b/c we want to add a modified
67 # _option_sequence list which includes 'index' in the right place.
67 # _option_sequence list which includes 'index' in the right place.
68 def __init__(self,*args,**kw):
68 def __init__(self,*args,**kw):
69 self._option_sequence = ['binary', 'index', 'using', 'smooth', 'axes',
69 self._option_sequence = ['binary', 'index', 'using', 'smooth', 'axes',
70 'title', 'with']
70 'title', 'with']
71
71
72 _BaseFileItem.__init__(self,*args,**kw)
72 _BaseFileItem.__init__(self,*args,**kw)
73
73
74 # Let's fix the constructor docstring
74 # Let's fix the constructor docstring
75 __newdoc = \
75 __newdoc = \
76 """Additional Keyword arguments added by IPython:
76 """Additional Keyword arguments added by IPython:
77
77
78 'index=<int>' -- similar to the `index` keyword in Gnuplot.
78 'index=<int>' -- similar to the `index` keyword in Gnuplot.
79 This allows only some of the datasets in a file to be
79 This allows only some of the datasets in a file to be
80 plotted. Datasets within a file are assumed to be separated
80 plotted. Datasets within a file are assumed to be separated
81 by _pairs_ of blank lines, and the first one is numbered as
81 by _pairs_ of blank lines, and the first one is numbered as
82 0 (similar to C/Python usage)."""
82 0 (similar to C/Python usage)."""
83 __init__.__doc__ = PlotItems.File.__init__.__doc__ + __newdoc
83 __init__.__doc__ = PlotItems.File.__init__.__doc__ + __newdoc
84
84
85 def set_option_index(self, index):
85 def set_option_index(self, index):
86 if index is None:
86 if index is None:
87 self.clear_option('index')
87 self.clear_option('index')
88 elif type(index) in [type(''), type(1)]:
88 elif type(index) in [type(''), type(1)]:
89 self._options['index'] = (index, 'index %s' % index)
89 self._options['index'] = (index, 'index %s' % index)
90 elif type(index) is type(()):
90 elif type(index) is type(()):
91 self._options['index'] = (index,'index %s' %
91 self._options['index'] = (index,'index %s' %
92 string.join(map(repr, index), ':'))
92 string.join(map(repr, index), ':'))
93 else:
93 else:
94 raise OptionException('index=%s' % (index,))
94 raise OptionException('index=%s' % (index,))
95
95
96 # We need a FileClass with a different name from 'File', which is a
96 # We need a FileClass with a different name from 'File', which is a
97 # factory function in 1.7, so that our String class can subclass FileClass
97 # factory function in 1.7, so that our String class can subclass FileClass
98 # in any version.
98 # in any version.
99 _FileClass = File
99 _FileClass = File
100
100
101 elif Gnuplot_ori.__version__ =='1.7':
101 elif Gnuplot_ori.__version__ =='1.7':
102 _FileClass = _BaseFileItem = PlotItems._FileItem
102 _FileClass = _BaseFileItem = PlotItems._FileItem
103 _BaseTempFileItem = PlotItems._TempFileItem
103 _BaseTempFileItem = PlotItems._TempFileItem
104 File = PlotItems.File
104 File = PlotItems.File
105
105
106 else: # changes in the newer version (svn as of March'06)
106 else: # changes in the newer version (svn as of March'06)
107 _FileClass = _BaseFileItem = PlotItems._FileItem
107 _FileClass = _BaseFileItem = PlotItems._FileItem
108 _BaseTempFileItem = PlotItems._NewFileItem
108 _BaseTempFileItem = PlotItems._NewFileItem
109 File = PlotItems.File
109 File = PlotItems.File
110
110
111
111
112 # Now, we can add our generic code which is version independent
112 # Now, we can add our generic code which is version independent
113
113
114 # First some useful utilities
114 # First some useful utilities
115 def eps_fix_bbox(fname):
115 def eps_fix_bbox(fname):
116 """Fix the bounding box of an eps file by running ps2eps on it.
116 """Fix the bounding box of an eps file by running ps2eps on it.
117
117
118 If its name ends in .eps, the original file is removed.
118 If its name ends in .eps, the original file is removed.
119
119
120 This is particularly useful for plots made by Gnuplot with square aspect
120 This is particularly useful for plots made by Gnuplot with square aspect
121 ratio: there is a bug in Gnuplot which makes it generate a bounding box
121 ratio: there is a bug in Gnuplot which makes it generate a bounding box
122 which is far wider than the actual plot.
122 which is far wider than the actual plot.
123
123
124 This function assumes that ps2eps is installed in your system."""
124 This function assumes that ps2eps is installed in your system."""
125
125
126 # note: ps2ps and eps2eps do NOT work, ONLY ps2eps works correctly. The
126 # note: ps2ps and eps2eps do NOT work, ONLY ps2eps works correctly. The
127 # others make output with bitmapped fonts, which looks horrible.
127 # others make output with bitmapped fonts, which looks horrible.
128 print 'Fixing eps file: <%s>' % fname
128 print 'Fixing eps file: <%s>' % fname
129 xsys('ps2eps -f -q -l %s' % fname)
129 xsys('ps2eps -f -q -l %s' % fname)
130 if fname.endswith('.eps'):
130 if fname.endswith('.eps'):
131 os.rename(fname+'.eps',fname)
131 os.rename(fname+'.eps',fname)
132
132
133 def is_list1d(x,containers = [types.ListType,types.TupleType]):
133 def is_list1d(x,containers = [types.ListType,types.TupleType]):
134 """Returns true if x appears to be a 1d list/tuple/array.
134 """Returns true if x appears to be a 1d list/tuple/array.
135
135
136 The heuristics are: identify Numeric arrays, or lists/tuples whose first
136 The heuristics are: identify Numeric arrays, or lists/tuples whose first
137 element is not itself a list/tuple. This way zipped lists should work like
137 element is not itself a list/tuple. This way zipped lists should work like
138 the original Gnuplot. There's no inexpensive way to know if a list doesn't
138 the original Gnuplot. There's no inexpensive way to know if a list doesn't
139 have a composite object after its first element, so that kind of input
139 have a composite object after its first element, so that kind of input
140 will produce an error. But it should work well in most cases.
140 will produce an error. But it should work well in most cases.
141 """
141 """
142 x_type = type(x)
142 x_type = type(x)
143
143
144 return x_type == Numeric.ArrayType and len(x.shape)==1 or \
144 return x_type == Numeric.ArrayType and len(x.shape)==1 or \
145 (x_type in containers and
145 (x_type in containers and
146 type(x[0]) not in containers + [Numeric.ArrayType])
146 type(x[0]) not in containers + [Numeric.ArrayType])
147
147
148 def zip_items(items,titles=None):
148 def zip_items(items,titles=None):
149 """zip together neighboring 1-d arrays, and zip standalone ones
149 """zip together neighboring 1-d arrays, and zip standalone ones
150 with their index. Leave other plot items alone."""
150 with their index. Leave other plot items alone."""
151
151
152 class StandaloneItem(Exception): pass
152 class StandaloneItem(Exception): pass
153
153
154 def get_titles(titles):
154 def get_titles(titles):
155 """Return the next title and the input titles array.
155 """Return the next title and the input titles array.
156
156
157 The input array may be changed to None when no titles are left to
157 The input array may be changed to None when no titles are left to
158 prevent extra unnecessary calls to this function."""
158 prevent extra unnecessary calls to this function."""
159
159
160 try:
160 try:
161 title = titles[tit_ct[0]] # tit_ct[0] is in zip_items'scope
161 title = titles[tit_ct[0]] # tit_ct[0] is in zip_items'scope
162 except IndexError:
162 except IndexError:
163 titles = None # so we don't enter again
163 titles = None # so we don't enter again
164 title = None
164 title = None
165 else:
165 else:
166 tit_ct[0] += 1
166 tit_ct[0] += 1
167 return title,titles
167 return title,titles
168
168
169 new_items = []
169 new_items = []
170
170
171 if titles:
171 if titles:
172 # Initialize counter. It was put in a list as a hack to allow the
172 # Initialize counter. It was put in a list as a hack to allow the
173 # nested get_titles to modify it without raising a NameError.
173 # nested get_titles to modify it without raising a NameError.
174 tit_ct = [0]
174 tit_ct = [0]
175
175
176 n = 0 # this loop needs to be done by hand
176 n = 0 # this loop needs to be done by hand
177 while n < len(items):
177 while n < len(items):
178 item = items[n]
178 item = items[n]
179 try:
179 try:
180 if is_list1d(item):
180 if is_list1d(item):
181 if n==len(items)-1: # last in list
181 if n==len(items)-1: # last in list
182 raise StandaloneItem
182 raise StandaloneItem
183 else: # check the next item and zip together if needed
183 else: # check the next item and zip together if needed
184 next_item = items[n+1]
184 next_item = items[n+1]
185 if next_item is None:
185 if next_item is None:
186 n += 1
186 n += 1
187 raise StandaloneItem
187 raise StandaloneItem
188 elif is_list1d(next_item):
188 elif is_list1d(next_item):
189 # this would be best done with an iterator
189 # this would be best done with an iterator
190 if titles:
190 if titles:
191 title,titles = get_titles(titles)
191 title,titles = get_titles(titles)
192 else:
192 else:
193 title = None
193 title = None
194 new_items.append(Data(zip(item,next_item),
194 new_items.append(Data(zip(item,next_item),
195 title=title))
195 title=title))
196 n += 1 # avoid double-inclusion of next item
196 n += 1 # avoid double-inclusion of next item
197 else: # can't zip with next, zip with own index list
197 else: # can't zip with next, zip with own index list
198 raise StandaloneItem
198 raise StandaloneItem
199 else: # not 1-d array
199 else: # not 1-d array
200 new_items.append(item)
200 new_items.append(item)
201 except StandaloneItem:
201 except StandaloneItem:
202 if titles:
202 if titles:
203 title,titles = get_titles(titles)
203 title,titles = get_titles(titles)
204 else:
204 else:
205 title = None
205 title = None
206 new_items.append(Data(zip(range(len(item)),item),title=title))
206 new_items.append(Data(zip(range(len(item)),item),title=title))
207 except AttributeError:
207 except AttributeError:
208 new_items.append(item)
208 new_items.append(item)
209 n+=1
209 n+=1
210
210
211 return new_items
211 return new_items
212
212
213 # And some classes with enhanced functionality.
213 # And some classes with enhanced functionality.
214 class String(_FileClass):
214 class String(_FileClass):
215 """Make a PlotItem from data in a string with the same format as a File.
215 """Make a PlotItem from data in a string with the same format as a File.
216
216
217 This allows writing data directly inside python scripts using the exact
217 This allows writing data directly inside python scripts using the exact
218 same format and manipulation options which would be used for external
218 same format and manipulation options which would be used for external
219 files."""
219 files."""
220
220
221 def __init__(self, data_str, **keyw):
221 def __init__(self, data_str, **keyw):
222 """Construct a String object.
222 """Construct a String object.
223
223
224 <data_str> is a string formatted exactly like a valid Gnuplot data
224 <data_str> is a string formatted exactly like a valid Gnuplot data
225 file would be. All options from the File constructor are valid here.
225 file would be. All options from the File constructor are valid here.
226
226
227 Warning: when used for interactive plotting in scripts which exit
227 Warning: when used for interactive plotting in scripts which exit
228 immediately, you may get an error because the temporary file used to
228 immediately, you may get an error because the temporary file used to
229 hold the string data was deleted before Gnuplot had a chance to see
229 hold the string data was deleted before Gnuplot had a chance to see
230 it. You can work around this problem by putting a raw_input() call at
230 it. You can work around this problem by putting a raw_input() call at
231 the end of the script.
231 the end of the script.
232
232
233 This problem does not appear when generating PostScript output, only
233 This problem does not appear when generating PostScript output, only
234 with Gnuplot windows."""
234 with Gnuplot windows."""
235
235
236 self.tmpfile = _BaseTempFileItem()
236 self.tmpfile = _BaseTempFileItem()
237 tmpfile = file(self.tmpfile.filename,'w')
237 tmpfile = file(self.tmpfile.filename,'w')
238 tmpfile.write(data_str)
238 tmpfile.write(data_str)
239 _BaseFileItem.__init__(self,self.tmpfile,**keyw)
239 _BaseFileItem.__init__(self,self.tmpfile,**keyw)
240
240
241
241
242 class Gnuplot(Gnuplot_ori.Gnuplot):
242 class Gnuplot(Gnuplot_ori.Gnuplot):
243 """Improved Gnuplot class.
243 """Improved Gnuplot class.
244
244
245 Enhancements: better plot,replot and hardcopy methods. New methods for
245 Enhancements: better plot,replot and hardcopy methods. New methods for
246 quick range setting.
246 quick range setting.
247 """
247 """
248
248
249 def xrange(self,min='*',max='*'):
249 def xrange(self,min='*',max='*'):
250 """Set xrange. If min/max is omitted, it is set to '*' (auto).
250 """Set xrange. If min/max is omitted, it is set to '*' (auto).
251
251
252 Note that this is different from the regular Gnuplot behavior, where
252 Note that this is different from the regular Gnuplot behavior, where
253 an unspecified limit means no change. Here any unspecified limit is
253 an unspecified limit means no change. Here any unspecified limit is
254 set to autoscaling, allowing these functions to be used for full
254 set to autoscaling, allowing these functions to be used for full
255 autoscaling when called with no arguments.
255 autoscaling when called with no arguments.
256
256
257 To preserve one limit's current value while changing the other, an
257 To preserve one limit's current value while changing the other, an
258 explicit '' argument must be given as the limit to be kept.
258 explicit '' argument must be given as the limit to be kept.
259
259
260 Similar functions exist for [y{2}z{2}rtuv]range."""
260 Similar functions exist for [y{2}z{2}rtuv]range."""
261
261
262 self('set xrange [%s:%s]' % (min,max))
262 self('set xrange [%s:%s]' % (min,max))
263
263
264 def yrange(self,min='*',max='*'):
264 def yrange(self,min='*',max='*'):
265 self('set yrange [%s:%s]' % (min,max))
265 self('set yrange [%s:%s]' % (min,max))
266
266
267 def zrange(self,min='*',max='*'):
267 def zrange(self,min='*',max='*'):
268 self('set zrange [%s:%s]' % (min,max))
268 self('set zrange [%s:%s]' % (min,max))
269
269
270 def x2range(self,min='*',max='*'):
270 def x2range(self,min='*',max='*'):
271 self('set xrange [%s:%s]' % (min,max))
271 self('set xrange [%s:%s]' % (min,max))
272
272
273 def y2range(self,min='*',max='*'):
273 def y2range(self,min='*',max='*'):
274 self('set yrange [%s:%s]' % (min,max))
274 self('set yrange [%s:%s]' % (min,max))
275
275
276 def z2range(self,min='*',max='*'):
276 def z2range(self,min='*',max='*'):
277 self('set zrange [%s:%s]' % (min,max))
277 self('set zrange [%s:%s]' % (min,max))
278
278
279 def rrange(self,min='*',max='*'):
279 def rrange(self,min='*',max='*'):
280 self('set rrange [%s:%s]' % (min,max))
280 self('set rrange [%s:%s]' % (min,max))
281
281
282 def trange(self,min='*',max='*'):
282 def trange(self,min='*',max='*'):
283 self('set trange [%s:%s]' % (min,max))
283 self('set trange [%s:%s]' % (min,max))
284
284
285 def urange(self,min='*',max='*'):
285 def urange(self,min='*',max='*'):
286 self('set urange [%s:%s]' % (min,max))
286 self('set urange [%s:%s]' % (min,max))
287
287
288 def vrange(self,min='*',max='*'):
288 def vrange(self,min='*',max='*'):
289 self('set vrange [%s:%s]' % (min,max))
289 self('set vrange [%s:%s]' % (min,max))
290
290
291 def set_ps(self,option):
291 def set_ps(self,option):
292 """Set an option for the PostScript terminal and reset default term."""
292 """Set an option for the PostScript terminal and reset default term."""
293
293
294 self('set terminal postscript %s ' % option)
294 self('set terminal postscript %s ' % option)
295 self('set terminal %s' % gp.GnuplotOpts.default_term)
295 self('set terminal %s' % gp.GnuplotOpts.default_term)
296
296
297 def __plot_ps(self, plot_method,*items, **keyw):
297 def __plot_ps(self, plot_method,*items, **keyw):
298 """Wrapper for plot/splot/replot, with processing of hardcopy options.
298 """Wrapper for plot/splot/replot, with processing of hardcopy options.
299
299
300 For internal use only."""
300 For internal use only."""
301
301
302 # Filter out PostScript options which will crash the normal plot/replot
302 # Filter out PostScript options which will crash the normal plot/replot
303 psargs = {'filename':None,
303 psargs = {'filename':None,
304 'mode':None,
304 'mode':None,
305 'eps':None,
305 'eps':None,
306 'enhanced':None,
306 'enhanced':None,
307 'color':None,
307 'color':None,
308 'solid':None,
308 'solid':None,
309 'duplexing':None,
309 'duplexing':None,
310 'fontname':None,
310 'fontname':None,
311 'fontsize':None,
311 'fontsize':None,
312 'debug':0 }
312 'debug':0 }
313
313
314 for k in psargs.keys():
314 for k in psargs.keys():
315 if keyw.has_key(k):
315 if keyw.has_key(k):
316 psargs[k] = keyw[k]
316 psargs[k] = keyw[k]
317 del keyw[k]
317 del keyw[k]
318
318
319 # Filter out other options the original plot doesn't know
319 # Filter out other options the original plot doesn't know
320 hardcopy = popkey(keyw,'hardcopy',psargs['filename'] is not None)
320 hardcopy = popkey(keyw,'hardcopy',psargs['filename'] is not None)
321 titles = popkey(keyw,'titles',0)
321 titles = popkey(keyw,'titles',0)
322
322
323 # the filename keyword should control hardcopy generation, this is an
323 # the filename keyword should control hardcopy generation, this is an
324 # override switch only which needs to be explicitly set to zero
324 # override switch only which needs to be explicitly set to zero
325 if hardcopy:
325 if hardcopy:
326 if psargs['filename'] is None:
326 if psargs['filename'] is None:
327 raise ValueError, \
327 raise ValueError, \
328 'If you request hardcopy, you must give a filename.'
328 'If you request hardcopy, you must give a filename.'
329
329
330 # set null output so nothing goes to screen. hardcopy() restores output
330 # set null output so nothing goes to screen. hardcopy() restores output
331 self('set term dumb')
331 self('set term dumb')
332 # I don't know how to prevent screen output in Windows
332 # I don't know how to prevent screen output in Windows
333 if os.name == 'posix':
333 if os.name == 'posix':
334 self('set output "/dev/null"')
334 self('set output "/dev/null"')
335
335
336 new_items = zip_items(items,titles)
336 new_items = zip_items(items,titles)
337 # plot_method is either plot or replot from the original Gnuplot class:
337 # plot_method is either plot or replot from the original Gnuplot class:
338 plot_method(self,*new_items,**keyw)
338 plot_method(self,*new_items,**keyw)
339
339
340 # Do hardcopy if requested
340 # Do hardcopy if requested
341 if hardcopy:
341 if hardcopy:
342 if psargs['filename'].endswith('.eps'):
342 if psargs['filename'].endswith('.eps'):
343 psargs['eps'] = 1
343 psargs['eps'] = 1
344 self.hardcopy(**psargs)
344 self.hardcopy(**psargs)
345
345
346 def plot(self, *items, **keyw):
346 def plot(self, *items, **keyw):
347 """Draw a new plot.
347 """Draw a new plot.
348
348
349 Clear the current plot and create a new 2-d plot containing
349 Clear the current plot and create a new 2-d plot containing
350 the specified items. Each arguments should be of the
350 the specified items. Each arguments should be of the
351 following types:
351 following types:
352
352
353 'PlotItem' (e.g., 'Data', 'File', 'Func') -- This is the most
353 'PlotItem' (e.g., 'Data', 'File', 'Func') -- This is the most
354 flexible way to call plot because the PlotItems can
354 flexible way to call plot because the PlotItems can
355 contain suboptions. Moreover, PlotItems can be saved to
355 contain suboptions. Moreover, PlotItems can be saved to
356 variables so that their lifetime is longer than one plot
356 variables so that their lifetime is longer than one plot
357 command; thus they can be replotted with minimal overhead.
357 command; thus they can be replotted with minimal overhead.
358
358
359 'string' (e.g., 'sin(x)') -- The string is interpreted as
359 'string' (e.g., 'sin(x)') -- The string is interpreted as
360 'Func(string)' (a function that is computed by gnuplot).
360 'Func(string)' (a function that is computed by gnuplot).
361
361
362 Anything else -- The object, which should be convertible to an
362 Anything else -- The object, which should be convertible to an
363 array, is passed to the 'Data' constructor, and thus
363 array, is passed to the 'Data' constructor, and thus
364 plotted as data. If the conversion fails, an exception is
364 plotted as data. If the conversion fails, an exception is
365 raised.
365 raised.
366
366
367
367
368 This is a modified version of plot(). Compared to the original in
368 This is a modified version of plot(). Compared to the original in
369 Gnuplot.py, this version has several enhancements, listed below.
369 Gnuplot.py, this version has several enhancements, listed below.
370
370
371
371
372 Modifications to the input arguments
372 Modifications to the input arguments
373 ------------------------------------
373 ------------------------------------
374
374
375 (1-d array means Numeric array, list or tuple):
375 (1-d array means Numeric array, list or tuple):
376
376
377 (i) Any 1-d array which is NOT followed by another 1-d array, is
377 (i) Any 1-d array which is NOT followed by another 1-d array, is
378 automatically zipped with range(len(array_1d)). Typing g.plot(y) will
378 automatically zipped with range(len(array_1d)). Typing g.plot(y) will
379 plot y against its indices.
379 plot y against its indices.
380
380
381 (ii) If two 1-d arrays are contiguous in the argument list, they are
381 (ii) If two 1-d arrays are contiguous in the argument list, they are
382 automatically zipped together. So g.plot(x,y) plots y vs. x, and
382 automatically zipped together. So g.plot(x,y) plots y vs. x, and
383 g.plot(x1,y1,x2,y2) plots y1 vs. x1 and y2 vs. x2.
383 g.plot(x1,y1,x2,y2) plots y1 vs. x1 and y2 vs. x2.
384
384
385 (iii) Any 1-d array which is followed by None is automatically zipped
385 (iii) Any 1-d array which is followed by None is automatically zipped
386 with range(len(array_1d)). In this form, typing g.plot(y1,None,y2)
386 with range(len(array_1d)). In this form, typing g.plot(y1,None,y2)
387 will plot both y1 and y2 against their respective indices (and NOT
387 will plot both y1 and y2 against their respective indices (and NOT
388 versus one another). The None prevents zipping y1 and y2 together, and
388 versus one another). The None prevents zipping y1 and y2 together, and
389 since y2 is unpaired it is automatically zipped to its indices by (i)
389 since y2 is unpaired it is automatically zipped to its indices by (i)
390
390
391 (iv) Any other arguments which don't match these cases are left alone and
391 (iv) Any other arguments which don't match these cases are left alone and
392 passed to the code below.
392 passed to the code below.
393
393
394 For lists or tuples, the heuristics used to determine whether they are
394 For lists or tuples, the heuristics used to determine whether they are
395 in fact 1-d is fairly simplistic: their first element is checked, and
395 in fact 1-d is fairly simplistic: their first element is checked, and
396 if it is not a list or tuple itself, it is assumed that the whole
396 if it is not a list or tuple itself, it is assumed that the whole
397 object is one-dimensional.
397 object is one-dimensional.
398
398
399 An additional optional keyword 'titles' has been added: it must be a
399 An additional optional keyword 'titles' has been added: it must be a
400 list of strings to be used as labels for the individual plots which
400 list of strings to be used as labels for the individual plots which
401 are NOT PlotItem objects (since those objects carry their own labels
401 are NOT PlotItem objects (since those objects carry their own labels
402 within).
402 within).
403
403
404
404
405 PostScript generation
405 PostScript generation
406 ---------------------
406 ---------------------
407
407
408 This version of plot() also handles automatically the production of
408 This version of plot() also handles automatically the production of
409 PostScript output. The main options are (given as keyword arguments):
409 PostScript output. The main options are (given as keyword arguments):
410
410
411 - filename: a string, typically ending in .eps. If given, the plot is
411 - filename: a string, typically ending in .eps. If given, the plot is
412 sent to this file in PostScript format.
412 sent to this file in PostScript format.
413
413
414 - hardcopy: this can be set to 0 to override 'filename'. It does not
414 - hardcopy: this can be set to 0 to override 'filename'. It does not
415 need to be given to produce PostScript, its purpose is to allow
415 need to be given to produce PostScript, its purpose is to allow
416 switching PostScript output off globally in scripts without having to
416 switching PostScript output off globally in scripts without having to
417 manually change 'filename' values in multiple calls.
417 manually change 'filename' values in multiple calls.
418
418
419 All other keywords accepted by Gnuplot.hardcopy() are transparently
419 All other keywords accepted by Gnuplot.hardcopy() are transparently
420 passed, and safely ignored if output is sent to the screen instead of
420 passed, and safely ignored if output is sent to the screen instead of
421 PostScript.
421 PostScript.
422
422
423 For example:
423 For example:
424
424
425 In [1]: x=frange(0,2*pi,npts=100)
425 In [1]: x=frange(0,2*pi,npts=100)
426
426
427 Generate a plot in file 'sin.eps':
427 Generate a plot in file 'sin.eps':
428
428
429 In [2]: plot(x,sin(x),filename = 'sin.eps')
429 In [2]: plot(x,sin(x),filename = 'sin.eps')
430
430
431 Plot to screen instead, without having to change the filename:
431 Plot to screen instead, without having to change the filename:
432
432
433 In [3]: plot(x,sin(x),filename = 'sin.eps',hardcopy=0)
433 In [3]: plot(x,sin(x),filename = 'sin.eps',hardcopy=0)
434
434
435 Pass the 'color=0' option to hardcopy for monochrome output:
435 Pass the 'color=0' option to hardcopy for monochrome output:
436
436
437 In [4]: plot(x,sin(x),filename = 'sin.eps',color=0)
437 In [4]: plot(x,sin(x),filename = 'sin.eps',color=0)
438
438
439 PostScript generation through plot() is useful mainly for scripting
439 PostScript generation through plot() is useful mainly for scripting
440 uses where you are not interested in interactive plotting. For
440 uses where you are not interested in interactive plotting. For
441 interactive use, the hardcopy() function is typically more convenient:
441 interactive use, the hardcopy() function is typically more convenient:
442
442
443 In [5]: plot(x,sin(x))
443 In [5]: plot(x,sin(x))
444
444
445 In [6]: hardcopy('sin.eps') """
445 In [6]: hardcopy('sin.eps') """
446
446
447 self.__plot_ps(Gnuplot_ori.Gnuplot.plot,*items,**keyw)
447 self.__plot_ps(Gnuplot_ori.Gnuplot.plot,*items,**keyw)
448
448
449 def plot2(self,arg,**kw):
449 def plot2(self,arg,**kw):
450 """Plot the entries of a dictionary or a list/tuple of arrays.
450 """Plot the entries of a dictionary or a list/tuple of arrays.
451
451
452 This simple utility calls plot() with a list of Gnuplot.Data objects
452 This simple utility calls plot() with a list of Gnuplot.Data objects
453 constructed either from the values of the input dictionary, or the entries
453 constructed either from the values of the input dictionary, or the entries
454 in it if it is a tuple or list. Each item gets labeled with the key/index
454 in it if it is a tuple or list. Each item gets labeled with the key/index
455 in the Gnuplot legend.
455 in the Gnuplot legend.
456
456
457 Each item is plotted by zipping it with a list of its indices.
457 Each item is plotted by zipping it with a list of its indices.
458
458
459 Any keywords are passed directly to plot()."""
459 Any keywords are passed directly to plot()."""
460
460
461 if hasattr(arg,'keys'):
461 if hasattr(arg,'keys'):
462 keys = arg.keys()
462 keys = arg.keys()
463 keys.sort()
463 keys.sort()
464 else:
464 else:
465 keys = range(len(arg))
465 keys = range(len(arg))
466
466
467 pitems = [Data(zip(range(len(arg[k])),arg[k]),title=`k`) for k in keys]
467 pitems = [Data(zip(range(len(arg[k])),arg[k]),title=`k`) for k in keys]
468 self.plot(*pitems,**kw)
468 self.plot(*pitems,**kw)
469
469
470 def splot(self, *items, **keyw):
470 def splot(self, *items, **keyw):
471 """Draw a new three-dimensional plot.
471 """Draw a new three-dimensional plot.
472
472
473 Clear the current plot and create a new 3-d plot containing
473 Clear the current plot and create a new 3-d plot containing
474 the specified items. Arguments can be of the following types:
474 the specified items. Arguments can be of the following types:
475
475
476 'PlotItem' (e.g., 'Data', 'File', 'Func', 'GridData' ) -- This
476 'PlotItem' (e.g., 'Data', 'File', 'Func', 'GridData' ) -- This
477 is the most flexible way to call plot because the
477 is the most flexible way to call plot because the
478 PlotItems can contain suboptions. Moreover, PlotItems can
478 PlotItems can contain suboptions. Moreover, PlotItems can
479 be saved to variables so that their lifetime is longer
479 be saved to variables so that their lifetime is longer
480 than one plot command--thus they can be replotted with
480 than one plot command--thus they can be replotted with
481 minimal overhead.
481 minimal overhead.
482
482
483 'string' (e.g., 'sin(x*y)') -- The string is interpreted as a
483 'string' (e.g., 'sin(x*y)') -- The string is interpreted as a
484 'Func()' (a function that is computed by gnuplot).
484 'Func()' (a function that is computed by gnuplot).
485
485
486 Anything else -- The object is converted to a Data() item, and
486 Anything else -- The object is converted to a Data() item, and
487 thus plotted as data. Note that each data point should
487 thus plotted as data. Note that each data point should
488 normally have at least three values associated with it
488 normally have at least three values associated with it
489 (i.e., x, y, and z). If the conversion fails, an
489 (i.e., x, y, and z). If the conversion fails, an
490 exception is raised.
490 exception is raised.
491
491
492 This is a modified version of splot(). Compared to the original in
492 This is a modified version of splot(). Compared to the original in
493 Gnuplot.py, this version has several enhancements, listed in the
493 Gnuplot.py, this version has several enhancements, listed in the
494 plot() documentation.
494 plot() documentation.
495 """
495 """
496
496
497 self.__plot_ps(Gnuplot_ori.Gnuplot.splot,*items,**keyw)
497 self.__plot_ps(Gnuplot_ori.Gnuplot.splot,*items,**keyw)
498
498
499 def replot(self, *items, **keyw):
499 def replot(self, *items, **keyw):
500 """Replot the data, possibly adding new 'PlotItem's.
500 """Replot the data, possibly adding new 'PlotItem's.
501
501
502 Replot the existing graph, using the items in the current
502 Replot the existing graph, using the items in the current
503 itemlist. If arguments are specified, they are interpreted as
503 itemlist. If arguments are specified, they are interpreted as
504 additional items to be plotted alongside the existing items on
504 additional items to be plotted alongside the existing items on
505 the same graph. See 'plot' for details.
505 the same graph. See 'plot' for details.
506
506
507 If you want to replot to a postscript file, you MUST give the
507 If you want to replot to a postscript file, you MUST give the
508 'filename' keyword argument in each call to replot. The Gnuplot python
508 'filename' keyword argument in each call to replot. The Gnuplot python
509 interface has no way of knowing that your previous call to
509 interface has no way of knowing that your previous call to
510 Gnuplot.plot() was meant for PostScript output."""
510 Gnuplot.plot() was meant for PostScript output."""
511
511
512 self.__plot_ps(Gnuplot_ori.Gnuplot.replot,*items,**keyw)
512 self.__plot_ps(Gnuplot_ori.Gnuplot.replot,*items,**keyw)
513
513
514 # The original hardcopy has a bug. See fix at the end. The rest of the code
514 # The original hardcopy has a bug. See fix at the end. The rest of the code
515 # was lifted verbatim from the original, so that people using IPython get the
515 # was lifted verbatim from the original, so that people using IPython get the
516 # benefits without having to manually patch Gnuplot.py
516 # benefits without having to manually patch Gnuplot.py
517 def hardcopy(self, filename=None,
517 def hardcopy(self, filename=None,
518 mode=None,
518 mode=None,
519 eps=None,
519 eps=None,
520 enhanced=None,
520 enhanced=None,
521 color=None,
521 color=None,
522 solid=None,
522 solid=None,
523 duplexing=None,
523 duplexing=None,
524 fontname=None,
524 fontname=None,
525 fontsize=None,
525 fontsize=None,
526 debug = 0,
526 debug = 0,
527 ):
527 ):
528 """Create a hardcopy of the current plot.
528 """Create a hardcopy of the current plot.
529
529
530 Create a postscript hardcopy of the current plot to the
530 Create a postscript hardcopy of the current plot to the
531 default printer (if configured) or to the specified filename.
531 default printer (if configured) or to the specified filename.
532
532
533 Note that gnuplot remembers the postscript suboptions across
533 Note that gnuplot remembers the postscript suboptions across
534 terminal changes. Therefore if you set, for example, color=1
534 terminal changes. Therefore if you set, for example, color=1
535 for one hardcopy then the next hardcopy will also be color
535 for one hardcopy then the next hardcopy will also be color
536 unless you explicitly choose color=0. Alternately you can
536 unless you explicitly choose color=0. Alternately you can
537 force all of the options to their defaults by setting
537 force all of the options to their defaults by setting
538 mode='default'. I consider this to be a bug in gnuplot.
538 mode='default'. I consider this to be a bug in gnuplot.
539
539
540 Keyword arguments:
540 Keyword arguments:
541
541
542 'filename=<string>' -- if a filename is specified, save the
542 'filename=<string>' -- if a filename is specified, save the
543 output in that file; otherwise print it immediately
543 output in that file; otherwise print it immediately
544 using the 'default_lpr' configuration option. If the
544 using the 'default_lpr' configuration option. If the
545 filename ends in '.eps', EPS mode is automatically
545 filename ends in '.eps', EPS mode is automatically
546 selected (like manually specifying eps=1 or mode='eps').
546 selected (like manually specifying eps=1 or mode='eps').
547
547
548 'mode=<string>' -- set the postscript submode ('landscape',
548 'mode=<string>' -- set the postscript submode ('landscape',
549 'portrait', 'eps', or 'default'). The default is
549 'portrait', 'eps', or 'default'). The default is
550 to leave this option unspecified.
550 to leave this option unspecified.
551
551
552 'eps=<bool>' -- shorthand for 'mode="eps"'; asks gnuplot to
552 'eps=<bool>' -- shorthand for 'mode="eps"'; asks gnuplot to
553 generate encapsulated postscript.
553 generate encapsulated postscript.
554
554
555 'enhanced=<bool>' -- if set (the default), then generate
555 'enhanced=<bool>' -- if set (the default), then generate
556 enhanced postscript, which allows extra features like
556 enhanced postscript, which allows extra features like
557 font-switching, superscripts, and subscripts in axis
557 font-switching, superscripts, and subscripts in axis
558 labels. (Some old gnuplot versions do not support
558 labels. (Some old gnuplot versions do not support
559 enhanced postscript; if this is the case set
559 enhanced postscript; if this is the case set
560 gp.GnuplotOpts.prefer_enhanced_postscript=None.)
560 gp.GnuplotOpts.prefer_enhanced_postscript=None.)
561
561
562 'color=<bool>' -- if set, create a plot with color. Default
562 'color=<bool>' -- if set, create a plot with color. Default
563 is to leave this option unchanged.
563 is to leave this option unchanged.
564
564
565 'solid=<bool>' -- if set, force lines to be solid (i.e., not
565 'solid=<bool>' -- if set, force lines to be solid (i.e., not
566 dashed).
566 dashed).
567
567
568 'duplexing=<string>' -- set duplexing option ('defaultplex',
568 'duplexing=<string>' -- set duplexing option ('defaultplex',
569 'simplex', or 'duplex'). Only request double-sided
569 'simplex', or 'duplex'). Only request double-sided
570 printing if your printer can handle it. Actually this
570 printing if your printer can handle it. Actually this
571 option is probably meaningless since hardcopy() can only
571 option is probably meaningless since hardcopy() can only
572 print a single plot at a time.
572 print a single plot at a time.
573
573
574 'fontname=<string>' -- set the default font to <string>,
574 'fontname=<string>' -- set the default font to <string>,
575 which must be a valid postscript font. The default is
575 which must be a valid postscript font. The default is
576 to leave this option unspecified.
576 to leave this option unspecified.
577
577
578 'fontsize=<double>' -- set the default font size, in
578 'fontsize=<double>' -- set the default font size, in
579 postscript points.
579 postscript points.
580
580
581 'debug=<bool>' -- print extra debugging information (useful if
581 'debug=<bool>' -- print extra debugging information (useful if
582 your PostScript files are misteriously not being created).
582 your PostScript files are misteriously not being created).
583 """
583 """
584
584
585 if filename is None:
585 if filename is None:
586 assert gp.GnuplotOpts.default_lpr is not None, \
586 assert gp.GnuplotOpts.default_lpr is not None, \
587 OptionException('default_lpr is not set, so you can only '
587 OptionException('default_lpr is not set, so you can only '
588 'print to a file.')
588 'print to a file.')
589 filename = gp.GnuplotOpts.default_lpr
589 filename = gp.GnuplotOpts.default_lpr
590 lpr_output = 1
590 lpr_output = 1
591 else:
591 else:
592 if filename.endswith('.eps'):
592 if filename.endswith('.eps'):
593 eps = 1
593 eps = 1
594 lpr_output = 0
594 lpr_output = 0
595
595
596 # Be careful processing the options. If the user didn't
596 # Be careful processing the options. If the user didn't
597 # request an option explicitly, do not specify it on the 'set
597 # request an option explicitly, do not specify it on the 'set
598 # terminal' line (don't even specify the default value for the
598 # terminal' line (don't even specify the default value for the
599 # option). This is to avoid confusing older versions of
599 # option). This is to avoid confusing older versions of
600 # gnuplot that do not support all of these options. The
600 # gnuplot that do not support all of these options. The
601 # exception is 'enhanced', which is just too useful to have to
601 # exception is 'enhanced', which is just too useful to have to
602 # specify each time!
602 # specify each time!
603
603
604 setterm = ['set', 'terminal', 'postscript']
604 setterm = ['set', 'terminal', 'postscript']
605 if eps:
605 if eps:
606 assert mode is None or mode=='eps', \
606 assert mode is None or mode=='eps', \
607 OptionException('eps option and mode are incompatible')
607 OptionException('eps option and mode are incompatible')
608 setterm.append('eps')
608 setterm.append('eps')
609 else:
609 else:
610 if mode is not None:
610 if mode is not None:
611 assert mode in ['landscape', 'portrait', 'eps', 'default'], \
611 assert mode in ['landscape', 'portrait', 'eps', 'default'], \
612 OptionException('illegal mode "%s"' % mode)
612 OptionException('illegal mode "%s"' % mode)
613 setterm.append(mode)
613 setterm.append(mode)
614 if enhanced is None:
614 if enhanced is None:
615 enhanced = gp.GnuplotOpts.prefer_enhanced_postscript
615 enhanced = gp.GnuplotOpts.prefer_enhanced_postscript
616 if enhanced is not None:
616 if enhanced is not None:
617 if enhanced: setterm.append('enhanced')
617 if enhanced: setterm.append('enhanced')
618 else: setterm.append('noenhanced')
618 else: setterm.append('noenhanced')
619 if color is not None:
619 if color is not None:
620 if color: setterm.append('color')
620 if color: setterm.append('color')
621 else: setterm.append('monochrome')
621 else: setterm.append('monochrome')
622 if solid is not None:
622 if solid is not None:
623 if solid: setterm.append('solid')
623 if solid: setterm.append('solid')
624 else: setterm.append('dashed')
624 else: setterm.append('dashed')
625 if duplexing is not None:
625 if duplexing is not None:
626 assert duplexing in ['defaultplex', 'simplex', 'duplex'], \
626 assert duplexing in ['defaultplex', 'simplex', 'duplex'], \
627 OptionException('illegal duplexing mode "%s"' % duplexing)
627 OptionException('illegal duplexing mode "%s"' % duplexing)
628 setterm.append(duplexing)
628 setterm.append(duplexing)
629 if fontname is not None:
629 if fontname is not None:
630 setterm.append('"%s"' % fontname)
630 setterm.append('"%s"' % fontname)
631 if fontsize is not None:
631 if fontsize is not None:
632 setterm.append('%s' % fontsize)
632 setterm.append('%s' % fontsize)
633
633
634 self(string.join(setterm))
634 self(string.join(setterm))
635 self.set_string('output', filename)
635 self.set_string('output', filename)
636 # replot the current figure (to the printer):
636 # replot the current figure (to the printer):
637 self.refresh()
637 self.refresh()
638
638
639 # fperez. Ugly kludge: often for some reason the file is NOT created
639 # fperez. Ugly kludge: often for some reason the file is NOT created
640 # and we must reissue the creation commands. I have no idea why!
640 # and we must reissue the creation commands. I have no idea why!
641 if not lpr_output:
641 if not lpr_output:
642 #print 'Hardcopy <%s>' % filename # dbg
642 #print 'Hardcopy <%s>' % filename # dbg
643 maxtries = 20
643 maxtries = 20
644 delay = 0.1 # delay (in seconds) between print attempts
644 delay = 0.1 # delay (in seconds) between print attempts
645 for i in range(maxtries):
645 for i in range(maxtries):
646 time.sleep(0.05) # safety, very small delay
646 time.sleep(0.05) # safety, very small delay
647 if os.path.isfile(filename):
647 if os.path.isfile(filename):
648 if debug:
648 if debug:
649 print 'Hardcopy to file <%s> success at attempt #%s.' \
649 print 'Hardcopy to file <%s> success at attempt #%s.' \
650 % (filename,i+1)
650 % (filename,i+1)
651 break
651 break
652 time.sleep(delay)
652 time.sleep(delay)
653 # try again, issue all commands just in case
653 # try again, issue all commands just in case
654 self(string.join(setterm))
654 self(string.join(setterm))
655 self.set_string('output', filename)
655 self.set_string('output', filename)
656 self.refresh()
656 self.refresh()
657 if not os.path.isfile(filename):
657 if not os.path.isfile(filename):
658 print >> sys.stderr,'ERROR: Tried %s times and failed to '\
658 print >> sys.stderr,'ERROR: Tried %s times and failed to '\
659 'create hardcopy file `%s`' % (maxtries,filename)
659 'create hardcopy file `%s`' % (maxtries,filename)
660
660
661 # reset the terminal to its `default' setting:
661 # reset the terminal to its `default' setting:
662 self('set terminal %s' % gp.GnuplotOpts.default_term)
662 self('set terminal %s' % gp.GnuplotOpts.default_term)
663 self.set_string('output')
663 self.set_string('output')
664
664
665 #********************** End of file <Gnuplot2.py> ************************
665 #********************** End of file <Gnuplot2.py> ************************
@@ -1,147 +1,147 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Interactive functions and magic functions for Gnuplot usage.
2 """Interactive functions and magic functions for Gnuplot usage.
3
3
4 This requires the Gnuplot.py module for interfacing python with Gnuplot, which
4 This requires the Gnuplot.py module for interfacing python with Gnuplot, which
5 can be downloaded from:
5 can be downloaded from:
6
6
7 http://gnuplot-py.sourceforge.net/
7 http://gnuplot-py.sourceforge.net/
8
8
9 See gphelp() below for details on the services offered by this module.
9 See gphelp() below for details on the services offered by this module.
10
10
11 Inspired by a suggestion/request from Arnd Baecker.
11 Inspired by a suggestion/request from Arnd Baecker.
12 """
12 """
13
13
14 __all__ = ['Gnuplot','gp','gp_new','plot','plot2','splot','replot',
14 __all__ = ['Gnuplot','gp','gp_new','plot','plot2','splot','replot',
15 'hardcopy','gpdata','gpfile','gpstring','gpfunc','gpgrid',
15 'hardcopy','gpdata','gpfile','gpstring','gpfunc','gpgrid',
16 'gphelp']
16 'gphelp']
17
17
18 import IPython.GnuplotRuntime as GRun
18 import IPython.GnuplotRuntime as GRun
19 from IPython.genutils import page,warn
19 from IPython.utils.genutils import page,warn
20
20
21 # Set global names for interactive use
21 # Set global names for interactive use
22 Gnuplot = GRun.Gnuplot
22 Gnuplot = GRun.Gnuplot
23 gp_new = GRun.gp_new
23 gp_new = GRun.gp_new
24 gp = GRun.gp
24 gp = GRun.gp
25 plot = gp.plot
25 plot = gp.plot
26 plot2 = gp.plot2
26 plot2 = gp.plot2
27 splot = gp.splot
27 splot = gp.splot
28 replot = gp.replot
28 replot = gp.replot
29 hardcopy = gp.hardcopy
29 hardcopy = gp.hardcopy
30
30
31 # Accessors for the main plot object constructors:
31 # Accessors for the main plot object constructors:
32 gpdata = Gnuplot.Data
32 gpdata = Gnuplot.Data
33 gpfile = Gnuplot.File
33 gpfile = Gnuplot.File
34 gpstring = Gnuplot.String
34 gpstring = Gnuplot.String
35 gpfunc = Gnuplot.Func
35 gpfunc = Gnuplot.Func
36 gpgrid = Gnuplot.GridData
36 gpgrid = Gnuplot.GridData
37
37
38 def gphelp():
38 def gphelp():
39 """Print information about the Gnuplot facilities in IPython."""
39 """Print information about the Gnuplot facilities in IPython."""
40
40
41 page("""
41 page("""
42 IPython provides an interface to access the Gnuplot scientific plotting
42 IPython provides an interface to access the Gnuplot scientific plotting
43 system, in an environment similar to that of Mathematica or Matlab.
43 system, in an environment similar to that of Mathematica or Matlab.
44
44
45 New top-level global objects
45 New top-level global objects
46 ----------------------------
46 ----------------------------
47
47
48 Please see their respective docstrings for further details.
48 Please see their respective docstrings for further details.
49
49
50 - gp: a running Gnuplot instance. You can access its methods as
50 - gp: a running Gnuplot instance. You can access its methods as
51 gp.<method>. gp(`a string`) will execute the given string as if it had been
51 gp.<method>. gp(`a string`) will execute the given string as if it had been
52 typed in an interactive gnuplot window.
52 typed in an interactive gnuplot window.
53
53
54 - plot, splot, replot and hardcopy: aliases to the methods of the same name in
54 - plot, splot, replot and hardcopy: aliases to the methods of the same name in
55 the global running Gnuplot instance gp. These allow you to simply type:
55 the global running Gnuplot instance gp. These allow you to simply type:
56
56
57 In [1]: plot(x,sin(x),title='Sin(x)') # assuming x is a Numeric array
57 In [1]: plot(x,sin(x),title='Sin(x)') # assuming x is a Numeric array
58
58
59 and obtain a plot of sin(x) vs x with the title 'Sin(x)'.
59 and obtain a plot of sin(x) vs x with the title 'Sin(x)'.
60
60
61 - gp_new: a function which returns a new Gnuplot instance. This can be used to
61 - gp_new: a function which returns a new Gnuplot instance. This can be used to
62 have multiple Gnuplot instances running in your session to compare different
62 have multiple Gnuplot instances running in your session to compare different
63 plots, each in a separate window.
63 plots, each in a separate window.
64
64
65 - Gnuplot: alias to the Gnuplot2 module, an improved drop-in replacement for
65 - Gnuplot: alias to the Gnuplot2 module, an improved drop-in replacement for
66 the original Gnuplot.py. Gnuplot2 needs Gnuplot but redefines several of its
66 the original Gnuplot.py. Gnuplot2 needs Gnuplot but redefines several of its
67 functions with improved versions (Gnuplot2 comes with IPython).
67 functions with improved versions (Gnuplot2 comes with IPython).
68
68
69 - gpdata, gpfile, gpstring, gpfunc, gpgrid: aliases to Gnuplot.Data,
69 - gpdata, gpfile, gpstring, gpfunc, gpgrid: aliases to Gnuplot.Data,
70 Gnuplot.File, Gnuplot.String, Gnuplot.Func and Gnuplot.GridData
70 Gnuplot.File, Gnuplot.String, Gnuplot.Func and Gnuplot.GridData
71 respectively. These functions create objects which can then be passed to the
71 respectively. These functions create objects which can then be passed to the
72 plotting commands. See the Gnuplot.py documentation for details.
72 plotting commands. See the Gnuplot.py documentation for details.
73
73
74 Keep in mind that all commands passed to a Gnuplot instance are executed in
74 Keep in mind that all commands passed to a Gnuplot instance are executed in
75 the Gnuplot namespace, where no Python variables exist. For example, for
75 the Gnuplot namespace, where no Python variables exist. For example, for
76 plotting sin(x) vs x as above, typing
76 plotting sin(x) vs x as above, typing
77
77
78 In [2]: gp('plot x,sin(x)')
78 In [2]: gp('plot x,sin(x)')
79
79
80 would not work. Instead, you would get the plot of BOTH the functions 'x' and
80 would not work. Instead, you would get the plot of BOTH the functions 'x' and
81 'sin(x)', since Gnuplot doesn't know about the 'x' Python array. The plot()
81 'sin(x)', since Gnuplot doesn't know about the 'x' Python array. The plot()
82 method lives in python and does know about these variables.
82 method lives in python and does know about these variables.
83
83
84
84
85 New magic functions
85 New magic functions
86 -------------------
86 -------------------
87
87
88 %gpc: pass one command to Gnuplot and execute it or open a Gnuplot shell where
88 %gpc: pass one command to Gnuplot and execute it or open a Gnuplot shell where
89 each line of input is executed.
89 each line of input is executed.
90
90
91 %gp_set_default: reset the value of IPython's global Gnuplot instance.""")
91 %gp_set_default: reset the value of IPython's global Gnuplot instance.""")
92
92
93 # Code below is all for IPython use
93 # Code below is all for IPython use
94 # Define the magic functions for communicating with the above gnuplot instance.
94 # Define the magic functions for communicating with the above gnuplot instance.
95 def magic_gpc(self,parameter_s=''):
95 def magic_gpc(self,parameter_s=''):
96 """Execute a gnuplot command or open a gnuplot shell.
96 """Execute a gnuplot command or open a gnuplot shell.
97
97
98 Usage (omit the % if automagic is on). There are two ways to use it:
98 Usage (omit the % if automagic is on). There are two ways to use it:
99
99
100 1) %gpc 'command' -> passes 'command' directly to the gnuplot instance.
100 1) %gpc 'command' -> passes 'command' directly to the gnuplot instance.
101
101
102 2) %gpc -> will open up a prompt (gnuplot>>>) which takes input like the
102 2) %gpc -> will open up a prompt (gnuplot>>>) which takes input like the
103 standard gnuplot interactive prompt. If you need to type a multi-line
103 standard gnuplot interactive prompt. If you need to type a multi-line
104 command, use \\ at the end of each intermediate line.
104 command, use \\ at the end of each intermediate line.
105
105
106 Upon exiting of the gnuplot sub-shell, you return to your IPython
106 Upon exiting of the gnuplot sub-shell, you return to your IPython
107 session (the gnuplot sub-shell can be invoked as many times as needed).
107 session (the gnuplot sub-shell can be invoked as many times as needed).
108 """
108 """
109
109
110 if parameter_s.strip():
110 if parameter_s.strip():
111 self.shell.gnuplot(parameter_s)
111 self.shell.gnuplot(parameter_s)
112 else:
112 else:
113 self.shell.gnuplot.interact()
113 self.shell.gnuplot.interact()
114
114
115 def magic_gp_set_default(self,parameter_s=''):
115 def magic_gp_set_default(self,parameter_s=''):
116 """Set the default gnuplot instance accessed by the %gp magic function.
116 """Set the default gnuplot instance accessed by the %gp magic function.
117
117
118 %gp_set_default name
118 %gp_set_default name
119
119
120 Call with the name of the new instance at the command line. If you want to
120 Call with the name of the new instance at the command line. If you want to
121 set this instance in your own code (using an embedded IPython, for
121 set this instance in your own code (using an embedded IPython, for
122 example), simply set the variable __IPYTHON__.gnuplot to your own gnuplot
122 example), simply set the variable __IPYTHON__.gnuplot to your own gnuplot
123 instance object."""
123 instance object."""
124
124
125 gname = parameter_s.strip()
125 gname = parameter_s.strip()
126 G = eval(gname,self.shell.user_ns)
126 G = eval(gname,self.shell.user_ns)
127 self.shell.gnuplot = G
127 self.shell.gnuplot = G
128 self.shell.user_ns.update({'plot':G.plot,'splot':G.splot,'plot2':G.plot2,
128 self.shell.user_ns.update({'plot':G.plot,'splot':G.splot,'plot2':G.plot2,
129 'replot':G.replot,'hardcopy':G.hardcopy})
129 'replot':G.replot,'hardcopy':G.hardcopy})
130
130
131 try:
131 try:
132 __IPYTHON__
132 __IPYTHON__
133 except NameError:
133 except NameError:
134 pass
134 pass
135 else:
135 else:
136 # make the global Gnuplot instance known to IPython
136 # make the global Gnuplot instance known to IPython
137 __IPYTHON__.gnuplot = GRun.gp
137 __IPYTHON__.gnuplot = GRun.gp
138 __IPYTHON__.gnuplot.shell_first_time = 1
138 __IPYTHON__.gnuplot.shell_first_time = 1
139
139
140 print """*** Type `gphelp` for help on the Gnuplot integration features."""
140 print """*** Type `gphelp` for help on the Gnuplot integration features."""
141
141
142 # Add the new magic functions to the class dict
142 # Add the new magic functions to the class dict
143 from IPython.iplib import InteractiveShell
143 from IPython.iplib import InteractiveShell
144 InteractiveShell.magic_gpc = magic_gpc
144 InteractiveShell.magic_gpc = magic_gpc
145 InteractiveShell.magic_gp_set_default = magic_gp_set_default
145 InteractiveShell.magic_gp_set_default = magic_gp_set_default
146
146
147 #********************** End of file <GnuplotInteractive.py> *******************
147 #********************** End of file <GnuplotInteractive.py> *******************
@@ -1,146 +1,146 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Basic Gnuplot functionality for inclusion in other code.
2 """Basic Gnuplot functionality for inclusion in other code.
3
3
4 This module creates a running Gnuplot instance called 'gp' and builds other
4 This module creates a running Gnuplot instance called 'gp' and builds other
5 convenient globals for quick use in running scripts. It is intended to allow
5 convenient globals for quick use in running scripts. It is intended to allow
6 you to script plotting tasks in Python with a minimum of effort. A typical
6 you to script plotting tasks in Python with a minimum of effort. A typical
7 usage would be:
7 usage would be:
8
8
9 import IPython.GnuplotRuntime as GP # or some other short name
9 import IPython.GnuplotRuntime as GP # or some other short name
10 GP.gp.plot(GP.File('your_data.dat'))
10 GP.gp.plot(GP.File('your_data.dat'))
11
11
12
12
13 This module exposes the following objects:
13 This module exposes the following objects:
14
14
15 - gp: a running Gnuplot instance. You can access its methods as
15 - gp: a running Gnuplot instance. You can access its methods as
16 gp.<method>. gp(`a string`) will execute the given string as if it had been
16 gp.<method>. gp(`a string`) will execute the given string as if it had been
17 typed in an interactive gnuplot window.
17 typed in an interactive gnuplot window.
18
18
19 - gp_new: a function which returns a new Gnuplot instance. This can be used to
19 - gp_new: a function which returns a new Gnuplot instance. This can be used to
20 have multiple Gnuplot instances running in your session to compare different
20 have multiple Gnuplot instances running in your session to compare different
21 plots.
21 plots.
22
22
23 - Gnuplot: alias to the Gnuplot2 module, an improved drop-in replacement for
23 - Gnuplot: alias to the Gnuplot2 module, an improved drop-in replacement for
24 the original Gnuplot.py. Gnuplot2 needs Gnuplot but redefines several of its
24 the original Gnuplot.py. Gnuplot2 needs Gnuplot but redefines several of its
25 functions with improved versions (Gnuplot2 comes with IPython).
25 functions with improved versions (Gnuplot2 comes with IPython).
26
26
27 - Data: alias to Gnuplot.Data, makes a PlotItem from array data.
27 - Data: alias to Gnuplot.Data, makes a PlotItem from array data.
28
28
29 - File: alias to Gnuplot.File, makes a PlotItem from a file.
29 - File: alias to Gnuplot.File, makes a PlotItem from a file.
30
30
31 - String: alias to Gnuplot.String, makes a PlotItem from a string formatted
31 - String: alias to Gnuplot.String, makes a PlotItem from a string formatted
32 exactly like a file for Gnuplot.File would be.
32 exactly like a file for Gnuplot.File would be.
33
33
34 - Func: alias to Gnuplot.Func, makes a PlotItem from a function string.
34 - Func: alias to Gnuplot.Func, makes a PlotItem from a function string.
35
35
36 - GridData: alias to Gnuplot.GridData, makes a PlotItem from grid data.
36 - GridData: alias to Gnuplot.GridData, makes a PlotItem from grid data.
37
37
38 - pm3d_config: a string with Gnuplot commands to set up the pm3d mode for
38 - pm3d_config: a string with Gnuplot commands to set up the pm3d mode for
39 surface plotting. You can activate it simply by calling gp(pm3d_config).
39 surface plotting. You can activate it simply by calling gp(pm3d_config).
40
40
41 - eps_fix_bbox: A Unix-only function to fix eps files with bad bounding boxes
41 - eps_fix_bbox: A Unix-only function to fix eps files with bad bounding boxes
42 (which Gnuplot generates when the plot size is set to square).
42 (which Gnuplot generates when the plot size is set to square).
43
43
44 This requires the Gnuplot.py module for interfacing Python with Gnuplot, which
44 This requires the Gnuplot.py module for interfacing Python with Gnuplot, which
45 can be downloaded from:
45 can be downloaded from:
46
46
47 http://gnuplot-py.sourceforge.net/
47 http://gnuplot-py.sourceforge.net/
48
48
49 Inspired by a suggestion/request from Arnd Baecker.
49 Inspired by a suggestion/request from Arnd Baecker.
50 """
50 """
51
51
52 __all__ = ['Gnuplot','gp','gp_new','Data','File','Func','GridData',
52 __all__ = ['Gnuplot','gp','gp_new','Data','File','Func','GridData',
53 'pm3d_config','eps_fix_bbox']
53 'pm3d_config','eps_fix_bbox']
54
54
55 import os,tempfile,sys
55 import os,tempfile,sys
56 from IPython.genutils import getoutput
56 from IPython.utils.genutils import getoutput
57
57
58 #---------------------------------------------------------------------------
58 #---------------------------------------------------------------------------
59 # Notes on mouse support for Gnuplot.py
59 # Notes on mouse support for Gnuplot.py
60
60
61 # If you do not have a mouse-enabled gnuplot, set gnuplot_mouse to 0. If you
61 # If you do not have a mouse-enabled gnuplot, set gnuplot_mouse to 0. If you
62 # use gnuplot, you should really grab a recent, mouse enabled copy. It is an
62 # use gnuplot, you should really grab a recent, mouse enabled copy. It is an
63 # extremely useful feature. Mouse support is official as of gnuplot 4.0,
63 # extremely useful feature. Mouse support is official as of gnuplot 4.0,
64 # released in April 2004.
64 # released in April 2004.
65
65
66 # For the mouse features to work correctly, you MUST set your Gnuplot.py
66 # For the mouse features to work correctly, you MUST set your Gnuplot.py
67 # module to use temporary files instead of 'inline data' for data
67 # module to use temporary files instead of 'inline data' for data
68 # communication. Note that this is the default, so unless you've manually
68 # communication. Note that this is the default, so unless you've manually
69 # fiddled with it you should be ok. If you need to make changes, in the
69 # fiddled with it you should be ok. If you need to make changes, in the
70 # Gnuplot module directory, loook for the gp_unix.py file and make sure the
70 # Gnuplot module directory, loook for the gp_unix.py file and make sure the
71 # prefer_inline_data variable is set to 0. If you set it to 1 Gnuplot.py will
71 # prefer_inline_data variable is set to 0. If you set it to 1 Gnuplot.py will
72 # try to pass the data to gnuplot via standard input, which completely
72 # try to pass the data to gnuplot via standard input, which completely
73 # confuses the mouse control system (even though it may be a bit faster than
73 # confuses the mouse control system (even though it may be a bit faster than
74 # using temp files).
74 # using temp files).
75
75
76 # As of Gnuplot.py v1.7, a new option was added to use FIFOs (pipes). This
76 # As of Gnuplot.py v1.7, a new option was added to use FIFOs (pipes). This
77 # mechanism, while fast, also breaks the mouse system. You must therefore set
77 # mechanism, while fast, also breaks the mouse system. You must therefore set
78 # the variable prefer_fifo_data to 0 in gp_unix.py.
78 # the variable prefer_fifo_data to 0 in gp_unix.py.
79
79
80 tmpname = tempfile.mktemp()
80 tmpname = tempfile.mktemp()
81 open(tmpname,'w').write('set mouse')
81 open(tmpname,'w').write('set mouse')
82 gnu_out = getoutput('gnuplot '+ tmpname)
82 gnu_out = getoutput('gnuplot '+ tmpname)
83 os.unlink(tmpname)
83 os.unlink(tmpname)
84 if gnu_out: # Gnuplot won't print anything if it has mouse support
84 if gnu_out: # Gnuplot won't print anything if it has mouse support
85 print "*** Your version of Gnuplot appears not to have mouse support."
85 print "*** Your version of Gnuplot appears not to have mouse support."
86 gnuplot_mouse = 0
86 gnuplot_mouse = 0
87 else:
87 else:
88 gnuplot_mouse = 1
88 gnuplot_mouse = 1
89 del tmpname,gnu_out
89 del tmpname,gnu_out
90
90
91 # Default state for persistence of new gnuplot instances
91 # Default state for persistence of new gnuplot instances
92 if os.name in ['nt','dos'] or sys.platform == 'cygwin':
92 if os.name in ['nt','dos'] or sys.platform == 'cygwin':
93 gnuplot_persist = 0
93 gnuplot_persist = 0
94 else:
94 else:
95 gnuplot_persist = 1
95 gnuplot_persist = 1
96
96
97 import IPython.Gnuplot2 as Gnuplot
97 import IPython.Gnuplot2 as Gnuplot
98
98
99 class NotGiven: pass
99 class NotGiven: pass
100
100
101 def gp_new(mouse=NotGiven,persist=NotGiven):
101 def gp_new(mouse=NotGiven,persist=NotGiven):
102 """Return a new Gnuplot instance.
102 """Return a new Gnuplot instance.
103
103
104 The instance returned uses the improved methods defined in Gnuplot2.
104 The instance returned uses the improved methods defined in Gnuplot2.
105
105
106 Options (boolean):
106 Options (boolean):
107
107
108 - mouse: if unspecified, the module global gnuplot_mouse is used.
108 - mouse: if unspecified, the module global gnuplot_mouse is used.
109
109
110 - persist: if unspecified, the module global gnuplot_persist is used."""
110 - persist: if unspecified, the module global gnuplot_persist is used."""
111
111
112 if mouse is NotGiven:
112 if mouse is NotGiven:
113 mouse = gnuplot_mouse
113 mouse = gnuplot_mouse
114 if persist is NotGiven:
114 if persist is NotGiven:
115 persist = gnuplot_persist
115 persist = gnuplot_persist
116 g = Gnuplot.Gnuplot(persist=persist)
116 g = Gnuplot.Gnuplot(persist=persist)
117 if mouse:
117 if mouse:
118 g('set mouse')
118 g('set mouse')
119 return g
119 return g
120
120
121 # Global-level names.
121 # Global-level names.
122
122
123 # A global Gnuplot instance for interactive use:
123 # A global Gnuplot instance for interactive use:
124 gp = gp_new()
124 gp = gp_new()
125
125
126 # Accessors for the main plot object constructors:
126 # Accessors for the main plot object constructors:
127 Data = Gnuplot.Data
127 Data = Gnuplot.Data
128 File = Gnuplot.File
128 File = Gnuplot.File
129 Func = Gnuplot.Func
129 Func = Gnuplot.Func
130 String = Gnuplot.String
130 String = Gnuplot.String
131 GridData = Gnuplot.GridData
131 GridData = Gnuplot.GridData
132
132
133 # A Unix-only function to fix eps files with bad bounding boxes (which Gnuplot
133 # A Unix-only function to fix eps files with bad bounding boxes (which Gnuplot
134 # generates when the plot size is set to square):
134 # generates when the plot size is set to square):
135 eps_fix_bbox = Gnuplot.eps_fix_bbox
135 eps_fix_bbox = Gnuplot.eps_fix_bbox
136
136
137 # String for configuring pm3d. Simply call g(pm3d_config) to execute it. pm3d
137 # String for configuring pm3d. Simply call g(pm3d_config) to execute it. pm3d
138 # is a very nice mode for plotting colormaps on surfaces. Modify the defaults
138 # is a very nice mode for plotting colormaps on surfaces. Modify the defaults
139 # below to suit your taste.
139 # below to suit your taste.
140 pm3d_config = """
140 pm3d_config = """
141 set pm3d solid
141 set pm3d solid
142 set hidden3d
142 set hidden3d
143 unset surface
143 unset surface
144 set isosamples 50
144 set isosamples 50
145 """
145 """
146 #******************** End of file <GnuplotRuntime.py> ******************
146 #******************** End of file <GnuplotRuntime.py> ******************
@@ -1,3457 +1,3457 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Magic functions for InteractiveShell.
2 """Magic functions for InteractiveShell.
3 """
3 """
4
4
5 #*****************************************************************************
5 #*****************************************************************************
6 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
6 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
7 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
7 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
8 #
8 #
9 # Distributed under the terms of the BSD License. The full license is in
9 # Distributed under the terms of the BSD License. The full license is in
10 # the file COPYING, distributed as part of this software.
10 # the file COPYING, distributed as part of this software.
11 #*****************************************************************************
11 #*****************************************************************************
12
12
13 #****************************************************************************
13 #****************************************************************************
14 # Modules and globals
14 # Modules and globals
15
15
16 # Python standard modules
16 # Python standard modules
17 import __builtin__
17 import __builtin__
18 import bdb
18 import bdb
19 import inspect
19 import inspect
20 import os
20 import os
21 import pdb
21 import pdb
22 import pydoc
22 import pydoc
23 import sys
23 import sys
24 import re
24 import re
25 import tempfile
25 import tempfile
26 import time
26 import time
27 import cPickle as pickle
27 import cPickle as pickle
28 import textwrap
28 import textwrap
29 from cStringIO import StringIO
29 from cStringIO import StringIO
30 from getopt import getopt,GetoptError
30 from getopt import getopt,GetoptError
31 from pprint import pprint, pformat
31 from pprint import pprint, pformat
32
32
33 # cProfile was added in Python2.5
33 # cProfile was added in Python2.5
34 try:
34 try:
35 import cProfile as profile
35 import cProfile as profile
36 import pstats
36 import pstats
37 except ImportError:
37 except ImportError:
38 # profile isn't bundled by default in Debian for license reasons
38 # profile isn't bundled by default in Debian for license reasons
39 try:
39 try:
40 import profile,pstats
40 import profile,pstats
41 except ImportError:
41 except ImportError:
42 profile = pstats = None
42 profile = pstats = None
43
43
44 # Homebrewed
44 # Homebrewed
45 import IPython
45 import IPython
46 from IPython import OInspect, wildcard
46 from IPython import OInspect, wildcard
47 from IPython.core import debugger
47 from IPython.core import debugger
48 from IPython.core.fakemodule import FakeModule
48 from IPython.core.fakemodule import FakeModule
49 from IPython.Itpl import Itpl, itpl, printpl,itplns
49 from IPython.Itpl import Itpl, itpl, printpl,itplns
50 from IPython.PyColorize import Parser
50 from IPython.PyColorize import Parser
51 from IPython.ipstruct import Struct
51 from IPython.ipstruct import Struct
52 from IPython.macro import Macro
52 from IPython.macro import Macro
53 from IPython.genutils import *
53 from IPython.utils.genutils import *
54 from IPython import platutils
54 from IPython import platutils
55 import IPython.utils.generics
55 import IPython.utils.generics
56 import IPython.ipapi
56 import IPython.ipapi
57 from IPython.ipapi import UsageError
57 from IPython.ipapi import UsageError
58 from IPython.testing import decorators as testdec
58 from IPython.testing import decorators as testdec
59
59
60 #***************************************************************************
60 #***************************************************************************
61 # Utility functions
61 # Utility functions
62 def on_off(tag):
62 def on_off(tag):
63 """Return an ON/OFF string for a 1/0 input. Simple utility function."""
63 """Return an ON/OFF string for a 1/0 input. Simple utility function."""
64 return ['OFF','ON'][tag]
64 return ['OFF','ON'][tag]
65
65
66 class Bunch: pass
66 class Bunch: pass
67
67
68 def compress_dhist(dh):
68 def compress_dhist(dh):
69 head, tail = dh[:-10], dh[-10:]
69 head, tail = dh[:-10], dh[-10:]
70
70
71 newhead = []
71 newhead = []
72 done = set()
72 done = set()
73 for h in head:
73 for h in head:
74 if h in done:
74 if h in done:
75 continue
75 continue
76 newhead.append(h)
76 newhead.append(h)
77 done.add(h)
77 done.add(h)
78
78
79 return newhead + tail
79 return newhead + tail
80
80
81
81
82 #***************************************************************************
82 #***************************************************************************
83 # Main class implementing Magic functionality
83 # Main class implementing Magic functionality
84 class Magic:
84 class Magic:
85 """Magic functions for InteractiveShell.
85 """Magic functions for InteractiveShell.
86
86
87 Shell functions which can be reached as %function_name. All magic
87 Shell functions which can be reached as %function_name. All magic
88 functions should accept a string, which they can parse for their own
88 functions should accept a string, which they can parse for their own
89 needs. This can make some functions easier to type, eg `%cd ../`
89 needs. This can make some functions easier to type, eg `%cd ../`
90 vs. `%cd("../")`
90 vs. `%cd("../")`
91
91
92 ALL definitions MUST begin with the prefix magic_. The user won't need it
92 ALL definitions MUST begin with the prefix magic_. The user won't need it
93 at the command line, but it is is needed in the definition. """
93 at the command line, but it is is needed in the definition. """
94
94
95 # class globals
95 # class globals
96 auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',
96 auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',
97 'Automagic is ON, % prefix NOT needed for magic functions.']
97 'Automagic is ON, % prefix NOT needed for magic functions.']
98
98
99 #......................................................................
99 #......................................................................
100 # some utility functions
100 # some utility functions
101
101
102 def __init__(self,shell):
102 def __init__(self,shell):
103
103
104 self.options_table = {}
104 self.options_table = {}
105 if profile is None:
105 if profile is None:
106 self.magic_prun = self.profile_missing_notice
106 self.magic_prun = self.profile_missing_notice
107 self.shell = shell
107 self.shell = shell
108
108
109 # namespace for holding state we may need
109 # namespace for holding state we may need
110 self._magic_state = Bunch()
110 self._magic_state = Bunch()
111
111
112 def profile_missing_notice(self, *args, **kwargs):
112 def profile_missing_notice(self, *args, **kwargs):
113 error("""\
113 error("""\
114 The profile module could not be found. It has been removed from the standard
114 The profile module could not be found. It has been removed from the standard
115 python packages because of its non-free license. To use profiling, install the
115 python packages because of its non-free license. To use profiling, install the
116 python-profiler package from non-free.""")
116 python-profiler package from non-free.""")
117
117
118 def default_option(self,fn,optstr):
118 def default_option(self,fn,optstr):
119 """Make an entry in the options_table for fn, with value optstr"""
119 """Make an entry in the options_table for fn, with value optstr"""
120
120
121 if fn not in self.lsmagic():
121 if fn not in self.lsmagic():
122 error("%s is not a magic function" % fn)
122 error("%s is not a magic function" % fn)
123 self.options_table[fn] = optstr
123 self.options_table[fn] = optstr
124
124
125 def lsmagic(self):
125 def lsmagic(self):
126 """Return a list of currently available magic functions.
126 """Return a list of currently available magic functions.
127
127
128 Gives a list of the bare names after mangling (['ls','cd', ...], not
128 Gives a list of the bare names after mangling (['ls','cd', ...], not
129 ['magic_ls','magic_cd',...]"""
129 ['magic_ls','magic_cd',...]"""
130
130
131 # FIXME. This needs a cleanup, in the way the magics list is built.
131 # FIXME. This needs a cleanup, in the way the magics list is built.
132
132
133 # magics in class definition
133 # magics in class definition
134 class_magic = lambda fn: fn.startswith('magic_') and \
134 class_magic = lambda fn: fn.startswith('magic_') and \
135 callable(Magic.__dict__[fn])
135 callable(Magic.__dict__[fn])
136 # in instance namespace (run-time user additions)
136 # in instance namespace (run-time user additions)
137 inst_magic = lambda fn: fn.startswith('magic_') and \
137 inst_magic = lambda fn: fn.startswith('magic_') and \
138 callable(self.__dict__[fn])
138 callable(self.__dict__[fn])
139 # and bound magics by user (so they can access self):
139 # and bound magics by user (so they can access self):
140 inst_bound_magic = lambda fn: fn.startswith('magic_') and \
140 inst_bound_magic = lambda fn: fn.startswith('magic_') and \
141 callable(self.__class__.__dict__[fn])
141 callable(self.__class__.__dict__[fn])
142 magics = filter(class_magic,Magic.__dict__.keys()) + \
142 magics = filter(class_magic,Magic.__dict__.keys()) + \
143 filter(inst_magic,self.__dict__.keys()) + \
143 filter(inst_magic,self.__dict__.keys()) + \
144 filter(inst_bound_magic,self.__class__.__dict__.keys())
144 filter(inst_bound_magic,self.__class__.__dict__.keys())
145 out = []
145 out = []
146 for fn in set(magics):
146 for fn in set(magics):
147 out.append(fn.replace('magic_','',1))
147 out.append(fn.replace('magic_','',1))
148 out.sort()
148 out.sort()
149 return out
149 return out
150
150
151 def extract_input_slices(self,slices,raw=False):
151 def extract_input_slices(self,slices,raw=False):
152 """Return as a string a set of input history slices.
152 """Return as a string a set of input history slices.
153
153
154 Inputs:
154 Inputs:
155
155
156 - slices: the set of slices is given as a list of strings (like
156 - slices: the set of slices is given as a list of strings (like
157 ['1','4:8','9'], since this function is for use by magic functions
157 ['1','4:8','9'], since this function is for use by magic functions
158 which get their arguments as strings.
158 which get their arguments as strings.
159
159
160 Optional inputs:
160 Optional inputs:
161
161
162 - raw(False): by default, the processed input is used. If this is
162 - raw(False): by default, the processed input is used. If this is
163 true, the raw input history is used instead.
163 true, the raw input history is used instead.
164
164
165 Note that slices can be called with two notations:
165 Note that slices can be called with two notations:
166
166
167 N:M -> standard python form, means including items N...(M-1).
167 N:M -> standard python form, means including items N...(M-1).
168
168
169 N-M -> include items N..M (closed endpoint)."""
169 N-M -> include items N..M (closed endpoint)."""
170
170
171 if raw:
171 if raw:
172 hist = self.shell.input_hist_raw
172 hist = self.shell.input_hist_raw
173 else:
173 else:
174 hist = self.shell.input_hist
174 hist = self.shell.input_hist
175
175
176 cmds = []
176 cmds = []
177 for chunk in slices:
177 for chunk in slices:
178 if ':' in chunk:
178 if ':' in chunk:
179 ini,fin = map(int,chunk.split(':'))
179 ini,fin = map(int,chunk.split(':'))
180 elif '-' in chunk:
180 elif '-' in chunk:
181 ini,fin = map(int,chunk.split('-'))
181 ini,fin = map(int,chunk.split('-'))
182 fin += 1
182 fin += 1
183 else:
183 else:
184 ini = int(chunk)
184 ini = int(chunk)
185 fin = ini+1
185 fin = ini+1
186 cmds.append(hist[ini:fin])
186 cmds.append(hist[ini:fin])
187 return cmds
187 return cmds
188
188
189 def _ofind(self, oname, namespaces=None):
189 def _ofind(self, oname, namespaces=None):
190 """Find an object in the available namespaces.
190 """Find an object in the available namespaces.
191
191
192 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
192 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
193
193
194 Has special code to detect magic functions.
194 Has special code to detect magic functions.
195 """
195 """
196
196
197 oname = oname.strip()
197 oname = oname.strip()
198
198
199 alias_ns = None
199 alias_ns = None
200 if namespaces is None:
200 if namespaces is None:
201 # Namespaces to search in:
201 # Namespaces to search in:
202 # Put them in a list. The order is important so that we
202 # Put them in a list. The order is important so that we
203 # find things in the same order that Python finds them.
203 # find things in the same order that Python finds them.
204 namespaces = [ ('Interactive', self.shell.user_ns),
204 namespaces = [ ('Interactive', self.shell.user_ns),
205 ('IPython internal', self.shell.internal_ns),
205 ('IPython internal', self.shell.internal_ns),
206 ('Python builtin', __builtin__.__dict__),
206 ('Python builtin', __builtin__.__dict__),
207 ('Alias', self.shell.alias_table),
207 ('Alias', self.shell.alias_table),
208 ]
208 ]
209 alias_ns = self.shell.alias_table
209 alias_ns = self.shell.alias_table
210
210
211 # initialize results to 'null'
211 # initialize results to 'null'
212 found = 0; obj = None; ospace = None; ds = None;
212 found = 0; obj = None; ospace = None; ds = None;
213 ismagic = 0; isalias = 0; parent = None
213 ismagic = 0; isalias = 0; parent = None
214
214
215 # Look for the given name by splitting it in parts. If the head is
215 # Look for the given name by splitting it in parts. If the head is
216 # found, then we look for all the remaining parts as members, and only
216 # found, then we look for all the remaining parts as members, and only
217 # declare success if we can find them all.
217 # declare success if we can find them all.
218 oname_parts = oname.split('.')
218 oname_parts = oname.split('.')
219 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
219 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
220 for nsname,ns in namespaces:
220 for nsname,ns in namespaces:
221 try:
221 try:
222 obj = ns[oname_head]
222 obj = ns[oname_head]
223 except KeyError:
223 except KeyError:
224 continue
224 continue
225 else:
225 else:
226 #print 'oname_rest:', oname_rest # dbg
226 #print 'oname_rest:', oname_rest # dbg
227 for part in oname_rest:
227 for part in oname_rest:
228 try:
228 try:
229 parent = obj
229 parent = obj
230 obj = getattr(obj,part)
230 obj = getattr(obj,part)
231 except:
231 except:
232 # Blanket except b/c some badly implemented objects
232 # Blanket except b/c some badly implemented objects
233 # allow __getattr__ to raise exceptions other than
233 # allow __getattr__ to raise exceptions other than
234 # AttributeError, which then crashes IPython.
234 # AttributeError, which then crashes IPython.
235 break
235 break
236 else:
236 else:
237 # If we finish the for loop (no break), we got all members
237 # If we finish the for loop (no break), we got all members
238 found = 1
238 found = 1
239 ospace = nsname
239 ospace = nsname
240 if ns == alias_ns:
240 if ns == alias_ns:
241 isalias = 1
241 isalias = 1
242 break # namespace loop
242 break # namespace loop
243
243
244 # Try to see if it's magic
244 # Try to see if it's magic
245 if not found:
245 if not found:
246 if oname.startswith(self.shell.ESC_MAGIC):
246 if oname.startswith(self.shell.ESC_MAGIC):
247 oname = oname[1:]
247 oname = oname[1:]
248 obj = getattr(self,'magic_'+oname,None)
248 obj = getattr(self,'magic_'+oname,None)
249 if obj is not None:
249 if obj is not None:
250 found = 1
250 found = 1
251 ospace = 'IPython internal'
251 ospace = 'IPython internal'
252 ismagic = 1
252 ismagic = 1
253
253
254 # Last try: special-case some literals like '', [], {}, etc:
254 # Last try: special-case some literals like '', [], {}, etc:
255 if not found and oname_head in ["''",'""','[]','{}','()']:
255 if not found and oname_head in ["''",'""','[]','{}','()']:
256 obj = eval(oname_head)
256 obj = eval(oname_head)
257 found = 1
257 found = 1
258 ospace = 'Interactive'
258 ospace = 'Interactive'
259
259
260 return {'found':found, 'obj':obj, 'namespace':ospace,
260 return {'found':found, 'obj':obj, 'namespace':ospace,
261 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
261 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
262
262
263 def arg_err(self,func):
263 def arg_err(self,func):
264 """Print docstring if incorrect arguments were passed"""
264 """Print docstring if incorrect arguments were passed"""
265 print 'Error in arguments:'
265 print 'Error in arguments:'
266 print OInspect.getdoc(func)
266 print OInspect.getdoc(func)
267
267
268 def format_latex(self,strng):
268 def format_latex(self,strng):
269 """Format a string for latex inclusion."""
269 """Format a string for latex inclusion."""
270
270
271 # Characters that need to be escaped for latex:
271 # Characters that need to be escaped for latex:
272 escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
272 escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
273 # Magic command names as headers:
273 # Magic command names as headers:
274 cmd_name_re = re.compile(r'^(%s.*?):' % self.shell.ESC_MAGIC,
274 cmd_name_re = re.compile(r'^(%s.*?):' % self.shell.ESC_MAGIC,
275 re.MULTILINE)
275 re.MULTILINE)
276 # Magic commands
276 # Magic commands
277 cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % self.shell.ESC_MAGIC,
277 cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % self.shell.ESC_MAGIC,
278 re.MULTILINE)
278 re.MULTILINE)
279 # Paragraph continue
279 # Paragraph continue
280 par_re = re.compile(r'\\$',re.MULTILINE)
280 par_re = re.compile(r'\\$',re.MULTILINE)
281
281
282 # The "\n" symbol
282 # The "\n" symbol
283 newline_re = re.compile(r'\\n')
283 newline_re = re.compile(r'\\n')
284
284
285 # Now build the string for output:
285 # Now build the string for output:
286 #strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
286 #strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
287 strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',
287 strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',
288 strng)
288 strng)
289 strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
289 strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
290 strng = par_re.sub(r'\\\\',strng)
290 strng = par_re.sub(r'\\\\',strng)
291 strng = escape_re.sub(r'\\\1',strng)
291 strng = escape_re.sub(r'\\\1',strng)
292 strng = newline_re.sub(r'\\textbackslash{}n',strng)
292 strng = newline_re.sub(r'\\textbackslash{}n',strng)
293 return strng
293 return strng
294
294
295 def format_screen(self,strng):
295 def format_screen(self,strng):
296 """Format a string for screen printing.
296 """Format a string for screen printing.
297
297
298 This removes some latex-type format codes."""
298 This removes some latex-type format codes."""
299 # Paragraph continue
299 # Paragraph continue
300 par_re = re.compile(r'\\$',re.MULTILINE)
300 par_re = re.compile(r'\\$',re.MULTILINE)
301 strng = par_re.sub('',strng)
301 strng = par_re.sub('',strng)
302 return strng
302 return strng
303
303
304 def parse_options(self,arg_str,opt_str,*long_opts,**kw):
304 def parse_options(self,arg_str,opt_str,*long_opts,**kw):
305 """Parse options passed to an argument string.
305 """Parse options passed to an argument string.
306
306
307 The interface is similar to that of getopt(), but it returns back a
307 The interface is similar to that of getopt(), but it returns back a
308 Struct with the options as keys and the stripped argument string still
308 Struct with the options as keys and the stripped argument string still
309 as a string.
309 as a string.
310
310
311 arg_str is quoted as a true sys.argv vector by using shlex.split.
311 arg_str is quoted as a true sys.argv vector by using shlex.split.
312 This allows us to easily expand variables, glob files, quote
312 This allows us to easily expand variables, glob files, quote
313 arguments, etc.
313 arguments, etc.
314
314
315 Options:
315 Options:
316 -mode: default 'string'. If given as 'list', the argument string is
316 -mode: default 'string'. If given as 'list', the argument string is
317 returned as a list (split on whitespace) instead of a string.
317 returned as a list (split on whitespace) instead of a string.
318
318
319 -list_all: put all option values in lists. Normally only options
319 -list_all: put all option values in lists. Normally only options
320 appearing more than once are put in a list.
320 appearing more than once are put in a list.
321
321
322 -posix (True): whether to split the input line in POSIX mode or not,
322 -posix (True): whether to split the input line in POSIX mode or not,
323 as per the conventions outlined in the shlex module from the
323 as per the conventions outlined in the shlex module from the
324 standard library."""
324 standard library."""
325
325
326 # inject default options at the beginning of the input line
326 # inject default options at the beginning of the input line
327 caller = sys._getframe(1).f_code.co_name.replace('magic_','')
327 caller = sys._getframe(1).f_code.co_name.replace('magic_','')
328 arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
328 arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
329
329
330 mode = kw.get('mode','string')
330 mode = kw.get('mode','string')
331 if mode not in ['string','list']:
331 if mode not in ['string','list']:
332 raise ValueError,'incorrect mode given: %s' % mode
332 raise ValueError,'incorrect mode given: %s' % mode
333 # Get options
333 # Get options
334 list_all = kw.get('list_all',0)
334 list_all = kw.get('list_all',0)
335 posix = kw.get('posix',True)
335 posix = kw.get('posix',True)
336
336
337 # Check if we have more than one argument to warrant extra processing:
337 # Check if we have more than one argument to warrant extra processing:
338 odict = {} # Dictionary with options
338 odict = {} # Dictionary with options
339 args = arg_str.split()
339 args = arg_str.split()
340 if len(args) >= 1:
340 if len(args) >= 1:
341 # If the list of inputs only has 0 or 1 thing in it, there's no
341 # If the list of inputs only has 0 or 1 thing in it, there's no
342 # need to look for options
342 # need to look for options
343 argv = arg_split(arg_str,posix)
343 argv = arg_split(arg_str,posix)
344 # Do regular option processing
344 # Do regular option processing
345 try:
345 try:
346 opts,args = getopt(argv,opt_str,*long_opts)
346 opts,args = getopt(argv,opt_str,*long_opts)
347 except GetoptError,e:
347 except GetoptError,e:
348 raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str,
348 raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str,
349 " ".join(long_opts)))
349 " ".join(long_opts)))
350 for o,a in opts:
350 for o,a in opts:
351 if o.startswith('--'):
351 if o.startswith('--'):
352 o = o[2:]
352 o = o[2:]
353 else:
353 else:
354 o = o[1:]
354 o = o[1:]
355 try:
355 try:
356 odict[o].append(a)
356 odict[o].append(a)
357 except AttributeError:
357 except AttributeError:
358 odict[o] = [odict[o],a]
358 odict[o] = [odict[o],a]
359 except KeyError:
359 except KeyError:
360 if list_all:
360 if list_all:
361 odict[o] = [a]
361 odict[o] = [a]
362 else:
362 else:
363 odict[o] = a
363 odict[o] = a
364
364
365 # Prepare opts,args for return
365 # Prepare opts,args for return
366 opts = Struct(odict)
366 opts = Struct(odict)
367 if mode == 'string':
367 if mode == 'string':
368 args = ' '.join(args)
368 args = ' '.join(args)
369
369
370 return opts,args
370 return opts,args
371
371
372 #......................................................................
372 #......................................................................
373 # And now the actual magic functions
373 # And now the actual magic functions
374
374
375 # Functions for IPython shell work (vars,funcs, config, etc)
375 # Functions for IPython shell work (vars,funcs, config, etc)
376 def magic_lsmagic(self, parameter_s = ''):
376 def magic_lsmagic(self, parameter_s = ''):
377 """List currently available magic functions."""
377 """List currently available magic functions."""
378 mesc = self.shell.ESC_MAGIC
378 mesc = self.shell.ESC_MAGIC
379 print 'Available magic functions:\n'+mesc+\
379 print 'Available magic functions:\n'+mesc+\
380 (' '+mesc).join(self.lsmagic())
380 (' '+mesc).join(self.lsmagic())
381 print '\n' + Magic.auto_status[self.shell.rc.automagic]
381 print '\n' + Magic.auto_status[self.shell.rc.automagic]
382 return None
382 return None
383
383
384 def magic_magic(self, parameter_s = ''):
384 def magic_magic(self, parameter_s = ''):
385 """Print information about the magic function system.
385 """Print information about the magic function system.
386
386
387 Supported formats: -latex, -brief, -rest
387 Supported formats: -latex, -brief, -rest
388 """
388 """
389
389
390 mode = ''
390 mode = ''
391 try:
391 try:
392 if parameter_s.split()[0] == '-latex':
392 if parameter_s.split()[0] == '-latex':
393 mode = 'latex'
393 mode = 'latex'
394 if parameter_s.split()[0] == '-brief':
394 if parameter_s.split()[0] == '-brief':
395 mode = 'brief'
395 mode = 'brief'
396 if parameter_s.split()[0] == '-rest':
396 if parameter_s.split()[0] == '-rest':
397 mode = 'rest'
397 mode = 'rest'
398 rest_docs = []
398 rest_docs = []
399 except:
399 except:
400 pass
400 pass
401
401
402 magic_docs = []
402 magic_docs = []
403 for fname in self.lsmagic():
403 for fname in self.lsmagic():
404 mname = 'magic_' + fname
404 mname = 'magic_' + fname
405 for space in (Magic,self,self.__class__):
405 for space in (Magic,self,self.__class__):
406 try:
406 try:
407 fn = space.__dict__[mname]
407 fn = space.__dict__[mname]
408 except KeyError:
408 except KeyError:
409 pass
409 pass
410 else:
410 else:
411 break
411 break
412 if mode == 'brief':
412 if mode == 'brief':
413 # only first line
413 # only first line
414 if fn.__doc__:
414 if fn.__doc__:
415 fndoc = fn.__doc__.split('\n',1)[0]
415 fndoc = fn.__doc__.split('\n',1)[0]
416 else:
416 else:
417 fndoc = 'No documentation'
417 fndoc = 'No documentation'
418 else:
418 else:
419 if fn.__doc__:
419 if fn.__doc__:
420 fndoc = fn.__doc__.rstrip()
420 fndoc = fn.__doc__.rstrip()
421 else:
421 else:
422 fndoc = 'No documentation'
422 fndoc = 'No documentation'
423
423
424
424
425 if mode == 'rest':
425 if mode == 'rest':
426 rest_docs.append('**%s%s**::\n\n\t%s\n\n' %(self.shell.ESC_MAGIC,
426 rest_docs.append('**%s%s**::\n\n\t%s\n\n' %(self.shell.ESC_MAGIC,
427 fname,fndoc))
427 fname,fndoc))
428
428
429 else:
429 else:
430 magic_docs.append('%s%s:\n\t%s\n' %(self.shell.ESC_MAGIC,
430 magic_docs.append('%s%s:\n\t%s\n' %(self.shell.ESC_MAGIC,
431 fname,fndoc))
431 fname,fndoc))
432
432
433 magic_docs = ''.join(magic_docs)
433 magic_docs = ''.join(magic_docs)
434
434
435 if mode == 'rest':
435 if mode == 'rest':
436 return "".join(rest_docs)
436 return "".join(rest_docs)
437
437
438 if mode == 'latex':
438 if mode == 'latex':
439 print self.format_latex(magic_docs)
439 print self.format_latex(magic_docs)
440 return
440 return
441 else:
441 else:
442 magic_docs = self.format_screen(magic_docs)
442 magic_docs = self.format_screen(magic_docs)
443 if mode == 'brief':
443 if mode == 'brief':
444 return magic_docs
444 return magic_docs
445
445
446 outmsg = """
446 outmsg = """
447 IPython's 'magic' functions
447 IPython's 'magic' functions
448 ===========================
448 ===========================
449
449
450 The magic function system provides a series of functions which allow you to
450 The magic function system provides a series of functions which allow you to
451 control the behavior of IPython itself, plus a lot of system-type
451 control the behavior of IPython itself, plus a lot of system-type
452 features. All these functions are prefixed with a % character, but parameters
452 features. All these functions are prefixed with a % character, but parameters
453 are given without parentheses or quotes.
453 are given without parentheses or quotes.
454
454
455 NOTE: If you have 'automagic' enabled (via the command line option or with the
455 NOTE: If you have 'automagic' enabled (via the command line option or with the
456 %automagic function), you don't need to type in the % explicitly. By default,
456 %automagic function), you don't need to type in the % explicitly. By default,
457 IPython ships with automagic on, so you should only rarely need the % escape.
457 IPython ships with automagic on, so you should only rarely need the % escape.
458
458
459 Example: typing '%cd mydir' (without the quotes) changes you working directory
459 Example: typing '%cd mydir' (without the quotes) changes you working directory
460 to 'mydir', if it exists.
460 to 'mydir', if it exists.
461
461
462 You can define your own magic functions to extend the system. See the supplied
462 You can define your own magic functions to extend the system. See the supplied
463 ipythonrc and example-magic.py files for details (in your ipython
463 ipythonrc and example-magic.py files for details (in your ipython
464 configuration directory, typically $HOME/.ipython/).
464 configuration directory, typically $HOME/.ipython/).
465
465
466 You can also define your own aliased names for magic functions. In your
466 You can also define your own aliased names for magic functions. In your
467 ipythonrc file, placing a line like:
467 ipythonrc file, placing a line like:
468
468
469 execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
469 execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
470
470
471 will define %pf as a new name for %profile.
471 will define %pf as a new name for %profile.
472
472
473 You can also call magics in code using the ipmagic() function, which IPython
473 You can also call magics in code using the ipmagic() function, which IPython
474 automatically adds to the builtin namespace. Type 'ipmagic?' for details.
474 automatically adds to the builtin namespace. Type 'ipmagic?' for details.
475
475
476 For a list of the available magic functions, use %lsmagic. For a description
476 For a list of the available magic functions, use %lsmagic. For a description
477 of any of them, type %magic_name?, e.g. '%cd?'.
477 of any of them, type %magic_name?, e.g. '%cd?'.
478
478
479 Currently the magic system has the following functions:\n"""
479 Currently the magic system has the following functions:\n"""
480
480
481 mesc = self.shell.ESC_MAGIC
481 mesc = self.shell.ESC_MAGIC
482 outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
482 outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
483 "\n\n%s%s\n\n%s" % (outmsg,
483 "\n\n%s%s\n\n%s" % (outmsg,
484 magic_docs,mesc,mesc,
484 magic_docs,mesc,mesc,
485 (' '+mesc).join(self.lsmagic()),
485 (' '+mesc).join(self.lsmagic()),
486 Magic.auto_status[self.shell.rc.automagic] ) )
486 Magic.auto_status[self.shell.rc.automagic] ) )
487
487
488 page(outmsg,screen_lines=self.shell.rc.screen_length)
488 page(outmsg,screen_lines=self.shell.rc.screen_length)
489
489
490
490
491 def magic_autoindent(self, parameter_s = ''):
491 def magic_autoindent(self, parameter_s = ''):
492 """Toggle autoindent on/off (if available)."""
492 """Toggle autoindent on/off (if available)."""
493
493
494 self.shell.set_autoindent()
494 self.shell.set_autoindent()
495 print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
495 print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
496
496
497
497
498 def magic_automagic(self, parameter_s = ''):
498 def magic_automagic(self, parameter_s = ''):
499 """Make magic functions callable without having to type the initial %.
499 """Make magic functions callable without having to type the initial %.
500
500
501 Without argumentsl toggles on/off (when off, you must call it as
501 Without argumentsl toggles on/off (when off, you must call it as
502 %automagic, of course). With arguments it sets the value, and you can
502 %automagic, of course). With arguments it sets the value, and you can
503 use any of (case insensitive):
503 use any of (case insensitive):
504
504
505 - on,1,True: to activate
505 - on,1,True: to activate
506
506
507 - off,0,False: to deactivate.
507 - off,0,False: to deactivate.
508
508
509 Note that magic functions have lowest priority, so if there's a
509 Note that magic functions have lowest priority, so if there's a
510 variable whose name collides with that of a magic fn, automagic won't
510 variable whose name collides with that of a magic fn, automagic won't
511 work for that function (you get the variable instead). However, if you
511 work for that function (you get the variable instead). However, if you
512 delete the variable (del var), the previously shadowed magic function
512 delete the variable (del var), the previously shadowed magic function
513 becomes visible to automagic again."""
513 becomes visible to automagic again."""
514
514
515 rc = self.shell.rc
515 rc = self.shell.rc
516 arg = parameter_s.lower()
516 arg = parameter_s.lower()
517 if parameter_s in ('on','1','true'):
517 if parameter_s in ('on','1','true'):
518 rc.automagic = True
518 rc.automagic = True
519 elif parameter_s in ('off','0','false'):
519 elif parameter_s in ('off','0','false'):
520 rc.automagic = False
520 rc.automagic = False
521 else:
521 else:
522 rc.automagic = not rc.automagic
522 rc.automagic = not rc.automagic
523 print '\n' + Magic.auto_status[rc.automagic]
523 print '\n' + Magic.auto_status[rc.automagic]
524
524
525 @testdec.skip_doctest
525 @testdec.skip_doctest
526 def magic_autocall(self, parameter_s = ''):
526 def magic_autocall(self, parameter_s = ''):
527 """Make functions callable without having to type parentheses.
527 """Make functions callable without having to type parentheses.
528
528
529 Usage:
529 Usage:
530
530
531 %autocall [mode]
531 %autocall [mode]
532
532
533 The mode can be one of: 0->Off, 1->Smart, 2->Full. If not given, the
533 The mode can be one of: 0->Off, 1->Smart, 2->Full. If not given, the
534 value is toggled on and off (remembering the previous state).
534 value is toggled on and off (remembering the previous state).
535
535
536 In more detail, these values mean:
536 In more detail, these values mean:
537
537
538 0 -> fully disabled
538 0 -> fully disabled
539
539
540 1 -> active, but do not apply if there are no arguments on the line.
540 1 -> active, but do not apply if there are no arguments on the line.
541
541
542 In this mode, you get:
542 In this mode, you get:
543
543
544 In [1]: callable
544 In [1]: callable
545 Out[1]: <built-in function callable>
545 Out[1]: <built-in function callable>
546
546
547 In [2]: callable 'hello'
547 In [2]: callable 'hello'
548 ------> callable('hello')
548 ------> callable('hello')
549 Out[2]: False
549 Out[2]: False
550
550
551 2 -> Active always. Even if no arguments are present, the callable
551 2 -> Active always. Even if no arguments are present, the callable
552 object is called:
552 object is called:
553
553
554 In [2]: float
554 In [2]: float
555 ------> float()
555 ------> float()
556 Out[2]: 0.0
556 Out[2]: 0.0
557
557
558 Note that even with autocall off, you can still use '/' at the start of
558 Note that even with autocall off, you can still use '/' at the start of
559 a line to treat the first argument on the command line as a function
559 a line to treat the first argument on the command line as a function
560 and add parentheses to it:
560 and add parentheses to it:
561
561
562 In [8]: /str 43
562 In [8]: /str 43
563 ------> str(43)
563 ------> str(43)
564 Out[8]: '43'
564 Out[8]: '43'
565
565
566 # all-random (note for auto-testing)
566 # all-random (note for auto-testing)
567 """
567 """
568
568
569 rc = self.shell.rc
569 rc = self.shell.rc
570
570
571 if parameter_s:
571 if parameter_s:
572 arg = int(parameter_s)
572 arg = int(parameter_s)
573 else:
573 else:
574 arg = 'toggle'
574 arg = 'toggle'
575
575
576 if not arg in (0,1,2,'toggle'):
576 if not arg in (0,1,2,'toggle'):
577 error('Valid modes: (0->Off, 1->Smart, 2->Full')
577 error('Valid modes: (0->Off, 1->Smart, 2->Full')
578 return
578 return
579
579
580 if arg in (0,1,2):
580 if arg in (0,1,2):
581 rc.autocall = arg
581 rc.autocall = arg
582 else: # toggle
582 else: # toggle
583 if rc.autocall:
583 if rc.autocall:
584 self._magic_state.autocall_save = rc.autocall
584 self._magic_state.autocall_save = rc.autocall
585 rc.autocall = 0
585 rc.autocall = 0
586 else:
586 else:
587 try:
587 try:
588 rc.autocall = self._magic_state.autocall_save
588 rc.autocall = self._magic_state.autocall_save
589 except AttributeError:
589 except AttributeError:
590 rc.autocall = self._magic_state.autocall_save = 1
590 rc.autocall = self._magic_state.autocall_save = 1
591
591
592 print "Automatic calling is:",['OFF','Smart','Full'][rc.autocall]
592 print "Automatic calling is:",['OFF','Smart','Full'][rc.autocall]
593
593
594 def magic_system_verbose(self, parameter_s = ''):
594 def magic_system_verbose(self, parameter_s = ''):
595 """Set verbose printing of system calls.
595 """Set verbose printing of system calls.
596
596
597 If called without an argument, act as a toggle"""
597 If called without an argument, act as a toggle"""
598
598
599 if parameter_s:
599 if parameter_s:
600 val = bool(eval(parameter_s))
600 val = bool(eval(parameter_s))
601 else:
601 else:
602 val = None
602 val = None
603
603
604 self.shell.rc_set_toggle('system_verbose',val)
604 self.shell.rc_set_toggle('system_verbose',val)
605 print "System verbose printing is:",\
605 print "System verbose printing is:",\
606 ['OFF','ON'][self.shell.rc.system_verbose]
606 ['OFF','ON'][self.shell.rc.system_verbose]
607
607
608
608
609 def magic_page(self, parameter_s=''):
609 def magic_page(self, parameter_s=''):
610 """Pretty print the object and display it through a pager.
610 """Pretty print the object and display it through a pager.
611
611
612 %page [options] OBJECT
612 %page [options] OBJECT
613
613
614 If no object is given, use _ (last output).
614 If no object is given, use _ (last output).
615
615
616 Options:
616 Options:
617
617
618 -r: page str(object), don't pretty-print it."""
618 -r: page str(object), don't pretty-print it."""
619
619
620 # After a function contributed by Olivier Aubert, slightly modified.
620 # After a function contributed by Olivier Aubert, slightly modified.
621
621
622 # Process options/args
622 # Process options/args
623 opts,args = self.parse_options(parameter_s,'r')
623 opts,args = self.parse_options(parameter_s,'r')
624 raw = 'r' in opts
624 raw = 'r' in opts
625
625
626 oname = args and args or '_'
626 oname = args and args or '_'
627 info = self._ofind(oname)
627 info = self._ofind(oname)
628 if info['found']:
628 if info['found']:
629 txt = (raw and str or pformat)( info['obj'] )
629 txt = (raw and str or pformat)( info['obj'] )
630 page(txt)
630 page(txt)
631 else:
631 else:
632 print 'Object `%s` not found' % oname
632 print 'Object `%s` not found' % oname
633
633
634 def magic_profile(self, parameter_s=''):
634 def magic_profile(self, parameter_s=''):
635 """Print your currently active IPyhton profile."""
635 """Print your currently active IPyhton profile."""
636 if self.shell.rc.profile:
636 if self.shell.rc.profile:
637 printpl('Current IPython profile: $self.shell.rc.profile.')
637 printpl('Current IPython profile: $self.shell.rc.profile.')
638 else:
638 else:
639 print 'No profile active.'
639 print 'No profile active.'
640
640
641 def magic_pinfo(self, parameter_s='', namespaces=None):
641 def magic_pinfo(self, parameter_s='', namespaces=None):
642 """Provide detailed information about an object.
642 """Provide detailed information about an object.
643
643
644 '%pinfo object' is just a synonym for object? or ?object."""
644 '%pinfo object' is just a synonym for object? or ?object."""
645
645
646 #print 'pinfo par: <%s>' % parameter_s # dbg
646 #print 'pinfo par: <%s>' % parameter_s # dbg
647
647
648
648
649 # detail_level: 0 -> obj? , 1 -> obj??
649 # detail_level: 0 -> obj? , 1 -> obj??
650 detail_level = 0
650 detail_level = 0
651 # We need to detect if we got called as 'pinfo pinfo foo', which can
651 # We need to detect if we got called as 'pinfo pinfo foo', which can
652 # happen if the user types 'pinfo foo?' at the cmd line.
652 # happen if the user types 'pinfo foo?' at the cmd line.
653 pinfo,qmark1,oname,qmark2 = \
653 pinfo,qmark1,oname,qmark2 = \
654 re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
654 re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
655 if pinfo or qmark1 or qmark2:
655 if pinfo or qmark1 or qmark2:
656 detail_level = 1
656 detail_level = 1
657 if "*" in oname:
657 if "*" in oname:
658 self.magic_psearch(oname)
658 self.magic_psearch(oname)
659 else:
659 else:
660 self._inspect('pinfo', oname, detail_level=detail_level,
660 self._inspect('pinfo', oname, detail_level=detail_level,
661 namespaces=namespaces)
661 namespaces=namespaces)
662
662
663 def magic_pdef(self, parameter_s='', namespaces=None):
663 def magic_pdef(self, parameter_s='', namespaces=None):
664 """Print the definition header for any callable object.
664 """Print the definition header for any callable object.
665
665
666 If the object is a class, print the constructor information."""
666 If the object is a class, print the constructor information."""
667 self._inspect('pdef',parameter_s, namespaces)
667 self._inspect('pdef',parameter_s, namespaces)
668
668
669 def magic_pdoc(self, parameter_s='', namespaces=None):
669 def magic_pdoc(self, parameter_s='', namespaces=None):
670 """Print the docstring for an object.
670 """Print the docstring for an object.
671
671
672 If the given object is a class, it will print both the class and the
672 If the given object is a class, it will print both the class and the
673 constructor docstrings."""
673 constructor docstrings."""
674 self._inspect('pdoc',parameter_s, namespaces)
674 self._inspect('pdoc',parameter_s, namespaces)
675
675
676 def magic_psource(self, parameter_s='', namespaces=None):
676 def magic_psource(self, parameter_s='', namespaces=None):
677 """Print (or run through pager) the source code for an object."""
677 """Print (or run through pager) the source code for an object."""
678 self._inspect('psource',parameter_s, namespaces)
678 self._inspect('psource',parameter_s, namespaces)
679
679
680 def magic_pfile(self, parameter_s=''):
680 def magic_pfile(self, parameter_s=''):
681 """Print (or run through pager) the file where an object is defined.
681 """Print (or run through pager) the file where an object is defined.
682
682
683 The file opens at the line where the object definition begins. IPython
683 The file opens at the line where the object definition begins. IPython
684 will honor the environment variable PAGER if set, and otherwise will
684 will honor the environment variable PAGER if set, and otherwise will
685 do its best to print the file in a convenient form.
685 do its best to print the file in a convenient form.
686
686
687 If the given argument is not an object currently defined, IPython will
687 If the given argument is not an object currently defined, IPython will
688 try to interpret it as a filename (automatically adding a .py extension
688 try to interpret it as a filename (automatically adding a .py extension
689 if needed). You can thus use %pfile as a syntax highlighting code
689 if needed). You can thus use %pfile as a syntax highlighting code
690 viewer."""
690 viewer."""
691
691
692 # first interpret argument as an object name
692 # first interpret argument as an object name
693 out = self._inspect('pfile',parameter_s)
693 out = self._inspect('pfile',parameter_s)
694 # if not, try the input as a filename
694 # if not, try the input as a filename
695 if out == 'not found':
695 if out == 'not found':
696 try:
696 try:
697 filename = get_py_filename(parameter_s)
697 filename = get_py_filename(parameter_s)
698 except IOError,msg:
698 except IOError,msg:
699 print msg
699 print msg
700 return
700 return
701 page(self.shell.inspector.format(file(filename).read()))
701 page(self.shell.inspector.format(file(filename).read()))
702
702
703 def _inspect(self,meth,oname,namespaces=None,**kw):
703 def _inspect(self,meth,oname,namespaces=None,**kw):
704 """Generic interface to the inspector system.
704 """Generic interface to the inspector system.
705
705
706 This function is meant to be called by pdef, pdoc & friends."""
706 This function is meant to be called by pdef, pdoc & friends."""
707
707
708 #oname = oname.strip()
708 #oname = oname.strip()
709 #print '1- oname: <%r>' % oname # dbg
709 #print '1- oname: <%r>' % oname # dbg
710 try:
710 try:
711 oname = oname.strip().encode('ascii')
711 oname = oname.strip().encode('ascii')
712 #print '2- oname: <%r>' % oname # dbg
712 #print '2- oname: <%r>' % oname # dbg
713 except UnicodeEncodeError:
713 except UnicodeEncodeError:
714 print 'Python identifiers can only contain ascii characters.'
714 print 'Python identifiers can only contain ascii characters.'
715 return 'not found'
715 return 'not found'
716
716
717 info = Struct(self._ofind(oname, namespaces))
717 info = Struct(self._ofind(oname, namespaces))
718
718
719 if info.found:
719 if info.found:
720 try:
720 try:
721 IPython.utils.generics.inspect_object(info.obj)
721 IPython.utils.generics.inspect_object(info.obj)
722 return
722 return
723 except IPython.ipapi.TryNext:
723 except IPython.ipapi.TryNext:
724 pass
724 pass
725 # Get the docstring of the class property if it exists.
725 # Get the docstring of the class property if it exists.
726 path = oname.split('.')
726 path = oname.split('.')
727 root = '.'.join(path[:-1])
727 root = '.'.join(path[:-1])
728 if info.parent is not None:
728 if info.parent is not None:
729 try:
729 try:
730 target = getattr(info.parent, '__class__')
730 target = getattr(info.parent, '__class__')
731 # The object belongs to a class instance.
731 # The object belongs to a class instance.
732 try:
732 try:
733 target = getattr(target, path[-1])
733 target = getattr(target, path[-1])
734 # The class defines the object.
734 # The class defines the object.
735 if isinstance(target, property):
735 if isinstance(target, property):
736 oname = root + '.__class__.' + path[-1]
736 oname = root + '.__class__.' + path[-1]
737 info = Struct(self._ofind(oname))
737 info = Struct(self._ofind(oname))
738 except AttributeError: pass
738 except AttributeError: pass
739 except AttributeError: pass
739 except AttributeError: pass
740
740
741 pmethod = getattr(self.shell.inspector,meth)
741 pmethod = getattr(self.shell.inspector,meth)
742 formatter = info.ismagic and self.format_screen or None
742 formatter = info.ismagic and self.format_screen or None
743 if meth == 'pdoc':
743 if meth == 'pdoc':
744 pmethod(info.obj,oname,formatter)
744 pmethod(info.obj,oname,formatter)
745 elif meth == 'pinfo':
745 elif meth == 'pinfo':
746 pmethod(info.obj,oname,formatter,info,**kw)
746 pmethod(info.obj,oname,formatter,info,**kw)
747 else:
747 else:
748 pmethod(info.obj,oname)
748 pmethod(info.obj,oname)
749 else:
749 else:
750 print 'Object `%s` not found.' % oname
750 print 'Object `%s` not found.' % oname
751 return 'not found' # so callers can take other action
751 return 'not found' # so callers can take other action
752
752
753 def magic_psearch(self, parameter_s=''):
753 def magic_psearch(self, parameter_s=''):
754 """Search for object in namespaces by wildcard.
754 """Search for object in namespaces by wildcard.
755
755
756 %psearch [options] PATTERN [OBJECT TYPE]
756 %psearch [options] PATTERN [OBJECT TYPE]
757
757
758 Note: ? can be used as a synonym for %psearch, at the beginning or at
758 Note: ? can be used as a synonym for %psearch, at the beginning or at
759 the end: both a*? and ?a* are equivalent to '%psearch a*'. Still, the
759 the end: both a*? and ?a* are equivalent to '%psearch a*'. Still, the
760 rest of the command line must be unchanged (options come first), so
760 rest of the command line must be unchanged (options come first), so
761 for example the following forms are equivalent
761 for example the following forms are equivalent
762
762
763 %psearch -i a* function
763 %psearch -i a* function
764 -i a* function?
764 -i a* function?
765 ?-i a* function
765 ?-i a* function
766
766
767 Arguments:
767 Arguments:
768
768
769 PATTERN
769 PATTERN
770
770
771 where PATTERN is a string containing * as a wildcard similar to its
771 where PATTERN is a string containing * as a wildcard similar to its
772 use in a shell. The pattern is matched in all namespaces on the
772 use in a shell. The pattern is matched in all namespaces on the
773 search path. By default objects starting with a single _ are not
773 search path. By default objects starting with a single _ are not
774 matched, many IPython generated objects have a single
774 matched, many IPython generated objects have a single
775 underscore. The default is case insensitive matching. Matching is
775 underscore. The default is case insensitive matching. Matching is
776 also done on the attributes of objects and not only on the objects
776 also done on the attributes of objects and not only on the objects
777 in a module.
777 in a module.
778
778
779 [OBJECT TYPE]
779 [OBJECT TYPE]
780
780
781 Is the name of a python type from the types module. The name is
781 Is the name of a python type from the types module. The name is
782 given in lowercase without the ending type, ex. StringType is
782 given in lowercase without the ending type, ex. StringType is
783 written string. By adding a type here only objects matching the
783 written string. By adding a type here only objects matching the
784 given type are matched. Using all here makes the pattern match all
784 given type are matched. Using all here makes the pattern match all
785 types (this is the default).
785 types (this is the default).
786
786
787 Options:
787 Options:
788
788
789 -a: makes the pattern match even objects whose names start with a
789 -a: makes the pattern match even objects whose names start with a
790 single underscore. These names are normally ommitted from the
790 single underscore. These names are normally ommitted from the
791 search.
791 search.
792
792
793 -i/-c: make the pattern case insensitive/sensitive. If neither of
793 -i/-c: make the pattern case insensitive/sensitive. If neither of
794 these options is given, the default is read from your ipythonrc
794 these options is given, the default is read from your ipythonrc
795 file. The option name which sets this value is
795 file. The option name which sets this value is
796 'wildcards_case_sensitive'. If this option is not specified in your
796 'wildcards_case_sensitive'. If this option is not specified in your
797 ipythonrc file, IPython's internal default is to do a case sensitive
797 ipythonrc file, IPython's internal default is to do a case sensitive
798 search.
798 search.
799
799
800 -e/-s NAMESPACE: exclude/search a given namespace. The pattern you
800 -e/-s NAMESPACE: exclude/search a given namespace. The pattern you
801 specifiy can be searched in any of the following namespaces:
801 specifiy can be searched in any of the following namespaces:
802 'builtin', 'user', 'user_global','internal', 'alias', where
802 'builtin', 'user', 'user_global','internal', 'alias', where
803 'builtin' and 'user' are the search defaults. Note that you should
803 'builtin' and 'user' are the search defaults. Note that you should
804 not use quotes when specifying namespaces.
804 not use quotes when specifying namespaces.
805
805
806 'Builtin' contains the python module builtin, 'user' contains all
806 'Builtin' contains the python module builtin, 'user' contains all
807 user data, 'alias' only contain the shell aliases and no python
807 user data, 'alias' only contain the shell aliases and no python
808 objects, 'internal' contains objects used by IPython. The
808 objects, 'internal' contains objects used by IPython. The
809 'user_global' namespace is only used by embedded IPython instances,
809 'user_global' namespace is only used by embedded IPython instances,
810 and it contains module-level globals. You can add namespaces to the
810 and it contains module-level globals. You can add namespaces to the
811 search with -s or exclude them with -e (these options can be given
811 search with -s or exclude them with -e (these options can be given
812 more than once).
812 more than once).
813
813
814 Examples:
814 Examples:
815
815
816 %psearch a* -> objects beginning with an a
816 %psearch a* -> objects beginning with an a
817 %psearch -e builtin a* -> objects NOT in the builtin space starting in a
817 %psearch -e builtin a* -> objects NOT in the builtin space starting in a
818 %psearch a* function -> all functions beginning with an a
818 %psearch a* function -> all functions beginning with an a
819 %psearch re.e* -> objects beginning with an e in module re
819 %psearch re.e* -> objects beginning with an e in module re
820 %psearch r*.e* -> objects that start with e in modules starting in r
820 %psearch r*.e* -> objects that start with e in modules starting in r
821 %psearch r*.* string -> all strings in modules beginning with r
821 %psearch r*.* string -> all strings in modules beginning with r
822
822
823 Case sensitve search:
823 Case sensitve search:
824
824
825 %psearch -c a* list all object beginning with lower case a
825 %psearch -c a* list all object beginning with lower case a
826
826
827 Show objects beginning with a single _:
827 Show objects beginning with a single _:
828
828
829 %psearch -a _* list objects beginning with a single underscore"""
829 %psearch -a _* list objects beginning with a single underscore"""
830 try:
830 try:
831 parameter_s = parameter_s.encode('ascii')
831 parameter_s = parameter_s.encode('ascii')
832 except UnicodeEncodeError:
832 except UnicodeEncodeError:
833 print 'Python identifiers can only contain ascii characters.'
833 print 'Python identifiers can only contain ascii characters.'
834 return
834 return
835
835
836 # default namespaces to be searched
836 # default namespaces to be searched
837 def_search = ['user','builtin']
837 def_search = ['user','builtin']
838
838
839 # Process options/args
839 # Process options/args
840 opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
840 opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
841 opt = opts.get
841 opt = opts.get
842 shell = self.shell
842 shell = self.shell
843 psearch = shell.inspector.psearch
843 psearch = shell.inspector.psearch
844
844
845 # select case options
845 # select case options
846 if opts.has_key('i'):
846 if opts.has_key('i'):
847 ignore_case = True
847 ignore_case = True
848 elif opts.has_key('c'):
848 elif opts.has_key('c'):
849 ignore_case = False
849 ignore_case = False
850 else:
850 else:
851 ignore_case = not shell.rc.wildcards_case_sensitive
851 ignore_case = not shell.rc.wildcards_case_sensitive
852
852
853 # Build list of namespaces to search from user options
853 # Build list of namespaces to search from user options
854 def_search.extend(opt('s',[]))
854 def_search.extend(opt('s',[]))
855 ns_exclude = ns_exclude=opt('e',[])
855 ns_exclude = ns_exclude=opt('e',[])
856 ns_search = [nm for nm in def_search if nm not in ns_exclude]
856 ns_search = [nm for nm in def_search if nm not in ns_exclude]
857
857
858 # Call the actual search
858 # Call the actual search
859 try:
859 try:
860 psearch(args,shell.ns_table,ns_search,
860 psearch(args,shell.ns_table,ns_search,
861 show_all=opt('a'),ignore_case=ignore_case)
861 show_all=opt('a'),ignore_case=ignore_case)
862 except:
862 except:
863 shell.showtraceback()
863 shell.showtraceback()
864
864
865 def magic_who_ls(self, parameter_s=''):
865 def magic_who_ls(self, parameter_s=''):
866 """Return a sorted list of all interactive variables.
866 """Return a sorted list of all interactive variables.
867
867
868 If arguments are given, only variables of types matching these
868 If arguments are given, only variables of types matching these
869 arguments are returned."""
869 arguments are returned."""
870
870
871 user_ns = self.shell.user_ns
871 user_ns = self.shell.user_ns
872 internal_ns = self.shell.internal_ns
872 internal_ns = self.shell.internal_ns
873 user_config_ns = self.shell.user_config_ns
873 user_config_ns = self.shell.user_config_ns
874 out = []
874 out = []
875 typelist = parameter_s.split()
875 typelist = parameter_s.split()
876
876
877 for i in user_ns:
877 for i in user_ns:
878 if not (i.startswith('_') or i.startswith('_i')) \
878 if not (i.startswith('_') or i.startswith('_i')) \
879 and not (i in internal_ns or i in user_config_ns):
879 and not (i in internal_ns or i in user_config_ns):
880 if typelist:
880 if typelist:
881 if type(user_ns[i]).__name__ in typelist:
881 if type(user_ns[i]).__name__ in typelist:
882 out.append(i)
882 out.append(i)
883 else:
883 else:
884 out.append(i)
884 out.append(i)
885 out.sort()
885 out.sort()
886 return out
886 return out
887
887
888 def magic_who(self, parameter_s=''):
888 def magic_who(self, parameter_s=''):
889 """Print all interactive variables, with some minimal formatting.
889 """Print all interactive variables, with some minimal formatting.
890
890
891 If any arguments are given, only variables whose type matches one of
891 If any arguments are given, only variables whose type matches one of
892 these are printed. For example:
892 these are printed. For example:
893
893
894 %who function str
894 %who function str
895
895
896 will only list functions and strings, excluding all other types of
896 will only list functions and strings, excluding all other types of
897 variables. To find the proper type names, simply use type(var) at a
897 variables. To find the proper type names, simply use type(var) at a
898 command line to see how python prints type names. For example:
898 command line to see how python prints type names. For example:
899
899
900 In [1]: type('hello')\\
900 In [1]: type('hello')\\
901 Out[1]: <type 'str'>
901 Out[1]: <type 'str'>
902
902
903 indicates that the type name for strings is 'str'.
903 indicates that the type name for strings is 'str'.
904
904
905 %who always excludes executed names loaded through your configuration
905 %who always excludes executed names loaded through your configuration
906 file and things which are internal to IPython.
906 file and things which are internal to IPython.
907
907
908 This is deliberate, as typically you may load many modules and the
908 This is deliberate, as typically you may load many modules and the
909 purpose of %who is to show you only what you've manually defined."""
909 purpose of %who is to show you only what you've manually defined."""
910
910
911 varlist = self.magic_who_ls(parameter_s)
911 varlist = self.magic_who_ls(parameter_s)
912 if not varlist:
912 if not varlist:
913 if parameter_s:
913 if parameter_s:
914 print 'No variables match your requested type.'
914 print 'No variables match your requested type.'
915 else:
915 else:
916 print 'Interactive namespace is empty.'
916 print 'Interactive namespace is empty.'
917 return
917 return
918
918
919 # if we have variables, move on...
919 # if we have variables, move on...
920 count = 0
920 count = 0
921 for i in varlist:
921 for i in varlist:
922 print i+'\t',
922 print i+'\t',
923 count += 1
923 count += 1
924 if count > 8:
924 if count > 8:
925 count = 0
925 count = 0
926 print
926 print
927 print
927 print
928
928
929 def magic_whos(self, parameter_s=''):
929 def magic_whos(self, parameter_s=''):
930 """Like %who, but gives some extra information about each variable.
930 """Like %who, but gives some extra information about each variable.
931
931
932 The same type filtering of %who can be applied here.
932 The same type filtering of %who can be applied here.
933
933
934 For all variables, the type is printed. Additionally it prints:
934 For all variables, the type is printed. Additionally it prints:
935
935
936 - For {},[],(): their length.
936 - For {},[],(): their length.
937
937
938 - For numpy and Numeric arrays, a summary with shape, number of
938 - For numpy and Numeric arrays, a summary with shape, number of
939 elements, typecode and size in memory.
939 elements, typecode and size in memory.
940
940
941 - Everything else: a string representation, snipping their middle if
941 - Everything else: a string representation, snipping their middle if
942 too long."""
942 too long."""
943
943
944 varnames = self.magic_who_ls(parameter_s)
944 varnames = self.magic_who_ls(parameter_s)
945 if not varnames:
945 if not varnames:
946 if parameter_s:
946 if parameter_s:
947 print 'No variables match your requested type.'
947 print 'No variables match your requested type.'
948 else:
948 else:
949 print 'Interactive namespace is empty.'
949 print 'Interactive namespace is empty.'
950 return
950 return
951
951
952 # if we have variables, move on...
952 # if we have variables, move on...
953
953
954 # for these types, show len() instead of data:
954 # for these types, show len() instead of data:
955 seq_types = [types.DictType,types.ListType,types.TupleType]
955 seq_types = [types.DictType,types.ListType,types.TupleType]
956
956
957 # for numpy/Numeric arrays, display summary info
957 # for numpy/Numeric arrays, display summary info
958 try:
958 try:
959 import numpy
959 import numpy
960 except ImportError:
960 except ImportError:
961 ndarray_type = None
961 ndarray_type = None
962 else:
962 else:
963 ndarray_type = numpy.ndarray.__name__
963 ndarray_type = numpy.ndarray.__name__
964 try:
964 try:
965 import Numeric
965 import Numeric
966 except ImportError:
966 except ImportError:
967 array_type = None
967 array_type = None
968 else:
968 else:
969 array_type = Numeric.ArrayType.__name__
969 array_type = Numeric.ArrayType.__name__
970
970
971 # Find all variable names and types so we can figure out column sizes
971 # Find all variable names and types so we can figure out column sizes
972 def get_vars(i):
972 def get_vars(i):
973 return self.shell.user_ns[i]
973 return self.shell.user_ns[i]
974
974
975 # some types are well known and can be shorter
975 # some types are well known and can be shorter
976 abbrevs = {'IPython.macro.Macro' : 'Macro'}
976 abbrevs = {'IPython.macro.Macro' : 'Macro'}
977 def type_name(v):
977 def type_name(v):
978 tn = type(v).__name__
978 tn = type(v).__name__
979 return abbrevs.get(tn,tn)
979 return abbrevs.get(tn,tn)
980
980
981 varlist = map(get_vars,varnames)
981 varlist = map(get_vars,varnames)
982
982
983 typelist = []
983 typelist = []
984 for vv in varlist:
984 for vv in varlist:
985 tt = type_name(vv)
985 tt = type_name(vv)
986
986
987 if tt=='instance':
987 if tt=='instance':
988 typelist.append( abbrevs.get(str(vv.__class__),
988 typelist.append( abbrevs.get(str(vv.__class__),
989 str(vv.__class__)))
989 str(vv.__class__)))
990 else:
990 else:
991 typelist.append(tt)
991 typelist.append(tt)
992
992
993 # column labels and # of spaces as separator
993 # column labels and # of spaces as separator
994 varlabel = 'Variable'
994 varlabel = 'Variable'
995 typelabel = 'Type'
995 typelabel = 'Type'
996 datalabel = 'Data/Info'
996 datalabel = 'Data/Info'
997 colsep = 3
997 colsep = 3
998 # variable format strings
998 # variable format strings
999 vformat = "$vname.ljust(varwidth)$vtype.ljust(typewidth)"
999 vformat = "$vname.ljust(varwidth)$vtype.ljust(typewidth)"
1000 vfmt_short = '$vstr[:25]<...>$vstr[-25:]'
1000 vfmt_short = '$vstr[:25]<...>$vstr[-25:]'
1001 aformat = "%s: %s elems, type `%s`, %s bytes"
1001 aformat = "%s: %s elems, type `%s`, %s bytes"
1002 # find the size of the columns to format the output nicely
1002 # find the size of the columns to format the output nicely
1003 varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
1003 varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
1004 typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
1004 typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
1005 # table header
1005 # table header
1006 print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
1006 print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
1007 ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
1007 ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
1008 # and the table itself
1008 # and the table itself
1009 kb = 1024
1009 kb = 1024
1010 Mb = 1048576 # kb**2
1010 Mb = 1048576 # kb**2
1011 for vname,var,vtype in zip(varnames,varlist,typelist):
1011 for vname,var,vtype in zip(varnames,varlist,typelist):
1012 print itpl(vformat),
1012 print itpl(vformat),
1013 if vtype in seq_types:
1013 if vtype in seq_types:
1014 print len(var)
1014 print len(var)
1015 elif vtype in [array_type,ndarray_type]:
1015 elif vtype in [array_type,ndarray_type]:
1016 vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
1016 vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
1017 if vtype==ndarray_type:
1017 if vtype==ndarray_type:
1018 # numpy
1018 # numpy
1019 vsize = var.size
1019 vsize = var.size
1020 vbytes = vsize*var.itemsize
1020 vbytes = vsize*var.itemsize
1021 vdtype = var.dtype
1021 vdtype = var.dtype
1022 else:
1022 else:
1023 # Numeric
1023 # Numeric
1024 vsize = Numeric.size(var)
1024 vsize = Numeric.size(var)
1025 vbytes = vsize*var.itemsize()
1025 vbytes = vsize*var.itemsize()
1026 vdtype = var.typecode()
1026 vdtype = var.typecode()
1027
1027
1028 if vbytes < 100000:
1028 if vbytes < 100000:
1029 print aformat % (vshape,vsize,vdtype,vbytes)
1029 print aformat % (vshape,vsize,vdtype,vbytes)
1030 else:
1030 else:
1031 print aformat % (vshape,vsize,vdtype,vbytes),
1031 print aformat % (vshape,vsize,vdtype,vbytes),
1032 if vbytes < Mb:
1032 if vbytes < Mb:
1033 print '(%s kb)' % (vbytes/kb,)
1033 print '(%s kb)' % (vbytes/kb,)
1034 else:
1034 else:
1035 print '(%s Mb)' % (vbytes/Mb,)
1035 print '(%s Mb)' % (vbytes/Mb,)
1036 else:
1036 else:
1037 try:
1037 try:
1038 vstr = str(var)
1038 vstr = str(var)
1039 except UnicodeEncodeError:
1039 except UnicodeEncodeError:
1040 vstr = unicode(var).encode(sys.getdefaultencoding(),
1040 vstr = unicode(var).encode(sys.getdefaultencoding(),
1041 'backslashreplace')
1041 'backslashreplace')
1042 vstr = vstr.replace('\n','\\n')
1042 vstr = vstr.replace('\n','\\n')
1043 if len(vstr) < 50:
1043 if len(vstr) < 50:
1044 print vstr
1044 print vstr
1045 else:
1045 else:
1046 printpl(vfmt_short)
1046 printpl(vfmt_short)
1047
1047
1048 def magic_reset(self, parameter_s=''):
1048 def magic_reset(self, parameter_s=''):
1049 """Resets the namespace by removing all names defined by the user.
1049 """Resets the namespace by removing all names defined by the user.
1050
1050
1051 Input/Output history are left around in case you need them.
1051 Input/Output history are left around in case you need them.
1052
1052
1053 Parameters
1053 Parameters
1054 ----------
1054 ----------
1055 -y : force reset without asking for confirmation.
1055 -y : force reset without asking for confirmation.
1056
1056
1057 Examples
1057 Examples
1058 --------
1058 --------
1059 In [6]: a = 1
1059 In [6]: a = 1
1060
1060
1061 In [7]: a
1061 In [7]: a
1062 Out[7]: 1
1062 Out[7]: 1
1063
1063
1064 In [8]: 'a' in _ip.user_ns
1064 In [8]: 'a' in _ip.user_ns
1065 Out[8]: True
1065 Out[8]: True
1066
1066
1067 In [9]: %reset -f
1067 In [9]: %reset -f
1068
1068
1069 In [10]: 'a' in _ip.user_ns
1069 In [10]: 'a' in _ip.user_ns
1070 Out[10]: False
1070 Out[10]: False
1071 """
1071 """
1072
1072
1073 if parameter_s == '-f':
1073 if parameter_s == '-f':
1074 ans = True
1074 ans = True
1075 else:
1075 else:
1076 ans = self.shell.ask_yes_no(
1076 ans = self.shell.ask_yes_no(
1077 "Once deleted, variables cannot be recovered. Proceed (y/[n])? ")
1077 "Once deleted, variables cannot be recovered. Proceed (y/[n])? ")
1078 if not ans:
1078 if not ans:
1079 print 'Nothing done.'
1079 print 'Nothing done.'
1080 return
1080 return
1081 user_ns = self.shell.user_ns
1081 user_ns = self.shell.user_ns
1082 for i in self.magic_who_ls():
1082 for i in self.magic_who_ls():
1083 del(user_ns[i])
1083 del(user_ns[i])
1084
1084
1085 # Also flush the private list of module references kept for script
1085 # Also flush the private list of module references kept for script
1086 # execution protection
1086 # execution protection
1087 self.shell.clear_main_mod_cache()
1087 self.shell.clear_main_mod_cache()
1088
1088
1089 def magic_logstart(self,parameter_s=''):
1089 def magic_logstart(self,parameter_s=''):
1090 """Start logging anywhere in a session.
1090 """Start logging anywhere in a session.
1091
1091
1092 %logstart [-o|-r|-t] [log_name [log_mode]]
1092 %logstart [-o|-r|-t] [log_name [log_mode]]
1093
1093
1094 If no name is given, it defaults to a file named 'ipython_log.py' in your
1094 If no name is given, it defaults to a file named 'ipython_log.py' in your
1095 current directory, in 'rotate' mode (see below).
1095 current directory, in 'rotate' mode (see below).
1096
1096
1097 '%logstart name' saves to file 'name' in 'backup' mode. It saves your
1097 '%logstart name' saves to file 'name' in 'backup' mode. It saves your
1098 history up to that point and then continues logging.
1098 history up to that point and then continues logging.
1099
1099
1100 %logstart takes a second optional parameter: logging mode. This can be one
1100 %logstart takes a second optional parameter: logging mode. This can be one
1101 of (note that the modes are given unquoted):\\
1101 of (note that the modes are given unquoted):\\
1102 append: well, that says it.\\
1102 append: well, that says it.\\
1103 backup: rename (if exists) to name~ and start name.\\
1103 backup: rename (if exists) to name~ and start name.\\
1104 global: single logfile in your home dir, appended to.\\
1104 global: single logfile in your home dir, appended to.\\
1105 over : overwrite existing log.\\
1105 over : overwrite existing log.\\
1106 rotate: create rotating logs name.1~, name.2~, etc.
1106 rotate: create rotating logs name.1~, name.2~, etc.
1107
1107
1108 Options:
1108 Options:
1109
1109
1110 -o: log also IPython's output. In this mode, all commands which
1110 -o: log also IPython's output. In this mode, all commands which
1111 generate an Out[NN] prompt are recorded to the logfile, right after
1111 generate an Out[NN] prompt are recorded to the logfile, right after
1112 their corresponding input line. The output lines are always
1112 their corresponding input line. The output lines are always
1113 prepended with a '#[Out]# ' marker, so that the log remains valid
1113 prepended with a '#[Out]# ' marker, so that the log remains valid
1114 Python code.
1114 Python code.
1115
1115
1116 Since this marker is always the same, filtering only the output from
1116 Since this marker is always the same, filtering only the output from
1117 a log is very easy, using for example a simple awk call:
1117 a log is very easy, using for example a simple awk call:
1118
1118
1119 awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
1119 awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
1120
1120
1121 -r: log 'raw' input. Normally, IPython's logs contain the processed
1121 -r: log 'raw' input. Normally, IPython's logs contain the processed
1122 input, so that user lines are logged in their final form, converted
1122 input, so that user lines are logged in their final form, converted
1123 into valid Python. For example, %Exit is logged as
1123 into valid Python. For example, %Exit is logged as
1124 '_ip.magic("Exit"). If the -r flag is given, all input is logged
1124 '_ip.magic("Exit"). If the -r flag is given, all input is logged
1125 exactly as typed, with no transformations applied.
1125 exactly as typed, with no transformations applied.
1126
1126
1127 -t: put timestamps before each input line logged (these are put in
1127 -t: put timestamps before each input line logged (these are put in
1128 comments)."""
1128 comments)."""
1129
1129
1130 opts,par = self.parse_options(parameter_s,'ort')
1130 opts,par = self.parse_options(parameter_s,'ort')
1131 log_output = 'o' in opts
1131 log_output = 'o' in opts
1132 log_raw_input = 'r' in opts
1132 log_raw_input = 'r' in opts
1133 timestamp = 't' in opts
1133 timestamp = 't' in opts
1134
1134
1135 rc = self.shell.rc
1135 rc = self.shell.rc
1136 logger = self.shell.logger
1136 logger = self.shell.logger
1137
1137
1138 # if no args are given, the defaults set in the logger constructor by
1138 # if no args are given, the defaults set in the logger constructor by
1139 # ipytohn remain valid
1139 # ipytohn remain valid
1140 if par:
1140 if par:
1141 try:
1141 try:
1142 logfname,logmode = par.split()
1142 logfname,logmode = par.split()
1143 except:
1143 except:
1144 logfname = par
1144 logfname = par
1145 logmode = 'backup'
1145 logmode = 'backup'
1146 else:
1146 else:
1147 logfname = logger.logfname
1147 logfname = logger.logfname
1148 logmode = logger.logmode
1148 logmode = logger.logmode
1149 # put logfname into rc struct as if it had been called on the command
1149 # put logfname into rc struct as if it had been called on the command
1150 # line, so it ends up saved in the log header Save it in case we need
1150 # line, so it ends up saved in the log header Save it in case we need
1151 # to restore it...
1151 # to restore it...
1152 old_logfile = rc.opts.get('logfile','')
1152 old_logfile = rc.opts.get('logfile','')
1153 if logfname:
1153 if logfname:
1154 logfname = os.path.expanduser(logfname)
1154 logfname = os.path.expanduser(logfname)
1155 rc.opts.logfile = logfname
1155 rc.opts.logfile = logfname
1156 loghead = self.shell.loghead_tpl % (rc.opts,rc.args)
1156 loghead = self.shell.loghead_tpl % (rc.opts,rc.args)
1157 try:
1157 try:
1158 started = logger.logstart(logfname,loghead,logmode,
1158 started = logger.logstart(logfname,loghead,logmode,
1159 log_output,timestamp,log_raw_input)
1159 log_output,timestamp,log_raw_input)
1160 except:
1160 except:
1161 rc.opts.logfile = old_logfile
1161 rc.opts.logfile = old_logfile
1162 warn("Couldn't start log: %s" % sys.exc_info()[1])
1162 warn("Couldn't start log: %s" % sys.exc_info()[1])
1163 else:
1163 else:
1164 # log input history up to this point, optionally interleaving
1164 # log input history up to this point, optionally interleaving
1165 # output if requested
1165 # output if requested
1166
1166
1167 if timestamp:
1167 if timestamp:
1168 # disable timestamping for the previous history, since we've
1168 # disable timestamping for the previous history, since we've
1169 # lost those already (no time machine here).
1169 # lost those already (no time machine here).
1170 logger.timestamp = False
1170 logger.timestamp = False
1171
1171
1172 if log_raw_input:
1172 if log_raw_input:
1173 input_hist = self.shell.input_hist_raw
1173 input_hist = self.shell.input_hist_raw
1174 else:
1174 else:
1175 input_hist = self.shell.input_hist
1175 input_hist = self.shell.input_hist
1176
1176
1177 if log_output:
1177 if log_output:
1178 log_write = logger.log_write
1178 log_write = logger.log_write
1179 output_hist = self.shell.output_hist
1179 output_hist = self.shell.output_hist
1180 for n in range(1,len(input_hist)-1):
1180 for n in range(1,len(input_hist)-1):
1181 log_write(input_hist[n].rstrip())
1181 log_write(input_hist[n].rstrip())
1182 if n in output_hist:
1182 if n in output_hist:
1183 log_write(repr(output_hist[n]),'output')
1183 log_write(repr(output_hist[n]),'output')
1184 else:
1184 else:
1185 logger.log_write(input_hist[1:])
1185 logger.log_write(input_hist[1:])
1186 if timestamp:
1186 if timestamp:
1187 # re-enable timestamping
1187 # re-enable timestamping
1188 logger.timestamp = True
1188 logger.timestamp = True
1189
1189
1190 print ('Activating auto-logging. '
1190 print ('Activating auto-logging. '
1191 'Current session state plus future input saved.')
1191 'Current session state plus future input saved.')
1192 logger.logstate()
1192 logger.logstate()
1193
1193
1194 def magic_logstop(self,parameter_s=''):
1194 def magic_logstop(self,parameter_s=''):
1195 """Fully stop logging and close log file.
1195 """Fully stop logging and close log file.
1196
1196
1197 In order to start logging again, a new %logstart call needs to be made,
1197 In order to start logging again, a new %logstart call needs to be made,
1198 possibly (though not necessarily) with a new filename, mode and other
1198 possibly (though not necessarily) with a new filename, mode and other
1199 options."""
1199 options."""
1200 self.logger.logstop()
1200 self.logger.logstop()
1201
1201
1202 def magic_logoff(self,parameter_s=''):
1202 def magic_logoff(self,parameter_s=''):
1203 """Temporarily stop logging.
1203 """Temporarily stop logging.
1204
1204
1205 You must have previously started logging."""
1205 You must have previously started logging."""
1206 self.shell.logger.switch_log(0)
1206 self.shell.logger.switch_log(0)
1207
1207
1208 def magic_logon(self,parameter_s=''):
1208 def magic_logon(self,parameter_s=''):
1209 """Restart logging.
1209 """Restart logging.
1210
1210
1211 This function is for restarting logging which you've temporarily
1211 This function is for restarting logging which you've temporarily
1212 stopped with %logoff. For starting logging for the first time, you
1212 stopped with %logoff. For starting logging for the first time, you
1213 must use the %logstart function, which allows you to specify an
1213 must use the %logstart function, which allows you to specify an
1214 optional log filename."""
1214 optional log filename."""
1215
1215
1216 self.shell.logger.switch_log(1)
1216 self.shell.logger.switch_log(1)
1217
1217
1218 def magic_logstate(self,parameter_s=''):
1218 def magic_logstate(self,parameter_s=''):
1219 """Print the status of the logging system."""
1219 """Print the status of the logging system."""
1220
1220
1221 self.shell.logger.logstate()
1221 self.shell.logger.logstate()
1222
1222
1223 def magic_pdb(self, parameter_s=''):
1223 def magic_pdb(self, parameter_s=''):
1224 """Control the automatic calling of the pdb interactive debugger.
1224 """Control the automatic calling of the pdb interactive debugger.
1225
1225
1226 Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
1226 Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
1227 argument it works as a toggle.
1227 argument it works as a toggle.
1228
1228
1229 When an exception is triggered, IPython can optionally call the
1229 When an exception is triggered, IPython can optionally call the
1230 interactive pdb debugger after the traceback printout. %pdb toggles
1230 interactive pdb debugger after the traceback printout. %pdb toggles
1231 this feature on and off.
1231 this feature on and off.
1232
1232
1233 The initial state of this feature is set in your ipythonrc
1233 The initial state of this feature is set in your ipythonrc
1234 configuration file (the variable is called 'pdb').
1234 configuration file (the variable is called 'pdb').
1235
1235
1236 If you want to just activate the debugger AFTER an exception has fired,
1236 If you want to just activate the debugger AFTER an exception has fired,
1237 without having to type '%pdb on' and rerunning your code, you can use
1237 without having to type '%pdb on' and rerunning your code, you can use
1238 the %debug magic."""
1238 the %debug magic."""
1239
1239
1240 par = parameter_s.strip().lower()
1240 par = parameter_s.strip().lower()
1241
1241
1242 if par:
1242 if par:
1243 try:
1243 try:
1244 new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
1244 new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
1245 except KeyError:
1245 except KeyError:
1246 print ('Incorrect argument. Use on/1, off/0, '
1246 print ('Incorrect argument. Use on/1, off/0, '
1247 'or nothing for a toggle.')
1247 'or nothing for a toggle.')
1248 return
1248 return
1249 else:
1249 else:
1250 # toggle
1250 # toggle
1251 new_pdb = not self.shell.call_pdb
1251 new_pdb = not self.shell.call_pdb
1252
1252
1253 # set on the shell
1253 # set on the shell
1254 self.shell.call_pdb = new_pdb
1254 self.shell.call_pdb = new_pdb
1255 print 'Automatic pdb calling has been turned',on_off(new_pdb)
1255 print 'Automatic pdb calling has been turned',on_off(new_pdb)
1256
1256
1257 def magic_debug(self, parameter_s=''):
1257 def magic_debug(self, parameter_s=''):
1258 """Activate the interactive debugger in post-mortem mode.
1258 """Activate the interactive debugger in post-mortem mode.
1259
1259
1260 If an exception has just occurred, this lets you inspect its stack
1260 If an exception has just occurred, this lets you inspect its stack
1261 frames interactively. Note that this will always work only on the last
1261 frames interactively. Note that this will always work only on the last
1262 traceback that occurred, so you must call this quickly after an
1262 traceback that occurred, so you must call this quickly after an
1263 exception that you wish to inspect has fired, because if another one
1263 exception that you wish to inspect has fired, because if another one
1264 occurs, it clobbers the previous one.
1264 occurs, it clobbers the previous one.
1265
1265
1266 If you want IPython to automatically do this on every exception, see
1266 If you want IPython to automatically do this on every exception, see
1267 the %pdb magic for more details.
1267 the %pdb magic for more details.
1268 """
1268 """
1269
1269
1270 self.shell.debugger(force=True)
1270 self.shell.debugger(force=True)
1271
1271
1272 @testdec.skip_doctest
1272 @testdec.skip_doctest
1273 def magic_prun(self, parameter_s ='',user_mode=1,
1273 def magic_prun(self, parameter_s ='',user_mode=1,
1274 opts=None,arg_lst=None,prog_ns=None):
1274 opts=None,arg_lst=None,prog_ns=None):
1275
1275
1276 """Run a statement through the python code profiler.
1276 """Run a statement through the python code profiler.
1277
1277
1278 Usage:
1278 Usage:
1279 %prun [options] statement
1279 %prun [options] statement
1280
1280
1281 The given statement (which doesn't require quote marks) is run via the
1281 The given statement (which doesn't require quote marks) is run via the
1282 python profiler in a manner similar to the profile.run() function.
1282 python profiler in a manner similar to the profile.run() function.
1283 Namespaces are internally managed to work correctly; profile.run
1283 Namespaces are internally managed to work correctly; profile.run
1284 cannot be used in IPython because it makes certain assumptions about
1284 cannot be used in IPython because it makes certain assumptions about
1285 namespaces which do not hold under IPython.
1285 namespaces which do not hold under IPython.
1286
1286
1287 Options:
1287 Options:
1288
1288
1289 -l <limit>: you can place restrictions on what or how much of the
1289 -l <limit>: you can place restrictions on what or how much of the
1290 profile gets printed. The limit value can be:
1290 profile gets printed. The limit value can be:
1291
1291
1292 * A string: only information for function names containing this string
1292 * A string: only information for function names containing this string
1293 is printed.
1293 is printed.
1294
1294
1295 * An integer: only these many lines are printed.
1295 * An integer: only these many lines are printed.
1296
1296
1297 * A float (between 0 and 1): this fraction of the report is printed
1297 * A float (between 0 and 1): this fraction of the report is printed
1298 (for example, use a limit of 0.4 to see the topmost 40% only).
1298 (for example, use a limit of 0.4 to see the topmost 40% only).
1299
1299
1300 You can combine several limits with repeated use of the option. For
1300 You can combine several limits with repeated use of the option. For
1301 example, '-l __init__ -l 5' will print only the topmost 5 lines of
1301 example, '-l __init__ -l 5' will print only the topmost 5 lines of
1302 information about class constructors.
1302 information about class constructors.
1303
1303
1304 -r: return the pstats.Stats object generated by the profiling. This
1304 -r: return the pstats.Stats object generated by the profiling. This
1305 object has all the information about the profile in it, and you can
1305 object has all the information about the profile in it, and you can
1306 later use it for further analysis or in other functions.
1306 later use it for further analysis or in other functions.
1307
1307
1308 -s <key>: sort profile by given key. You can provide more than one key
1308 -s <key>: sort profile by given key. You can provide more than one key
1309 by using the option several times: '-s key1 -s key2 -s key3...'. The
1309 by using the option several times: '-s key1 -s key2 -s key3...'. The
1310 default sorting key is 'time'.
1310 default sorting key is 'time'.
1311
1311
1312 The following is copied verbatim from the profile documentation
1312 The following is copied verbatim from the profile documentation
1313 referenced below:
1313 referenced below:
1314
1314
1315 When more than one key is provided, additional keys are used as
1315 When more than one key is provided, additional keys are used as
1316 secondary criteria when the there is equality in all keys selected
1316 secondary criteria when the there is equality in all keys selected
1317 before them.
1317 before them.
1318
1318
1319 Abbreviations can be used for any key names, as long as the
1319 Abbreviations can be used for any key names, as long as the
1320 abbreviation is unambiguous. The following are the keys currently
1320 abbreviation is unambiguous. The following are the keys currently
1321 defined:
1321 defined:
1322
1322
1323 Valid Arg Meaning
1323 Valid Arg Meaning
1324 "calls" call count
1324 "calls" call count
1325 "cumulative" cumulative time
1325 "cumulative" cumulative time
1326 "file" file name
1326 "file" file name
1327 "module" file name
1327 "module" file name
1328 "pcalls" primitive call count
1328 "pcalls" primitive call count
1329 "line" line number
1329 "line" line number
1330 "name" function name
1330 "name" function name
1331 "nfl" name/file/line
1331 "nfl" name/file/line
1332 "stdname" standard name
1332 "stdname" standard name
1333 "time" internal time
1333 "time" internal time
1334
1334
1335 Note that all sorts on statistics are in descending order (placing
1335 Note that all sorts on statistics are in descending order (placing
1336 most time consuming items first), where as name, file, and line number
1336 most time consuming items first), where as name, file, and line number
1337 searches are in ascending order (i.e., alphabetical). The subtle
1337 searches are in ascending order (i.e., alphabetical). The subtle
1338 distinction between "nfl" and "stdname" is that the standard name is a
1338 distinction between "nfl" and "stdname" is that the standard name is a
1339 sort of the name as printed, which means that the embedded line
1339 sort of the name as printed, which means that the embedded line
1340 numbers get compared in an odd way. For example, lines 3, 20, and 40
1340 numbers get compared in an odd way. For example, lines 3, 20, and 40
1341 would (if the file names were the same) appear in the string order
1341 would (if the file names were the same) appear in the string order
1342 "20" "3" and "40". In contrast, "nfl" does a numeric compare of the
1342 "20" "3" and "40". In contrast, "nfl" does a numeric compare of the
1343 line numbers. In fact, sort_stats("nfl") is the same as
1343 line numbers. In fact, sort_stats("nfl") is the same as
1344 sort_stats("name", "file", "line").
1344 sort_stats("name", "file", "line").
1345
1345
1346 -T <filename>: save profile results as shown on screen to a text
1346 -T <filename>: save profile results as shown on screen to a text
1347 file. The profile is still shown on screen.
1347 file. The profile is still shown on screen.
1348
1348
1349 -D <filename>: save (via dump_stats) profile statistics to given
1349 -D <filename>: save (via dump_stats) profile statistics to given
1350 filename. This data is in a format understod by the pstats module, and
1350 filename. This data is in a format understod by the pstats module, and
1351 is generated by a call to the dump_stats() method of profile
1351 is generated by a call to the dump_stats() method of profile
1352 objects. The profile is still shown on screen.
1352 objects. The profile is still shown on screen.
1353
1353
1354 If you want to run complete programs under the profiler's control, use
1354 If you want to run complete programs under the profiler's control, use
1355 '%run -p [prof_opts] filename.py [args to program]' where prof_opts
1355 '%run -p [prof_opts] filename.py [args to program]' where prof_opts
1356 contains profiler specific options as described here.
1356 contains profiler specific options as described here.
1357
1357
1358 You can read the complete documentation for the profile module with::
1358 You can read the complete documentation for the profile module with::
1359
1359
1360 In [1]: import profile; profile.help()
1360 In [1]: import profile; profile.help()
1361 """
1361 """
1362
1362
1363 opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
1363 opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
1364 # protect user quote marks
1364 # protect user quote marks
1365 parameter_s = parameter_s.replace('"',r'\"').replace("'",r"\'")
1365 parameter_s = parameter_s.replace('"',r'\"').replace("'",r"\'")
1366
1366
1367 if user_mode: # regular user call
1367 if user_mode: # regular user call
1368 opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:',
1368 opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:',
1369 list_all=1)
1369 list_all=1)
1370 namespace = self.shell.user_ns
1370 namespace = self.shell.user_ns
1371 else: # called to run a program by %run -p
1371 else: # called to run a program by %run -p
1372 try:
1372 try:
1373 filename = get_py_filename(arg_lst[0])
1373 filename = get_py_filename(arg_lst[0])
1374 except IOError,msg:
1374 except IOError,msg:
1375 error(msg)
1375 error(msg)
1376 return
1376 return
1377
1377
1378 arg_str = 'execfile(filename,prog_ns)'
1378 arg_str = 'execfile(filename,prog_ns)'
1379 namespace = locals()
1379 namespace = locals()
1380
1380
1381 opts.merge(opts_def)
1381 opts.merge(opts_def)
1382
1382
1383 prof = profile.Profile()
1383 prof = profile.Profile()
1384 try:
1384 try:
1385 prof = prof.runctx(arg_str,namespace,namespace)
1385 prof = prof.runctx(arg_str,namespace,namespace)
1386 sys_exit = ''
1386 sys_exit = ''
1387 except SystemExit:
1387 except SystemExit:
1388 sys_exit = """*** SystemExit exception caught in code being profiled."""
1388 sys_exit = """*** SystemExit exception caught in code being profiled."""
1389
1389
1390 stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
1390 stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
1391
1391
1392 lims = opts.l
1392 lims = opts.l
1393 if lims:
1393 if lims:
1394 lims = [] # rebuild lims with ints/floats/strings
1394 lims = [] # rebuild lims with ints/floats/strings
1395 for lim in opts.l:
1395 for lim in opts.l:
1396 try:
1396 try:
1397 lims.append(int(lim))
1397 lims.append(int(lim))
1398 except ValueError:
1398 except ValueError:
1399 try:
1399 try:
1400 lims.append(float(lim))
1400 lims.append(float(lim))
1401 except ValueError:
1401 except ValueError:
1402 lims.append(lim)
1402 lims.append(lim)
1403
1403
1404 # Trap output.
1404 # Trap output.
1405 stdout_trap = StringIO()
1405 stdout_trap = StringIO()
1406
1406
1407 if hasattr(stats,'stream'):
1407 if hasattr(stats,'stream'):
1408 # In newer versions of python, the stats object has a 'stream'
1408 # In newer versions of python, the stats object has a 'stream'
1409 # attribute to write into.
1409 # attribute to write into.
1410 stats.stream = stdout_trap
1410 stats.stream = stdout_trap
1411 stats.print_stats(*lims)
1411 stats.print_stats(*lims)
1412 else:
1412 else:
1413 # For older versions, we manually redirect stdout during printing
1413 # For older versions, we manually redirect stdout during printing
1414 sys_stdout = sys.stdout
1414 sys_stdout = sys.stdout
1415 try:
1415 try:
1416 sys.stdout = stdout_trap
1416 sys.stdout = stdout_trap
1417 stats.print_stats(*lims)
1417 stats.print_stats(*lims)
1418 finally:
1418 finally:
1419 sys.stdout = sys_stdout
1419 sys.stdout = sys_stdout
1420
1420
1421 output = stdout_trap.getvalue()
1421 output = stdout_trap.getvalue()
1422 output = output.rstrip()
1422 output = output.rstrip()
1423
1423
1424 page(output,screen_lines=self.shell.rc.screen_length)
1424 page(output,screen_lines=self.shell.rc.screen_length)
1425 print sys_exit,
1425 print sys_exit,
1426
1426
1427 dump_file = opts.D[0]
1427 dump_file = opts.D[0]
1428 text_file = opts.T[0]
1428 text_file = opts.T[0]
1429 if dump_file:
1429 if dump_file:
1430 prof.dump_stats(dump_file)
1430 prof.dump_stats(dump_file)
1431 print '\n*** Profile stats marshalled to file',\
1431 print '\n*** Profile stats marshalled to file',\
1432 `dump_file`+'.',sys_exit
1432 `dump_file`+'.',sys_exit
1433 if text_file:
1433 if text_file:
1434 pfile = file(text_file,'w')
1434 pfile = file(text_file,'w')
1435 pfile.write(output)
1435 pfile.write(output)
1436 pfile.close()
1436 pfile.close()
1437 print '\n*** Profile printout saved to text file',\
1437 print '\n*** Profile printout saved to text file',\
1438 `text_file`+'.',sys_exit
1438 `text_file`+'.',sys_exit
1439
1439
1440 if opts.has_key('r'):
1440 if opts.has_key('r'):
1441 return stats
1441 return stats
1442 else:
1442 else:
1443 return None
1443 return None
1444
1444
1445 @testdec.skip_doctest
1445 @testdec.skip_doctest
1446 def magic_run(self, parameter_s ='',runner=None,
1446 def magic_run(self, parameter_s ='',runner=None,
1447 file_finder=get_py_filename):
1447 file_finder=get_py_filename):
1448 """Run the named file inside IPython as a program.
1448 """Run the named file inside IPython as a program.
1449
1449
1450 Usage:\\
1450 Usage:\\
1451 %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
1451 %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
1452
1452
1453 Parameters after the filename are passed as command-line arguments to
1453 Parameters after the filename are passed as command-line arguments to
1454 the program (put in sys.argv). Then, control returns to IPython's
1454 the program (put in sys.argv). Then, control returns to IPython's
1455 prompt.
1455 prompt.
1456
1456
1457 This is similar to running at a system prompt:\\
1457 This is similar to running at a system prompt:\\
1458 $ python file args\\
1458 $ python file args\\
1459 but with the advantage of giving you IPython's tracebacks, and of
1459 but with the advantage of giving you IPython's tracebacks, and of
1460 loading all variables into your interactive namespace for further use
1460 loading all variables into your interactive namespace for further use
1461 (unless -p is used, see below).
1461 (unless -p is used, see below).
1462
1462
1463 The file is executed in a namespace initially consisting only of
1463 The file is executed in a namespace initially consisting only of
1464 __name__=='__main__' and sys.argv constructed as indicated. It thus
1464 __name__=='__main__' and sys.argv constructed as indicated. It thus
1465 sees its environment as if it were being run as a stand-alone program
1465 sees its environment as if it were being run as a stand-alone program
1466 (except for sharing global objects such as previously imported
1466 (except for sharing global objects such as previously imported
1467 modules). But after execution, the IPython interactive namespace gets
1467 modules). But after execution, the IPython interactive namespace gets
1468 updated with all variables defined in the program (except for __name__
1468 updated with all variables defined in the program (except for __name__
1469 and sys.argv). This allows for very convenient loading of code for
1469 and sys.argv). This allows for very convenient loading of code for
1470 interactive work, while giving each program a 'clean sheet' to run in.
1470 interactive work, while giving each program a 'clean sheet' to run in.
1471
1471
1472 Options:
1472 Options:
1473
1473
1474 -n: __name__ is NOT set to '__main__', but to the running file's name
1474 -n: __name__ is NOT set to '__main__', but to the running file's name
1475 without extension (as python does under import). This allows running
1475 without extension (as python does under import). This allows running
1476 scripts and reloading the definitions in them without calling code
1476 scripts and reloading the definitions in them without calling code
1477 protected by an ' if __name__ == "__main__" ' clause.
1477 protected by an ' if __name__ == "__main__" ' clause.
1478
1478
1479 -i: run the file in IPython's namespace instead of an empty one. This
1479 -i: run the file in IPython's namespace instead of an empty one. This
1480 is useful if you are experimenting with code written in a text editor
1480 is useful if you are experimenting with code written in a text editor
1481 which depends on variables defined interactively.
1481 which depends on variables defined interactively.
1482
1482
1483 -e: ignore sys.exit() calls or SystemExit exceptions in the script
1483 -e: ignore sys.exit() calls or SystemExit exceptions in the script
1484 being run. This is particularly useful if IPython is being used to
1484 being run. This is particularly useful if IPython is being used to
1485 run unittests, which always exit with a sys.exit() call. In such
1485 run unittests, which always exit with a sys.exit() call. In such
1486 cases you are interested in the output of the test results, not in
1486 cases you are interested in the output of the test results, not in
1487 seeing a traceback of the unittest module.
1487 seeing a traceback of the unittest module.
1488
1488
1489 -t: print timing information at the end of the run. IPython will give
1489 -t: print timing information at the end of the run. IPython will give
1490 you an estimated CPU time consumption for your script, which under
1490 you an estimated CPU time consumption for your script, which under
1491 Unix uses the resource module to avoid the wraparound problems of
1491 Unix uses the resource module to avoid the wraparound problems of
1492 time.clock(). Under Unix, an estimate of time spent on system tasks
1492 time.clock(). Under Unix, an estimate of time spent on system tasks
1493 is also given (for Windows platforms this is reported as 0.0).
1493 is also given (for Windows platforms this is reported as 0.0).
1494
1494
1495 If -t is given, an additional -N<N> option can be given, where <N>
1495 If -t is given, an additional -N<N> option can be given, where <N>
1496 must be an integer indicating how many times you want the script to
1496 must be an integer indicating how many times you want the script to
1497 run. The final timing report will include total and per run results.
1497 run. The final timing report will include total and per run results.
1498
1498
1499 For example (testing the script uniq_stable.py):
1499 For example (testing the script uniq_stable.py):
1500
1500
1501 In [1]: run -t uniq_stable
1501 In [1]: run -t uniq_stable
1502
1502
1503 IPython CPU timings (estimated):\\
1503 IPython CPU timings (estimated):\\
1504 User : 0.19597 s.\\
1504 User : 0.19597 s.\\
1505 System: 0.0 s.\\
1505 System: 0.0 s.\\
1506
1506
1507 In [2]: run -t -N5 uniq_stable
1507 In [2]: run -t -N5 uniq_stable
1508
1508
1509 IPython CPU timings (estimated):\\
1509 IPython CPU timings (estimated):\\
1510 Total runs performed: 5\\
1510 Total runs performed: 5\\
1511 Times : Total Per run\\
1511 Times : Total Per run\\
1512 User : 0.910862 s, 0.1821724 s.\\
1512 User : 0.910862 s, 0.1821724 s.\\
1513 System: 0.0 s, 0.0 s.
1513 System: 0.0 s, 0.0 s.
1514
1514
1515 -d: run your program under the control of pdb, the Python debugger.
1515 -d: run your program under the control of pdb, the Python debugger.
1516 This allows you to execute your program step by step, watch variables,
1516 This allows you to execute your program step by step, watch variables,
1517 etc. Internally, what IPython does is similar to calling:
1517 etc. Internally, what IPython does is similar to calling:
1518
1518
1519 pdb.run('execfile("YOURFILENAME")')
1519 pdb.run('execfile("YOURFILENAME")')
1520
1520
1521 with a breakpoint set on line 1 of your file. You can change the line
1521 with a breakpoint set on line 1 of your file. You can change the line
1522 number for this automatic breakpoint to be <N> by using the -bN option
1522 number for this automatic breakpoint to be <N> by using the -bN option
1523 (where N must be an integer). For example:
1523 (where N must be an integer). For example:
1524
1524
1525 %run -d -b40 myscript
1525 %run -d -b40 myscript
1526
1526
1527 will set the first breakpoint at line 40 in myscript.py. Note that
1527 will set the first breakpoint at line 40 in myscript.py. Note that
1528 the first breakpoint must be set on a line which actually does
1528 the first breakpoint must be set on a line which actually does
1529 something (not a comment or docstring) for it to stop execution.
1529 something (not a comment or docstring) for it to stop execution.
1530
1530
1531 When the pdb debugger starts, you will see a (Pdb) prompt. You must
1531 When the pdb debugger starts, you will see a (Pdb) prompt. You must
1532 first enter 'c' (without qoutes) to start execution up to the first
1532 first enter 'c' (without qoutes) to start execution up to the first
1533 breakpoint.
1533 breakpoint.
1534
1534
1535 Entering 'help' gives information about the use of the debugger. You
1535 Entering 'help' gives information about the use of the debugger. You
1536 can easily see pdb's full documentation with "import pdb;pdb.help()"
1536 can easily see pdb's full documentation with "import pdb;pdb.help()"
1537 at a prompt.
1537 at a prompt.
1538
1538
1539 -p: run program under the control of the Python profiler module (which
1539 -p: run program under the control of the Python profiler module (which
1540 prints a detailed report of execution times, function calls, etc).
1540 prints a detailed report of execution times, function calls, etc).
1541
1541
1542 You can pass other options after -p which affect the behavior of the
1542 You can pass other options after -p which affect the behavior of the
1543 profiler itself. See the docs for %prun for details.
1543 profiler itself. See the docs for %prun for details.
1544
1544
1545 In this mode, the program's variables do NOT propagate back to the
1545 In this mode, the program's variables do NOT propagate back to the
1546 IPython interactive namespace (because they remain in the namespace
1546 IPython interactive namespace (because they remain in the namespace
1547 where the profiler executes them).
1547 where the profiler executes them).
1548
1548
1549 Internally this triggers a call to %prun, see its documentation for
1549 Internally this triggers a call to %prun, see its documentation for
1550 details on the options available specifically for profiling.
1550 details on the options available specifically for profiling.
1551
1551
1552 There is one special usage for which the text above doesn't apply:
1552 There is one special usage for which the text above doesn't apply:
1553 if the filename ends with .ipy, the file is run as ipython script,
1553 if the filename ends with .ipy, the file is run as ipython script,
1554 just as if the commands were written on IPython prompt.
1554 just as if the commands were written on IPython prompt.
1555 """
1555 """
1556
1556
1557 # get arguments and set sys.argv for program to be run.
1557 # get arguments and set sys.argv for program to be run.
1558 opts,arg_lst = self.parse_options(parameter_s,'nidtN:b:pD:l:rs:T:e',
1558 opts,arg_lst = self.parse_options(parameter_s,'nidtN:b:pD:l:rs:T:e',
1559 mode='list',list_all=1)
1559 mode='list',list_all=1)
1560
1560
1561 try:
1561 try:
1562 filename = file_finder(arg_lst[0])
1562 filename = file_finder(arg_lst[0])
1563 except IndexError:
1563 except IndexError:
1564 warn('you must provide at least a filename.')
1564 warn('you must provide at least a filename.')
1565 print '\n%run:\n',OInspect.getdoc(self.magic_run)
1565 print '\n%run:\n',OInspect.getdoc(self.magic_run)
1566 return
1566 return
1567 except IOError,msg:
1567 except IOError,msg:
1568 error(msg)
1568 error(msg)
1569 return
1569 return
1570
1570
1571 if filename.lower().endswith('.ipy'):
1571 if filename.lower().endswith('.ipy'):
1572 self.api.runlines(open(filename).read())
1572 self.api.runlines(open(filename).read())
1573 return
1573 return
1574
1574
1575 # Control the response to exit() calls made by the script being run
1575 # Control the response to exit() calls made by the script being run
1576 exit_ignore = opts.has_key('e')
1576 exit_ignore = opts.has_key('e')
1577
1577
1578 # Make sure that the running script gets a proper sys.argv as if it
1578 # Make sure that the running script gets a proper sys.argv as if it
1579 # were run from a system shell.
1579 # were run from a system shell.
1580 save_argv = sys.argv # save it for later restoring
1580 save_argv = sys.argv # save it for later restoring
1581 sys.argv = [filename]+ arg_lst[1:] # put in the proper filename
1581 sys.argv = [filename]+ arg_lst[1:] # put in the proper filename
1582
1582
1583 if opts.has_key('i'):
1583 if opts.has_key('i'):
1584 # Run in user's interactive namespace
1584 # Run in user's interactive namespace
1585 prog_ns = self.shell.user_ns
1585 prog_ns = self.shell.user_ns
1586 __name__save = self.shell.user_ns['__name__']
1586 __name__save = self.shell.user_ns['__name__']
1587 prog_ns['__name__'] = '__main__'
1587 prog_ns['__name__'] = '__main__'
1588 main_mod = self.shell.new_main_mod(prog_ns)
1588 main_mod = self.shell.new_main_mod(prog_ns)
1589 else:
1589 else:
1590 # Run in a fresh, empty namespace
1590 # Run in a fresh, empty namespace
1591 if opts.has_key('n'):
1591 if opts.has_key('n'):
1592 name = os.path.splitext(os.path.basename(filename))[0]
1592 name = os.path.splitext(os.path.basename(filename))[0]
1593 else:
1593 else:
1594 name = '__main__'
1594 name = '__main__'
1595
1595
1596 main_mod = self.shell.new_main_mod()
1596 main_mod = self.shell.new_main_mod()
1597 prog_ns = main_mod.__dict__
1597 prog_ns = main_mod.__dict__
1598 prog_ns['__name__'] = name
1598 prog_ns['__name__'] = name
1599
1599
1600 # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
1600 # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
1601 # set the __file__ global in the script's namespace
1601 # set the __file__ global in the script's namespace
1602 prog_ns['__file__'] = filename
1602 prog_ns['__file__'] = filename
1603
1603
1604 # pickle fix. See iplib for an explanation. But we need to make sure
1604 # pickle fix. See iplib for an explanation. But we need to make sure
1605 # that, if we overwrite __main__, we replace it at the end
1605 # that, if we overwrite __main__, we replace it at the end
1606 main_mod_name = prog_ns['__name__']
1606 main_mod_name = prog_ns['__name__']
1607
1607
1608 if main_mod_name == '__main__':
1608 if main_mod_name == '__main__':
1609 restore_main = sys.modules['__main__']
1609 restore_main = sys.modules['__main__']
1610 else:
1610 else:
1611 restore_main = False
1611 restore_main = False
1612
1612
1613 # This needs to be undone at the end to prevent holding references to
1613 # This needs to be undone at the end to prevent holding references to
1614 # every single object ever created.
1614 # every single object ever created.
1615 sys.modules[main_mod_name] = main_mod
1615 sys.modules[main_mod_name] = main_mod
1616
1616
1617 stats = None
1617 stats = None
1618 try:
1618 try:
1619 self.shell.savehist()
1619 self.shell.savehist()
1620
1620
1621 if opts.has_key('p'):
1621 if opts.has_key('p'):
1622 stats = self.magic_prun('',0,opts,arg_lst,prog_ns)
1622 stats = self.magic_prun('',0,opts,arg_lst,prog_ns)
1623 else:
1623 else:
1624 if opts.has_key('d'):
1624 if opts.has_key('d'):
1625 deb = debugger.Pdb(self.shell.rc.colors)
1625 deb = debugger.Pdb(self.shell.rc.colors)
1626 # reset Breakpoint state, which is moronically kept
1626 # reset Breakpoint state, which is moronically kept
1627 # in a class
1627 # in a class
1628 bdb.Breakpoint.next = 1
1628 bdb.Breakpoint.next = 1
1629 bdb.Breakpoint.bplist = {}
1629 bdb.Breakpoint.bplist = {}
1630 bdb.Breakpoint.bpbynumber = [None]
1630 bdb.Breakpoint.bpbynumber = [None]
1631 # Set an initial breakpoint to stop execution
1631 # Set an initial breakpoint to stop execution
1632 maxtries = 10
1632 maxtries = 10
1633 bp = int(opts.get('b',[1])[0])
1633 bp = int(opts.get('b',[1])[0])
1634 checkline = deb.checkline(filename,bp)
1634 checkline = deb.checkline(filename,bp)
1635 if not checkline:
1635 if not checkline:
1636 for bp in range(bp+1,bp+maxtries+1):
1636 for bp in range(bp+1,bp+maxtries+1):
1637 if deb.checkline(filename,bp):
1637 if deb.checkline(filename,bp):
1638 break
1638 break
1639 else:
1639 else:
1640 msg = ("\nI failed to find a valid line to set "
1640 msg = ("\nI failed to find a valid line to set "
1641 "a breakpoint\n"
1641 "a breakpoint\n"
1642 "after trying up to line: %s.\n"
1642 "after trying up to line: %s.\n"
1643 "Please set a valid breakpoint manually "
1643 "Please set a valid breakpoint manually "
1644 "with the -b option." % bp)
1644 "with the -b option." % bp)
1645 error(msg)
1645 error(msg)
1646 return
1646 return
1647 # if we find a good linenumber, set the breakpoint
1647 # if we find a good linenumber, set the breakpoint
1648 deb.do_break('%s:%s' % (filename,bp))
1648 deb.do_break('%s:%s' % (filename,bp))
1649 # Start file run
1649 # Start file run
1650 print "NOTE: Enter 'c' at the",
1650 print "NOTE: Enter 'c' at the",
1651 print "%s prompt to start your script." % deb.prompt
1651 print "%s prompt to start your script." % deb.prompt
1652 try:
1652 try:
1653 deb.run('execfile("%s")' % filename,prog_ns)
1653 deb.run('execfile("%s")' % filename,prog_ns)
1654
1654
1655 except:
1655 except:
1656 etype, value, tb = sys.exc_info()
1656 etype, value, tb = sys.exc_info()
1657 # Skip three frames in the traceback: the %run one,
1657 # Skip three frames in the traceback: the %run one,
1658 # one inside bdb.py, and the command-line typed by the
1658 # one inside bdb.py, and the command-line typed by the
1659 # user (run by exec in pdb itself).
1659 # user (run by exec in pdb itself).
1660 self.shell.InteractiveTB(etype,value,tb,tb_offset=3)
1660 self.shell.InteractiveTB(etype,value,tb,tb_offset=3)
1661 else:
1661 else:
1662 if runner is None:
1662 if runner is None:
1663 runner = self.shell.safe_execfile
1663 runner = self.shell.safe_execfile
1664 if opts.has_key('t'):
1664 if opts.has_key('t'):
1665 # timed execution
1665 # timed execution
1666 try:
1666 try:
1667 nruns = int(opts['N'][0])
1667 nruns = int(opts['N'][0])
1668 if nruns < 1:
1668 if nruns < 1:
1669 error('Number of runs must be >=1')
1669 error('Number of runs must be >=1')
1670 return
1670 return
1671 except (KeyError):
1671 except (KeyError):
1672 nruns = 1
1672 nruns = 1
1673 if nruns == 1:
1673 if nruns == 1:
1674 t0 = clock2()
1674 t0 = clock2()
1675 runner(filename,prog_ns,prog_ns,
1675 runner(filename,prog_ns,prog_ns,
1676 exit_ignore=exit_ignore)
1676 exit_ignore=exit_ignore)
1677 t1 = clock2()
1677 t1 = clock2()
1678 t_usr = t1[0]-t0[0]
1678 t_usr = t1[0]-t0[0]
1679 t_sys = t1[1]-t0[1]
1679 t_sys = t1[1]-t0[1]
1680 print "\nIPython CPU timings (estimated):"
1680 print "\nIPython CPU timings (estimated):"
1681 print " User : %10s s." % t_usr
1681 print " User : %10s s." % t_usr
1682 print " System: %10s s." % t_sys
1682 print " System: %10s s." % t_sys
1683 else:
1683 else:
1684 runs = range(nruns)
1684 runs = range(nruns)
1685 t0 = clock2()
1685 t0 = clock2()
1686 for nr in runs:
1686 for nr in runs:
1687 runner(filename,prog_ns,prog_ns,
1687 runner(filename,prog_ns,prog_ns,
1688 exit_ignore=exit_ignore)
1688 exit_ignore=exit_ignore)
1689 t1 = clock2()
1689 t1 = clock2()
1690 t_usr = t1[0]-t0[0]
1690 t_usr = t1[0]-t0[0]
1691 t_sys = t1[1]-t0[1]
1691 t_sys = t1[1]-t0[1]
1692 print "\nIPython CPU timings (estimated):"
1692 print "\nIPython CPU timings (estimated):"
1693 print "Total runs performed:",nruns
1693 print "Total runs performed:",nruns
1694 print " Times : %10s %10s" % ('Total','Per run')
1694 print " Times : %10s %10s" % ('Total','Per run')
1695 print " User : %10s s, %10s s." % (t_usr,t_usr/nruns)
1695 print " User : %10s s, %10s s." % (t_usr,t_usr/nruns)
1696 print " System: %10s s, %10s s." % (t_sys,t_sys/nruns)
1696 print " System: %10s s, %10s s." % (t_sys,t_sys/nruns)
1697
1697
1698 else:
1698 else:
1699 # regular execution
1699 # regular execution
1700 runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
1700 runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
1701
1701
1702 if opts.has_key('i'):
1702 if opts.has_key('i'):
1703 self.shell.user_ns['__name__'] = __name__save
1703 self.shell.user_ns['__name__'] = __name__save
1704 else:
1704 else:
1705 # The shell MUST hold a reference to prog_ns so after %run
1705 # The shell MUST hold a reference to prog_ns so after %run
1706 # exits, the python deletion mechanism doesn't zero it out
1706 # exits, the python deletion mechanism doesn't zero it out
1707 # (leaving dangling references).
1707 # (leaving dangling references).
1708 self.shell.cache_main_mod(prog_ns,filename)
1708 self.shell.cache_main_mod(prog_ns,filename)
1709 # update IPython interactive namespace
1709 # update IPython interactive namespace
1710 del prog_ns['__name__']
1710 del prog_ns['__name__']
1711 self.shell.user_ns.update(prog_ns)
1711 self.shell.user_ns.update(prog_ns)
1712 finally:
1712 finally:
1713 # It's a bit of a mystery why, but __builtins__ can change from
1713 # It's a bit of a mystery why, but __builtins__ can change from
1714 # being a module to becoming a dict missing some key data after
1714 # being a module to becoming a dict missing some key data after
1715 # %run. As best I can see, this is NOT something IPython is doing
1715 # %run. As best I can see, this is NOT something IPython is doing
1716 # at all, and similar problems have been reported before:
1716 # at all, and similar problems have been reported before:
1717 # http://coding.derkeiler.com/Archive/Python/comp.lang.python/2004-10/0188.html
1717 # http://coding.derkeiler.com/Archive/Python/comp.lang.python/2004-10/0188.html
1718 # Since this seems to be done by the interpreter itself, the best
1718 # Since this seems to be done by the interpreter itself, the best
1719 # we can do is to at least restore __builtins__ for the user on
1719 # we can do is to at least restore __builtins__ for the user on
1720 # exit.
1720 # exit.
1721 self.shell.user_ns['__builtins__'] = __builtin__
1721 self.shell.user_ns['__builtins__'] = __builtin__
1722
1722
1723 # Ensure key global structures are restored
1723 # Ensure key global structures are restored
1724 sys.argv = save_argv
1724 sys.argv = save_argv
1725 if restore_main:
1725 if restore_main:
1726 sys.modules['__main__'] = restore_main
1726 sys.modules['__main__'] = restore_main
1727 else:
1727 else:
1728 # Remove from sys.modules the reference to main_mod we'd
1728 # Remove from sys.modules the reference to main_mod we'd
1729 # added. Otherwise it will trap references to objects
1729 # added. Otherwise it will trap references to objects
1730 # contained therein.
1730 # contained therein.
1731 del sys.modules[main_mod_name]
1731 del sys.modules[main_mod_name]
1732
1732
1733 self.shell.reloadhist()
1733 self.shell.reloadhist()
1734
1734
1735 return stats
1735 return stats
1736
1736
1737 def magic_runlog(self, parameter_s =''):
1737 def magic_runlog(self, parameter_s =''):
1738 """Run files as logs.
1738 """Run files as logs.
1739
1739
1740 Usage:\\
1740 Usage:\\
1741 %runlog file1 file2 ...
1741 %runlog file1 file2 ...
1742
1742
1743 Run the named files (treating them as log files) in sequence inside
1743 Run the named files (treating them as log files) in sequence inside
1744 the interpreter, and return to the prompt. This is much slower than
1744 the interpreter, and return to the prompt. This is much slower than
1745 %run because each line is executed in a try/except block, but it
1745 %run because each line is executed in a try/except block, but it
1746 allows running files with syntax errors in them.
1746 allows running files with syntax errors in them.
1747
1747
1748 Normally IPython will guess when a file is one of its own logfiles, so
1748 Normally IPython will guess when a file is one of its own logfiles, so
1749 you can typically use %run even for logs. This shorthand allows you to
1749 you can typically use %run even for logs. This shorthand allows you to
1750 force any file to be treated as a log file."""
1750 force any file to be treated as a log file."""
1751
1751
1752 for f in parameter_s.split():
1752 for f in parameter_s.split():
1753 self.shell.safe_execfile(f,self.shell.user_ns,
1753 self.shell.safe_execfile(f,self.shell.user_ns,
1754 self.shell.user_ns,islog=1)
1754 self.shell.user_ns,islog=1)
1755
1755
1756 @testdec.skip_doctest
1756 @testdec.skip_doctest
1757 def magic_timeit(self, parameter_s =''):
1757 def magic_timeit(self, parameter_s =''):
1758 """Time execution of a Python statement or expression
1758 """Time execution of a Python statement or expression
1759
1759
1760 Usage:\\
1760 Usage:\\
1761 %timeit [-n<N> -r<R> [-t|-c]] statement
1761 %timeit [-n<N> -r<R> [-t|-c]] statement
1762
1762
1763 Time execution of a Python statement or expression using the timeit
1763 Time execution of a Python statement or expression using the timeit
1764 module.
1764 module.
1765
1765
1766 Options:
1766 Options:
1767 -n<N>: execute the given statement <N> times in a loop. If this value
1767 -n<N>: execute the given statement <N> times in a loop. If this value
1768 is not given, a fitting value is chosen.
1768 is not given, a fitting value is chosen.
1769
1769
1770 -r<R>: repeat the loop iteration <R> times and take the best result.
1770 -r<R>: repeat the loop iteration <R> times and take the best result.
1771 Default: 3
1771 Default: 3
1772
1772
1773 -t: use time.time to measure the time, which is the default on Unix.
1773 -t: use time.time to measure the time, which is the default on Unix.
1774 This function measures wall time.
1774 This function measures wall time.
1775
1775
1776 -c: use time.clock to measure the time, which is the default on
1776 -c: use time.clock to measure the time, which is the default on
1777 Windows and measures wall time. On Unix, resource.getrusage is used
1777 Windows and measures wall time. On Unix, resource.getrusage is used
1778 instead and returns the CPU user time.
1778 instead and returns the CPU user time.
1779
1779
1780 -p<P>: use a precision of <P> digits to display the timing result.
1780 -p<P>: use a precision of <P> digits to display the timing result.
1781 Default: 3
1781 Default: 3
1782
1782
1783
1783
1784 Examples:
1784 Examples:
1785
1785
1786 In [1]: %timeit pass
1786 In [1]: %timeit pass
1787 10000000 loops, best of 3: 53.3 ns per loop
1787 10000000 loops, best of 3: 53.3 ns per loop
1788
1788
1789 In [2]: u = None
1789 In [2]: u = None
1790
1790
1791 In [3]: %timeit u is None
1791 In [3]: %timeit u is None
1792 10000000 loops, best of 3: 184 ns per loop
1792 10000000 loops, best of 3: 184 ns per loop
1793
1793
1794 In [4]: %timeit -r 4 u == None
1794 In [4]: %timeit -r 4 u == None
1795 1000000 loops, best of 4: 242 ns per loop
1795 1000000 loops, best of 4: 242 ns per loop
1796
1796
1797 In [5]: import time
1797 In [5]: import time
1798
1798
1799 In [6]: %timeit -n1 time.sleep(2)
1799 In [6]: %timeit -n1 time.sleep(2)
1800 1 loops, best of 3: 2 s per loop
1800 1 loops, best of 3: 2 s per loop
1801
1801
1802
1802
1803 The times reported by %timeit will be slightly higher than those
1803 The times reported by %timeit will be slightly higher than those
1804 reported by the timeit.py script when variables are accessed. This is
1804 reported by the timeit.py script when variables are accessed. This is
1805 due to the fact that %timeit executes the statement in the namespace
1805 due to the fact that %timeit executes the statement in the namespace
1806 of the shell, compared with timeit.py, which uses a single setup
1806 of the shell, compared with timeit.py, which uses a single setup
1807 statement to import function or create variables. Generally, the bias
1807 statement to import function or create variables. Generally, the bias
1808 does not matter as long as results from timeit.py are not mixed with
1808 does not matter as long as results from timeit.py are not mixed with
1809 those from %timeit."""
1809 those from %timeit."""
1810
1810
1811 import timeit
1811 import timeit
1812 import math
1812 import math
1813
1813
1814 # XXX: Unfortunately the unicode 'micro' symbol can cause problems in
1814 # XXX: Unfortunately the unicode 'micro' symbol can cause problems in
1815 # certain terminals. Until we figure out a robust way of
1815 # certain terminals. Until we figure out a robust way of
1816 # auto-detecting if the terminal can deal with it, use plain 'us' for
1816 # auto-detecting if the terminal can deal with it, use plain 'us' for
1817 # microseconds. I am really NOT happy about disabling the proper
1817 # microseconds. I am really NOT happy about disabling the proper
1818 # 'micro' prefix, but crashing is worse... If anyone knows what the
1818 # 'micro' prefix, but crashing is worse... If anyone knows what the
1819 # right solution for this is, I'm all ears...
1819 # right solution for this is, I'm all ears...
1820 #
1820 #
1821 # Note: using
1821 # Note: using
1822 #
1822 #
1823 # s = u'\xb5'
1823 # s = u'\xb5'
1824 # s.encode(sys.getdefaultencoding())
1824 # s.encode(sys.getdefaultencoding())
1825 #
1825 #
1826 # is not sufficient, as I've seen terminals where that fails but
1826 # is not sufficient, as I've seen terminals where that fails but
1827 # print s
1827 # print s
1828 #
1828 #
1829 # succeeds
1829 # succeeds
1830 #
1830 #
1831 # See bug: https://bugs.launchpad.net/ipython/+bug/348466
1831 # See bug: https://bugs.launchpad.net/ipython/+bug/348466
1832
1832
1833 #units = [u"s", u"ms",u'\xb5',"ns"]
1833 #units = [u"s", u"ms",u'\xb5',"ns"]
1834 units = [u"s", u"ms",u'us',"ns"]
1834 units = [u"s", u"ms",u'us',"ns"]
1835
1835
1836 scaling = [1, 1e3, 1e6, 1e9]
1836 scaling = [1, 1e3, 1e6, 1e9]
1837
1837
1838 opts, stmt = self.parse_options(parameter_s,'n:r:tcp:',
1838 opts, stmt = self.parse_options(parameter_s,'n:r:tcp:',
1839 posix=False)
1839 posix=False)
1840 if stmt == "":
1840 if stmt == "":
1841 return
1841 return
1842 timefunc = timeit.default_timer
1842 timefunc = timeit.default_timer
1843 number = int(getattr(opts, "n", 0))
1843 number = int(getattr(opts, "n", 0))
1844 repeat = int(getattr(opts, "r", timeit.default_repeat))
1844 repeat = int(getattr(opts, "r", timeit.default_repeat))
1845 precision = int(getattr(opts, "p", 3))
1845 precision = int(getattr(opts, "p", 3))
1846 if hasattr(opts, "t"):
1846 if hasattr(opts, "t"):
1847 timefunc = time.time
1847 timefunc = time.time
1848 if hasattr(opts, "c"):
1848 if hasattr(opts, "c"):
1849 timefunc = clock
1849 timefunc = clock
1850
1850
1851 timer = timeit.Timer(timer=timefunc)
1851 timer = timeit.Timer(timer=timefunc)
1852 # this code has tight coupling to the inner workings of timeit.Timer,
1852 # this code has tight coupling to the inner workings of timeit.Timer,
1853 # but is there a better way to achieve that the code stmt has access
1853 # but is there a better way to achieve that the code stmt has access
1854 # to the shell namespace?
1854 # to the shell namespace?
1855
1855
1856 src = timeit.template % {'stmt': timeit.reindent(stmt, 8),
1856 src = timeit.template % {'stmt': timeit.reindent(stmt, 8),
1857 'setup': "pass"}
1857 'setup': "pass"}
1858 # Track compilation time so it can be reported if too long
1858 # Track compilation time so it can be reported if too long
1859 # Minimum time above which compilation time will be reported
1859 # Minimum time above which compilation time will be reported
1860 tc_min = 0.1
1860 tc_min = 0.1
1861
1861
1862 t0 = clock()
1862 t0 = clock()
1863 code = compile(src, "<magic-timeit>", "exec")
1863 code = compile(src, "<magic-timeit>", "exec")
1864 tc = clock()-t0
1864 tc = clock()-t0
1865
1865
1866 ns = {}
1866 ns = {}
1867 exec code in self.shell.user_ns, ns
1867 exec code in self.shell.user_ns, ns
1868 timer.inner = ns["inner"]
1868 timer.inner = ns["inner"]
1869
1869
1870 if number == 0:
1870 if number == 0:
1871 # determine number so that 0.2 <= total time < 2.0
1871 # determine number so that 0.2 <= total time < 2.0
1872 number = 1
1872 number = 1
1873 for i in range(1, 10):
1873 for i in range(1, 10):
1874 if timer.timeit(number) >= 0.2:
1874 if timer.timeit(number) >= 0.2:
1875 break
1875 break
1876 number *= 10
1876 number *= 10
1877
1877
1878 best = min(timer.repeat(repeat, number)) / number
1878 best = min(timer.repeat(repeat, number)) / number
1879
1879
1880 if best > 0.0:
1880 if best > 0.0:
1881 order = min(-int(math.floor(math.log10(best)) // 3), 3)
1881 order = min(-int(math.floor(math.log10(best)) // 3), 3)
1882 else:
1882 else:
1883 order = 3
1883 order = 3
1884 print u"%d loops, best of %d: %.*g %s per loop" % (number, repeat,
1884 print u"%d loops, best of %d: %.*g %s per loop" % (number, repeat,
1885 precision,
1885 precision,
1886 best * scaling[order],
1886 best * scaling[order],
1887 units[order])
1887 units[order])
1888 if tc > tc_min:
1888 if tc > tc_min:
1889 print "Compiler time: %.2f s" % tc
1889 print "Compiler time: %.2f s" % tc
1890
1890
1891 @testdec.skip_doctest
1891 @testdec.skip_doctest
1892 def magic_time(self,parameter_s = ''):
1892 def magic_time(self,parameter_s = ''):
1893 """Time execution of a Python statement or expression.
1893 """Time execution of a Python statement or expression.
1894
1894
1895 The CPU and wall clock times are printed, and the value of the
1895 The CPU and wall clock times are printed, and the value of the
1896 expression (if any) is returned. Note that under Win32, system time
1896 expression (if any) is returned. Note that under Win32, system time
1897 is always reported as 0, since it can not be measured.
1897 is always reported as 0, since it can not be measured.
1898
1898
1899 This function provides very basic timing functionality. In Python
1899 This function provides very basic timing functionality. In Python
1900 2.3, the timeit module offers more control and sophistication, so this
1900 2.3, the timeit module offers more control and sophistication, so this
1901 could be rewritten to use it (patches welcome).
1901 could be rewritten to use it (patches welcome).
1902
1902
1903 Some examples:
1903 Some examples:
1904
1904
1905 In [1]: time 2**128
1905 In [1]: time 2**128
1906 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1906 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1907 Wall time: 0.00
1907 Wall time: 0.00
1908 Out[1]: 340282366920938463463374607431768211456L
1908 Out[1]: 340282366920938463463374607431768211456L
1909
1909
1910 In [2]: n = 1000000
1910 In [2]: n = 1000000
1911
1911
1912 In [3]: time sum(range(n))
1912 In [3]: time sum(range(n))
1913 CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
1913 CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
1914 Wall time: 1.37
1914 Wall time: 1.37
1915 Out[3]: 499999500000L
1915 Out[3]: 499999500000L
1916
1916
1917 In [4]: time print 'hello world'
1917 In [4]: time print 'hello world'
1918 hello world
1918 hello world
1919 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1919 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1920 Wall time: 0.00
1920 Wall time: 0.00
1921
1921
1922 Note that the time needed by Python to compile the given expression
1922 Note that the time needed by Python to compile the given expression
1923 will be reported if it is more than 0.1s. In this example, the
1923 will be reported if it is more than 0.1s. In this example, the
1924 actual exponentiation is done by Python at compilation time, so while
1924 actual exponentiation is done by Python at compilation time, so while
1925 the expression can take a noticeable amount of time to compute, that
1925 the expression can take a noticeable amount of time to compute, that
1926 time is purely due to the compilation:
1926 time is purely due to the compilation:
1927
1927
1928 In [5]: time 3**9999;
1928 In [5]: time 3**9999;
1929 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1929 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1930 Wall time: 0.00 s
1930 Wall time: 0.00 s
1931
1931
1932 In [6]: time 3**999999;
1932 In [6]: time 3**999999;
1933 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1933 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1934 Wall time: 0.00 s
1934 Wall time: 0.00 s
1935 Compiler : 0.78 s
1935 Compiler : 0.78 s
1936 """
1936 """
1937
1937
1938 # fail immediately if the given expression can't be compiled
1938 # fail immediately if the given expression can't be compiled
1939
1939
1940 expr = self.shell.prefilter(parameter_s,False)
1940 expr = self.shell.prefilter(parameter_s,False)
1941
1941
1942 # Minimum time above which compilation time will be reported
1942 # Minimum time above which compilation time will be reported
1943 tc_min = 0.1
1943 tc_min = 0.1
1944
1944
1945 try:
1945 try:
1946 mode = 'eval'
1946 mode = 'eval'
1947 t0 = clock()
1947 t0 = clock()
1948 code = compile(expr,'<timed eval>',mode)
1948 code = compile(expr,'<timed eval>',mode)
1949 tc = clock()-t0
1949 tc = clock()-t0
1950 except SyntaxError:
1950 except SyntaxError:
1951 mode = 'exec'
1951 mode = 'exec'
1952 t0 = clock()
1952 t0 = clock()
1953 code = compile(expr,'<timed exec>',mode)
1953 code = compile(expr,'<timed exec>',mode)
1954 tc = clock()-t0
1954 tc = clock()-t0
1955 # skew measurement as little as possible
1955 # skew measurement as little as possible
1956 glob = self.shell.user_ns
1956 glob = self.shell.user_ns
1957 clk = clock2
1957 clk = clock2
1958 wtime = time.time
1958 wtime = time.time
1959 # time execution
1959 # time execution
1960 wall_st = wtime()
1960 wall_st = wtime()
1961 if mode=='eval':
1961 if mode=='eval':
1962 st = clk()
1962 st = clk()
1963 out = eval(code,glob)
1963 out = eval(code,glob)
1964 end = clk()
1964 end = clk()
1965 else:
1965 else:
1966 st = clk()
1966 st = clk()
1967 exec code in glob
1967 exec code in glob
1968 end = clk()
1968 end = clk()
1969 out = None
1969 out = None
1970 wall_end = wtime()
1970 wall_end = wtime()
1971 # Compute actual times and report
1971 # Compute actual times and report
1972 wall_time = wall_end-wall_st
1972 wall_time = wall_end-wall_st
1973 cpu_user = end[0]-st[0]
1973 cpu_user = end[0]-st[0]
1974 cpu_sys = end[1]-st[1]
1974 cpu_sys = end[1]-st[1]
1975 cpu_tot = cpu_user+cpu_sys
1975 cpu_tot = cpu_user+cpu_sys
1976 print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
1976 print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
1977 (cpu_user,cpu_sys,cpu_tot)
1977 (cpu_user,cpu_sys,cpu_tot)
1978 print "Wall time: %.2f s" % wall_time
1978 print "Wall time: %.2f s" % wall_time
1979 if tc > tc_min:
1979 if tc > tc_min:
1980 print "Compiler : %.2f s" % tc
1980 print "Compiler : %.2f s" % tc
1981 return out
1981 return out
1982
1982
1983 @testdec.skip_doctest
1983 @testdec.skip_doctest
1984 def magic_macro(self,parameter_s = ''):
1984 def magic_macro(self,parameter_s = ''):
1985 """Define a set of input lines as a macro for future re-execution.
1985 """Define a set of input lines as a macro for future re-execution.
1986
1986
1987 Usage:\\
1987 Usage:\\
1988 %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
1988 %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
1989
1989
1990 Options:
1990 Options:
1991
1991
1992 -r: use 'raw' input. By default, the 'processed' history is used,
1992 -r: use 'raw' input. By default, the 'processed' history is used,
1993 so that magics are loaded in their transformed version to valid
1993 so that magics are loaded in their transformed version to valid
1994 Python. If this option is given, the raw input as typed as the
1994 Python. If this option is given, the raw input as typed as the
1995 command line is used instead.
1995 command line is used instead.
1996
1996
1997 This will define a global variable called `name` which is a string
1997 This will define a global variable called `name` which is a string
1998 made of joining the slices and lines you specify (n1,n2,... numbers
1998 made of joining the slices and lines you specify (n1,n2,... numbers
1999 above) from your input history into a single string. This variable
1999 above) from your input history into a single string. This variable
2000 acts like an automatic function which re-executes those lines as if
2000 acts like an automatic function which re-executes those lines as if
2001 you had typed them. You just type 'name' at the prompt and the code
2001 you had typed them. You just type 'name' at the prompt and the code
2002 executes.
2002 executes.
2003
2003
2004 The notation for indicating number ranges is: n1-n2 means 'use line
2004 The notation for indicating number ranges is: n1-n2 means 'use line
2005 numbers n1,...n2' (the endpoint is included). That is, '5-7' means
2005 numbers n1,...n2' (the endpoint is included). That is, '5-7' means
2006 using the lines numbered 5,6 and 7.
2006 using the lines numbered 5,6 and 7.
2007
2007
2008 Note: as a 'hidden' feature, you can also use traditional python slice
2008 Note: as a 'hidden' feature, you can also use traditional python slice
2009 notation, where N:M means numbers N through M-1.
2009 notation, where N:M means numbers N through M-1.
2010
2010
2011 For example, if your history contains (%hist prints it):
2011 For example, if your history contains (%hist prints it):
2012
2012
2013 44: x=1
2013 44: x=1
2014 45: y=3
2014 45: y=3
2015 46: z=x+y
2015 46: z=x+y
2016 47: print x
2016 47: print x
2017 48: a=5
2017 48: a=5
2018 49: print 'x',x,'y',y
2018 49: print 'x',x,'y',y
2019
2019
2020 you can create a macro with lines 44 through 47 (included) and line 49
2020 you can create a macro with lines 44 through 47 (included) and line 49
2021 called my_macro with:
2021 called my_macro with:
2022
2022
2023 In [55]: %macro my_macro 44-47 49
2023 In [55]: %macro my_macro 44-47 49
2024
2024
2025 Now, typing `my_macro` (without quotes) will re-execute all this code
2025 Now, typing `my_macro` (without quotes) will re-execute all this code
2026 in one pass.
2026 in one pass.
2027
2027
2028 You don't need to give the line-numbers in order, and any given line
2028 You don't need to give the line-numbers in order, and any given line
2029 number can appear multiple times. You can assemble macros with any
2029 number can appear multiple times. You can assemble macros with any
2030 lines from your input history in any order.
2030 lines from your input history in any order.
2031
2031
2032 The macro is a simple object which holds its value in an attribute,
2032 The macro is a simple object which holds its value in an attribute,
2033 but IPython's display system checks for macros and executes them as
2033 but IPython's display system checks for macros and executes them as
2034 code instead of printing them when you type their name.
2034 code instead of printing them when you type their name.
2035
2035
2036 You can view a macro's contents by explicitly printing it with:
2036 You can view a macro's contents by explicitly printing it with:
2037
2037
2038 'print macro_name'.
2038 'print macro_name'.
2039
2039
2040 For one-off cases which DON'T contain magic function calls in them you
2040 For one-off cases which DON'T contain magic function calls in them you
2041 can obtain similar results by explicitly executing slices from your
2041 can obtain similar results by explicitly executing slices from your
2042 input history with:
2042 input history with:
2043
2043
2044 In [60]: exec In[44:48]+In[49]"""
2044 In [60]: exec In[44:48]+In[49]"""
2045
2045
2046 opts,args = self.parse_options(parameter_s,'r',mode='list')
2046 opts,args = self.parse_options(parameter_s,'r',mode='list')
2047 if not args:
2047 if not args:
2048 macs = [k for k,v in self.shell.user_ns.items() if isinstance(v, Macro)]
2048 macs = [k for k,v in self.shell.user_ns.items() if isinstance(v, Macro)]
2049 macs.sort()
2049 macs.sort()
2050 return macs
2050 return macs
2051 if len(args) == 1:
2051 if len(args) == 1:
2052 raise UsageError(
2052 raise UsageError(
2053 "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
2053 "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
2054 name,ranges = args[0], args[1:]
2054 name,ranges = args[0], args[1:]
2055
2055
2056 #print 'rng',ranges # dbg
2056 #print 'rng',ranges # dbg
2057 lines = self.extract_input_slices(ranges,opts.has_key('r'))
2057 lines = self.extract_input_slices(ranges,opts.has_key('r'))
2058 macro = Macro(lines)
2058 macro = Macro(lines)
2059 self.shell.user_ns.update({name:macro})
2059 self.shell.user_ns.update({name:macro})
2060 print 'Macro `%s` created. To execute, type its name (without quotes).' % name
2060 print 'Macro `%s` created. To execute, type its name (without quotes).' % name
2061 print 'Macro contents:'
2061 print 'Macro contents:'
2062 print macro,
2062 print macro,
2063
2063
2064 def magic_save(self,parameter_s = ''):
2064 def magic_save(self,parameter_s = ''):
2065 """Save a set of lines to a given filename.
2065 """Save a set of lines to a given filename.
2066
2066
2067 Usage:\\
2067 Usage:\\
2068 %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
2068 %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
2069
2069
2070 Options:
2070 Options:
2071
2071
2072 -r: use 'raw' input. By default, the 'processed' history is used,
2072 -r: use 'raw' input. By default, the 'processed' history is used,
2073 so that magics are loaded in their transformed version to valid
2073 so that magics are loaded in their transformed version to valid
2074 Python. If this option is given, the raw input as typed as the
2074 Python. If this option is given, the raw input as typed as the
2075 command line is used instead.
2075 command line is used instead.
2076
2076
2077 This function uses the same syntax as %macro for line extraction, but
2077 This function uses the same syntax as %macro for line extraction, but
2078 instead of creating a macro it saves the resulting string to the
2078 instead of creating a macro it saves the resulting string to the
2079 filename you specify.
2079 filename you specify.
2080
2080
2081 It adds a '.py' extension to the file if you don't do so yourself, and
2081 It adds a '.py' extension to the file if you don't do so yourself, and
2082 it asks for confirmation before overwriting existing files."""
2082 it asks for confirmation before overwriting existing files."""
2083
2083
2084 opts,args = self.parse_options(parameter_s,'r',mode='list')
2084 opts,args = self.parse_options(parameter_s,'r',mode='list')
2085 fname,ranges = args[0], args[1:]
2085 fname,ranges = args[0], args[1:]
2086 if not fname.endswith('.py'):
2086 if not fname.endswith('.py'):
2087 fname += '.py'
2087 fname += '.py'
2088 if os.path.isfile(fname):
2088 if os.path.isfile(fname):
2089 ans = raw_input('File `%s` exists. Overwrite (y/[N])? ' % fname)
2089 ans = raw_input('File `%s` exists. Overwrite (y/[N])? ' % fname)
2090 if ans.lower() not in ['y','yes']:
2090 if ans.lower() not in ['y','yes']:
2091 print 'Operation cancelled.'
2091 print 'Operation cancelled.'
2092 return
2092 return
2093 cmds = ''.join(self.extract_input_slices(ranges,opts.has_key('r')))
2093 cmds = ''.join(self.extract_input_slices(ranges,opts.has_key('r')))
2094 f = file(fname,'w')
2094 f = file(fname,'w')
2095 f.write(cmds)
2095 f.write(cmds)
2096 f.close()
2096 f.close()
2097 print 'The following commands were written to file `%s`:' % fname
2097 print 'The following commands were written to file `%s`:' % fname
2098 print cmds
2098 print cmds
2099
2099
2100 def _edit_macro(self,mname,macro):
2100 def _edit_macro(self,mname,macro):
2101 """open an editor with the macro data in a file"""
2101 """open an editor with the macro data in a file"""
2102 filename = self.shell.mktempfile(macro.value)
2102 filename = self.shell.mktempfile(macro.value)
2103 self.shell.hooks.editor(filename)
2103 self.shell.hooks.editor(filename)
2104
2104
2105 # and make a new macro object, to replace the old one
2105 # and make a new macro object, to replace the old one
2106 mfile = open(filename)
2106 mfile = open(filename)
2107 mvalue = mfile.read()
2107 mvalue = mfile.read()
2108 mfile.close()
2108 mfile.close()
2109 self.shell.user_ns[mname] = Macro(mvalue)
2109 self.shell.user_ns[mname] = Macro(mvalue)
2110
2110
2111 def magic_ed(self,parameter_s=''):
2111 def magic_ed(self,parameter_s=''):
2112 """Alias to %edit."""
2112 """Alias to %edit."""
2113 return self.magic_edit(parameter_s)
2113 return self.magic_edit(parameter_s)
2114
2114
2115 @testdec.skip_doctest
2115 @testdec.skip_doctest
2116 def magic_edit(self,parameter_s='',last_call=['','']):
2116 def magic_edit(self,parameter_s='',last_call=['','']):
2117 """Bring up an editor and execute the resulting code.
2117 """Bring up an editor and execute the resulting code.
2118
2118
2119 Usage:
2119 Usage:
2120 %edit [options] [args]
2120 %edit [options] [args]
2121
2121
2122 %edit runs IPython's editor hook. The default version of this hook is
2122 %edit runs IPython's editor hook. The default version of this hook is
2123 set to call the __IPYTHON__.rc.editor command. This is read from your
2123 set to call the __IPYTHON__.rc.editor command. This is read from your
2124 environment variable $EDITOR. If this isn't found, it will default to
2124 environment variable $EDITOR. If this isn't found, it will default to
2125 vi under Linux/Unix and to notepad under Windows. See the end of this
2125 vi under Linux/Unix and to notepad under Windows. See the end of this
2126 docstring for how to change the editor hook.
2126 docstring for how to change the editor hook.
2127
2127
2128 You can also set the value of this editor via the command line option
2128 You can also set the value of this editor via the command line option
2129 '-editor' or in your ipythonrc file. This is useful if you wish to use
2129 '-editor' or in your ipythonrc file. This is useful if you wish to use
2130 specifically for IPython an editor different from your typical default
2130 specifically for IPython an editor different from your typical default
2131 (and for Windows users who typically don't set environment variables).
2131 (and for Windows users who typically don't set environment variables).
2132
2132
2133 This command allows you to conveniently edit multi-line code right in
2133 This command allows you to conveniently edit multi-line code right in
2134 your IPython session.
2134 your IPython session.
2135
2135
2136 If called without arguments, %edit opens up an empty editor with a
2136 If called without arguments, %edit opens up an empty editor with a
2137 temporary file and will execute the contents of this file when you
2137 temporary file and will execute the contents of this file when you
2138 close it (don't forget to save it!).
2138 close it (don't forget to save it!).
2139
2139
2140
2140
2141 Options:
2141 Options:
2142
2142
2143 -n <number>: open the editor at a specified line number. By default,
2143 -n <number>: open the editor at a specified line number. By default,
2144 the IPython editor hook uses the unix syntax 'editor +N filename', but
2144 the IPython editor hook uses the unix syntax 'editor +N filename', but
2145 you can configure this by providing your own modified hook if your
2145 you can configure this by providing your own modified hook if your
2146 favorite editor supports line-number specifications with a different
2146 favorite editor supports line-number specifications with a different
2147 syntax.
2147 syntax.
2148
2148
2149 -p: this will call the editor with the same data as the previous time
2149 -p: this will call the editor with the same data as the previous time
2150 it was used, regardless of how long ago (in your current session) it
2150 it was used, regardless of how long ago (in your current session) it
2151 was.
2151 was.
2152
2152
2153 -r: use 'raw' input. This option only applies to input taken from the
2153 -r: use 'raw' input. This option only applies to input taken from the
2154 user's history. By default, the 'processed' history is used, so that
2154 user's history. By default, the 'processed' history is used, so that
2155 magics are loaded in their transformed version to valid Python. If
2155 magics are loaded in their transformed version to valid Python. If
2156 this option is given, the raw input as typed as the command line is
2156 this option is given, the raw input as typed as the command line is
2157 used instead. When you exit the editor, it will be executed by
2157 used instead. When you exit the editor, it will be executed by
2158 IPython's own processor.
2158 IPython's own processor.
2159
2159
2160 -x: do not execute the edited code immediately upon exit. This is
2160 -x: do not execute the edited code immediately upon exit. This is
2161 mainly useful if you are editing programs which need to be called with
2161 mainly useful if you are editing programs which need to be called with
2162 command line arguments, which you can then do using %run.
2162 command line arguments, which you can then do using %run.
2163
2163
2164
2164
2165 Arguments:
2165 Arguments:
2166
2166
2167 If arguments are given, the following possibilites exist:
2167 If arguments are given, the following possibilites exist:
2168
2168
2169 - The arguments are numbers or pairs of colon-separated numbers (like
2169 - The arguments are numbers or pairs of colon-separated numbers (like
2170 1 4:8 9). These are interpreted as lines of previous input to be
2170 1 4:8 9). These are interpreted as lines of previous input to be
2171 loaded into the editor. The syntax is the same of the %macro command.
2171 loaded into the editor. The syntax is the same of the %macro command.
2172
2172
2173 - If the argument doesn't start with a number, it is evaluated as a
2173 - If the argument doesn't start with a number, it is evaluated as a
2174 variable and its contents loaded into the editor. You can thus edit
2174 variable and its contents loaded into the editor. You can thus edit
2175 any string which contains python code (including the result of
2175 any string which contains python code (including the result of
2176 previous edits).
2176 previous edits).
2177
2177
2178 - If the argument is the name of an object (other than a string),
2178 - If the argument is the name of an object (other than a string),
2179 IPython will try to locate the file where it was defined and open the
2179 IPython will try to locate the file where it was defined and open the
2180 editor at the point where it is defined. You can use `%edit function`
2180 editor at the point where it is defined. You can use `%edit function`
2181 to load an editor exactly at the point where 'function' is defined,
2181 to load an editor exactly at the point where 'function' is defined,
2182 edit it and have the file be executed automatically.
2182 edit it and have the file be executed automatically.
2183
2183
2184 If the object is a macro (see %macro for details), this opens up your
2184 If the object is a macro (see %macro for details), this opens up your
2185 specified editor with a temporary file containing the macro's data.
2185 specified editor with a temporary file containing the macro's data.
2186 Upon exit, the macro is reloaded with the contents of the file.
2186 Upon exit, the macro is reloaded with the contents of the file.
2187
2187
2188 Note: opening at an exact line is only supported under Unix, and some
2188 Note: opening at an exact line is only supported under Unix, and some
2189 editors (like kedit and gedit up to Gnome 2.8) do not understand the
2189 editors (like kedit and gedit up to Gnome 2.8) do not understand the
2190 '+NUMBER' parameter necessary for this feature. Good editors like
2190 '+NUMBER' parameter necessary for this feature. Good editors like
2191 (X)Emacs, vi, jed, pico and joe all do.
2191 (X)Emacs, vi, jed, pico and joe all do.
2192
2192
2193 - If the argument is not found as a variable, IPython will look for a
2193 - If the argument is not found as a variable, IPython will look for a
2194 file with that name (adding .py if necessary) and load it into the
2194 file with that name (adding .py if necessary) and load it into the
2195 editor. It will execute its contents with execfile() when you exit,
2195 editor. It will execute its contents with execfile() when you exit,
2196 loading any code in the file into your interactive namespace.
2196 loading any code in the file into your interactive namespace.
2197
2197
2198 After executing your code, %edit will return as output the code you
2198 After executing your code, %edit will return as output the code you
2199 typed in the editor (except when it was an existing file). This way
2199 typed in the editor (except when it was an existing file). This way
2200 you can reload the code in further invocations of %edit as a variable,
2200 you can reload the code in further invocations of %edit as a variable,
2201 via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
2201 via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
2202 the output.
2202 the output.
2203
2203
2204 Note that %edit is also available through the alias %ed.
2204 Note that %edit is also available through the alias %ed.
2205
2205
2206 This is an example of creating a simple function inside the editor and
2206 This is an example of creating a simple function inside the editor and
2207 then modifying it. First, start up the editor:
2207 then modifying it. First, start up the editor:
2208
2208
2209 In [1]: ed
2209 In [1]: ed
2210 Editing... done. Executing edited code...
2210 Editing... done. Executing edited code...
2211 Out[1]: 'def foo():n print "foo() was defined in an editing session"n'
2211 Out[1]: 'def foo():n print "foo() was defined in an editing session"n'
2212
2212
2213 We can then call the function foo():
2213 We can then call the function foo():
2214
2214
2215 In [2]: foo()
2215 In [2]: foo()
2216 foo() was defined in an editing session
2216 foo() was defined in an editing session
2217
2217
2218 Now we edit foo. IPython automatically loads the editor with the
2218 Now we edit foo. IPython automatically loads the editor with the
2219 (temporary) file where foo() was previously defined:
2219 (temporary) file where foo() was previously defined:
2220
2220
2221 In [3]: ed foo
2221 In [3]: ed foo
2222 Editing... done. Executing edited code...
2222 Editing... done. Executing edited code...
2223
2223
2224 And if we call foo() again we get the modified version:
2224 And if we call foo() again we get the modified version:
2225
2225
2226 In [4]: foo()
2226 In [4]: foo()
2227 foo() has now been changed!
2227 foo() has now been changed!
2228
2228
2229 Here is an example of how to edit a code snippet successive
2229 Here is an example of how to edit a code snippet successive
2230 times. First we call the editor:
2230 times. First we call the editor:
2231
2231
2232 In [5]: ed
2232 In [5]: ed
2233 Editing... done. Executing edited code...
2233 Editing... done. Executing edited code...
2234 hello
2234 hello
2235 Out[5]: "print 'hello'n"
2235 Out[5]: "print 'hello'n"
2236
2236
2237 Now we call it again with the previous output (stored in _):
2237 Now we call it again with the previous output (stored in _):
2238
2238
2239 In [6]: ed _
2239 In [6]: ed _
2240 Editing... done. Executing edited code...
2240 Editing... done. Executing edited code...
2241 hello world
2241 hello world
2242 Out[6]: "print 'hello world'n"
2242 Out[6]: "print 'hello world'n"
2243
2243
2244 Now we call it with the output #8 (stored in _8, also as Out[8]):
2244 Now we call it with the output #8 (stored in _8, also as Out[8]):
2245
2245
2246 In [7]: ed _8
2246 In [7]: ed _8
2247 Editing... done. Executing edited code...
2247 Editing... done. Executing edited code...
2248 hello again
2248 hello again
2249 Out[7]: "print 'hello again'n"
2249 Out[7]: "print 'hello again'n"
2250
2250
2251
2251
2252 Changing the default editor hook:
2252 Changing the default editor hook:
2253
2253
2254 If you wish to write your own editor hook, you can put it in a
2254 If you wish to write your own editor hook, you can put it in a
2255 configuration file which you load at startup time. The default hook
2255 configuration file which you load at startup time. The default hook
2256 is defined in the IPython.hooks module, and you can use that as a
2256 is defined in the IPython.hooks module, and you can use that as a
2257 starting example for further modifications. That file also has
2257 starting example for further modifications. That file also has
2258 general instructions on how to set a new hook for use once you've
2258 general instructions on how to set a new hook for use once you've
2259 defined it."""
2259 defined it."""
2260
2260
2261 # FIXME: This function has become a convoluted mess. It needs a
2261 # FIXME: This function has become a convoluted mess. It needs a
2262 # ground-up rewrite with clean, simple logic.
2262 # ground-up rewrite with clean, simple logic.
2263
2263
2264 def make_filename(arg):
2264 def make_filename(arg):
2265 "Make a filename from the given args"
2265 "Make a filename from the given args"
2266 try:
2266 try:
2267 filename = get_py_filename(arg)
2267 filename = get_py_filename(arg)
2268 except IOError:
2268 except IOError:
2269 if args.endswith('.py'):
2269 if args.endswith('.py'):
2270 filename = arg
2270 filename = arg
2271 else:
2271 else:
2272 filename = None
2272 filename = None
2273 return filename
2273 return filename
2274
2274
2275 # custom exceptions
2275 # custom exceptions
2276 class DataIsObject(Exception): pass
2276 class DataIsObject(Exception): pass
2277
2277
2278 opts,args = self.parse_options(parameter_s,'prxn:')
2278 opts,args = self.parse_options(parameter_s,'prxn:')
2279 # Set a few locals from the options for convenience:
2279 # Set a few locals from the options for convenience:
2280 opts_p = opts.has_key('p')
2280 opts_p = opts.has_key('p')
2281 opts_r = opts.has_key('r')
2281 opts_r = opts.has_key('r')
2282
2282
2283 # Default line number value
2283 # Default line number value
2284 lineno = opts.get('n',None)
2284 lineno = opts.get('n',None)
2285
2285
2286 if opts_p:
2286 if opts_p:
2287 args = '_%s' % last_call[0]
2287 args = '_%s' % last_call[0]
2288 if not self.shell.user_ns.has_key(args):
2288 if not self.shell.user_ns.has_key(args):
2289 args = last_call[1]
2289 args = last_call[1]
2290
2290
2291 # use last_call to remember the state of the previous call, but don't
2291 # use last_call to remember the state of the previous call, but don't
2292 # let it be clobbered by successive '-p' calls.
2292 # let it be clobbered by successive '-p' calls.
2293 try:
2293 try:
2294 last_call[0] = self.shell.outputcache.prompt_count
2294 last_call[0] = self.shell.outputcache.prompt_count
2295 if not opts_p:
2295 if not opts_p:
2296 last_call[1] = parameter_s
2296 last_call[1] = parameter_s
2297 except:
2297 except:
2298 pass
2298 pass
2299
2299
2300 # by default this is done with temp files, except when the given
2300 # by default this is done with temp files, except when the given
2301 # arg is a filename
2301 # arg is a filename
2302 use_temp = 1
2302 use_temp = 1
2303
2303
2304 if re.match(r'\d',args):
2304 if re.match(r'\d',args):
2305 # Mode where user specifies ranges of lines, like in %macro.
2305 # Mode where user specifies ranges of lines, like in %macro.
2306 # This means that you can't edit files whose names begin with
2306 # This means that you can't edit files whose names begin with
2307 # numbers this way. Tough.
2307 # numbers this way. Tough.
2308 ranges = args.split()
2308 ranges = args.split()
2309 data = ''.join(self.extract_input_slices(ranges,opts_r))
2309 data = ''.join(self.extract_input_slices(ranges,opts_r))
2310 elif args.endswith('.py'):
2310 elif args.endswith('.py'):
2311 filename = make_filename(args)
2311 filename = make_filename(args)
2312 data = ''
2312 data = ''
2313 use_temp = 0
2313 use_temp = 0
2314 elif args:
2314 elif args:
2315 try:
2315 try:
2316 # Load the parameter given as a variable. If not a string,
2316 # Load the parameter given as a variable. If not a string,
2317 # process it as an object instead (below)
2317 # process it as an object instead (below)
2318
2318
2319 #print '*** args',args,'type',type(args) # dbg
2319 #print '*** args',args,'type',type(args) # dbg
2320 data = eval(args,self.shell.user_ns)
2320 data = eval(args,self.shell.user_ns)
2321 if not type(data) in StringTypes:
2321 if not type(data) in StringTypes:
2322 raise DataIsObject
2322 raise DataIsObject
2323
2323
2324 except (NameError,SyntaxError):
2324 except (NameError,SyntaxError):
2325 # given argument is not a variable, try as a filename
2325 # given argument is not a variable, try as a filename
2326 filename = make_filename(args)
2326 filename = make_filename(args)
2327 if filename is None:
2327 if filename is None:
2328 warn("Argument given (%s) can't be found as a variable "
2328 warn("Argument given (%s) can't be found as a variable "
2329 "or as a filename." % args)
2329 "or as a filename." % args)
2330 return
2330 return
2331
2331
2332 data = ''
2332 data = ''
2333 use_temp = 0
2333 use_temp = 0
2334 except DataIsObject:
2334 except DataIsObject:
2335
2335
2336 # macros have a special edit function
2336 # macros have a special edit function
2337 if isinstance(data,Macro):
2337 if isinstance(data,Macro):
2338 self._edit_macro(args,data)
2338 self._edit_macro(args,data)
2339 return
2339 return
2340
2340
2341 # For objects, try to edit the file where they are defined
2341 # For objects, try to edit the file where they are defined
2342 try:
2342 try:
2343 filename = inspect.getabsfile(data)
2343 filename = inspect.getabsfile(data)
2344 if 'fakemodule' in filename.lower() and inspect.isclass(data):
2344 if 'fakemodule' in filename.lower() and inspect.isclass(data):
2345 # class created by %edit? Try to find source
2345 # class created by %edit? Try to find source
2346 # by looking for method definitions instead, the
2346 # by looking for method definitions instead, the
2347 # __module__ in those classes is FakeModule.
2347 # __module__ in those classes is FakeModule.
2348 attrs = [getattr(data, aname) for aname in dir(data)]
2348 attrs = [getattr(data, aname) for aname in dir(data)]
2349 for attr in attrs:
2349 for attr in attrs:
2350 if not inspect.ismethod(attr):
2350 if not inspect.ismethod(attr):
2351 continue
2351 continue
2352 filename = inspect.getabsfile(attr)
2352 filename = inspect.getabsfile(attr)
2353 if filename and 'fakemodule' not in filename.lower():
2353 if filename and 'fakemodule' not in filename.lower():
2354 # change the attribute to be the edit target instead
2354 # change the attribute to be the edit target instead
2355 data = attr
2355 data = attr
2356 break
2356 break
2357
2357
2358 datafile = 1
2358 datafile = 1
2359 except TypeError:
2359 except TypeError:
2360 filename = make_filename(args)
2360 filename = make_filename(args)
2361 datafile = 1
2361 datafile = 1
2362 warn('Could not find file where `%s` is defined.\n'
2362 warn('Could not find file where `%s` is defined.\n'
2363 'Opening a file named `%s`' % (args,filename))
2363 'Opening a file named `%s`' % (args,filename))
2364 # Now, make sure we can actually read the source (if it was in
2364 # Now, make sure we can actually read the source (if it was in
2365 # a temp file it's gone by now).
2365 # a temp file it's gone by now).
2366 if datafile:
2366 if datafile:
2367 try:
2367 try:
2368 if lineno is None:
2368 if lineno is None:
2369 lineno = inspect.getsourcelines(data)[1]
2369 lineno = inspect.getsourcelines(data)[1]
2370 except IOError:
2370 except IOError:
2371 filename = make_filename(args)
2371 filename = make_filename(args)
2372 if filename is None:
2372 if filename is None:
2373 warn('The file `%s` where `%s` was defined cannot '
2373 warn('The file `%s` where `%s` was defined cannot '
2374 'be read.' % (filename,data))
2374 'be read.' % (filename,data))
2375 return
2375 return
2376 use_temp = 0
2376 use_temp = 0
2377 else:
2377 else:
2378 data = ''
2378 data = ''
2379
2379
2380 if use_temp:
2380 if use_temp:
2381 filename = self.shell.mktempfile(data)
2381 filename = self.shell.mktempfile(data)
2382 print 'IPython will make a temporary file named:',filename
2382 print 'IPython will make a temporary file named:',filename
2383
2383
2384 # do actual editing here
2384 # do actual editing here
2385 print 'Editing...',
2385 print 'Editing...',
2386 sys.stdout.flush()
2386 sys.stdout.flush()
2387 try:
2387 try:
2388 self.shell.hooks.editor(filename,lineno)
2388 self.shell.hooks.editor(filename,lineno)
2389 except IPython.ipapi.TryNext:
2389 except IPython.ipapi.TryNext:
2390 warn('Could not open editor')
2390 warn('Could not open editor')
2391 return
2391 return
2392
2392
2393 # XXX TODO: should this be generalized for all string vars?
2393 # XXX TODO: should this be generalized for all string vars?
2394 # For now, this is special-cased to blocks created by cpaste
2394 # For now, this is special-cased to blocks created by cpaste
2395 if args.strip() == 'pasted_block':
2395 if args.strip() == 'pasted_block':
2396 self.shell.user_ns['pasted_block'] = file_read(filename)
2396 self.shell.user_ns['pasted_block'] = file_read(filename)
2397
2397
2398 if opts.has_key('x'): # -x prevents actual execution
2398 if opts.has_key('x'): # -x prevents actual execution
2399 print
2399 print
2400 else:
2400 else:
2401 print 'done. Executing edited code...'
2401 print 'done. Executing edited code...'
2402 if opts_r:
2402 if opts_r:
2403 self.shell.runlines(file_read(filename))
2403 self.shell.runlines(file_read(filename))
2404 else:
2404 else:
2405 self.shell.safe_execfile(filename,self.shell.user_ns,
2405 self.shell.safe_execfile(filename,self.shell.user_ns,
2406 self.shell.user_ns)
2406 self.shell.user_ns)
2407
2407
2408
2408
2409 if use_temp:
2409 if use_temp:
2410 try:
2410 try:
2411 return open(filename).read()
2411 return open(filename).read()
2412 except IOError,msg:
2412 except IOError,msg:
2413 if msg.filename == filename:
2413 if msg.filename == filename:
2414 warn('File not found. Did you forget to save?')
2414 warn('File not found. Did you forget to save?')
2415 return
2415 return
2416 else:
2416 else:
2417 self.shell.showtraceback()
2417 self.shell.showtraceback()
2418
2418
2419 def magic_xmode(self,parameter_s = ''):
2419 def magic_xmode(self,parameter_s = ''):
2420 """Switch modes for the exception handlers.
2420 """Switch modes for the exception handlers.
2421
2421
2422 Valid modes: Plain, Context and Verbose.
2422 Valid modes: Plain, Context and Verbose.
2423
2423
2424 If called without arguments, acts as a toggle."""
2424 If called without arguments, acts as a toggle."""
2425
2425
2426 def xmode_switch_err(name):
2426 def xmode_switch_err(name):
2427 warn('Error changing %s exception modes.\n%s' %
2427 warn('Error changing %s exception modes.\n%s' %
2428 (name,sys.exc_info()[1]))
2428 (name,sys.exc_info()[1]))
2429
2429
2430 shell = self.shell
2430 shell = self.shell
2431 new_mode = parameter_s.strip().capitalize()
2431 new_mode = parameter_s.strip().capitalize()
2432 try:
2432 try:
2433 shell.InteractiveTB.set_mode(mode=new_mode)
2433 shell.InteractiveTB.set_mode(mode=new_mode)
2434 print 'Exception reporting mode:',shell.InteractiveTB.mode
2434 print 'Exception reporting mode:',shell.InteractiveTB.mode
2435 except:
2435 except:
2436 xmode_switch_err('user')
2436 xmode_switch_err('user')
2437
2437
2438 # threaded shells use a special handler in sys.excepthook
2438 # threaded shells use a special handler in sys.excepthook
2439 if shell.isthreaded:
2439 if shell.isthreaded:
2440 try:
2440 try:
2441 shell.sys_excepthook.set_mode(mode=new_mode)
2441 shell.sys_excepthook.set_mode(mode=new_mode)
2442 except:
2442 except:
2443 xmode_switch_err('threaded')
2443 xmode_switch_err('threaded')
2444
2444
2445 def magic_colors(self,parameter_s = ''):
2445 def magic_colors(self,parameter_s = ''):
2446 """Switch color scheme for prompts, info system and exception handlers.
2446 """Switch color scheme for prompts, info system and exception handlers.
2447
2447
2448 Currently implemented schemes: NoColor, Linux, LightBG.
2448 Currently implemented schemes: NoColor, Linux, LightBG.
2449
2449
2450 Color scheme names are not case-sensitive."""
2450 Color scheme names are not case-sensitive."""
2451
2451
2452 def color_switch_err(name):
2452 def color_switch_err(name):
2453 warn('Error changing %s color schemes.\n%s' %
2453 warn('Error changing %s color schemes.\n%s' %
2454 (name,sys.exc_info()[1]))
2454 (name,sys.exc_info()[1]))
2455
2455
2456
2456
2457 new_scheme = parameter_s.strip()
2457 new_scheme = parameter_s.strip()
2458 if not new_scheme:
2458 if not new_scheme:
2459 raise UsageError(
2459 raise UsageError(
2460 "%colors: you must specify a color scheme. See '%colors?'")
2460 "%colors: you must specify a color scheme. See '%colors?'")
2461 return
2461 return
2462 # local shortcut
2462 # local shortcut
2463 shell = self.shell
2463 shell = self.shell
2464
2464
2465 import IPython.rlineimpl as readline
2465 import IPython.rlineimpl as readline
2466
2466
2467 if not readline.have_readline and sys.platform == "win32":
2467 if not readline.have_readline and sys.platform == "win32":
2468 msg = """\
2468 msg = """\
2469 Proper color support under MS Windows requires the pyreadline library.
2469 Proper color support under MS Windows requires the pyreadline library.
2470 You can find it at:
2470 You can find it at:
2471 http://ipython.scipy.org/moin/PyReadline/Intro
2471 http://ipython.scipy.org/moin/PyReadline/Intro
2472 Gary's readline needs the ctypes module, from:
2472 Gary's readline needs the ctypes module, from:
2473 http://starship.python.net/crew/theller/ctypes
2473 http://starship.python.net/crew/theller/ctypes
2474 (Note that ctypes is already part of Python versions 2.5 and newer).
2474 (Note that ctypes is already part of Python versions 2.5 and newer).
2475
2475
2476 Defaulting color scheme to 'NoColor'"""
2476 Defaulting color scheme to 'NoColor'"""
2477 new_scheme = 'NoColor'
2477 new_scheme = 'NoColor'
2478 warn(msg)
2478 warn(msg)
2479
2479
2480 # readline option is 0
2480 # readline option is 0
2481 if not shell.has_readline:
2481 if not shell.has_readline:
2482 new_scheme = 'NoColor'
2482 new_scheme = 'NoColor'
2483
2483
2484 # Set prompt colors
2484 # Set prompt colors
2485 try:
2485 try:
2486 shell.outputcache.set_colors(new_scheme)
2486 shell.outputcache.set_colors(new_scheme)
2487 except:
2487 except:
2488 color_switch_err('prompt')
2488 color_switch_err('prompt')
2489 else:
2489 else:
2490 shell.rc.colors = \
2490 shell.rc.colors = \
2491 shell.outputcache.color_table.active_scheme_name
2491 shell.outputcache.color_table.active_scheme_name
2492 # Set exception colors
2492 # Set exception colors
2493 try:
2493 try:
2494 shell.InteractiveTB.set_colors(scheme = new_scheme)
2494 shell.InteractiveTB.set_colors(scheme = new_scheme)
2495 shell.SyntaxTB.set_colors(scheme = new_scheme)
2495 shell.SyntaxTB.set_colors(scheme = new_scheme)
2496 except:
2496 except:
2497 color_switch_err('exception')
2497 color_switch_err('exception')
2498
2498
2499 # threaded shells use a verbose traceback in sys.excepthook
2499 # threaded shells use a verbose traceback in sys.excepthook
2500 if shell.isthreaded:
2500 if shell.isthreaded:
2501 try:
2501 try:
2502 shell.sys_excepthook.set_colors(scheme=new_scheme)
2502 shell.sys_excepthook.set_colors(scheme=new_scheme)
2503 except:
2503 except:
2504 color_switch_err('system exception handler')
2504 color_switch_err('system exception handler')
2505
2505
2506 # Set info (for 'object?') colors
2506 # Set info (for 'object?') colors
2507 if shell.rc.color_info:
2507 if shell.rc.color_info:
2508 try:
2508 try:
2509 shell.inspector.set_active_scheme(new_scheme)
2509 shell.inspector.set_active_scheme(new_scheme)
2510 except:
2510 except:
2511 color_switch_err('object inspector')
2511 color_switch_err('object inspector')
2512 else:
2512 else:
2513 shell.inspector.set_active_scheme('NoColor')
2513 shell.inspector.set_active_scheme('NoColor')
2514
2514
2515 def magic_color_info(self,parameter_s = ''):
2515 def magic_color_info(self,parameter_s = ''):
2516 """Toggle color_info.
2516 """Toggle color_info.
2517
2517
2518 The color_info configuration parameter controls whether colors are
2518 The color_info configuration parameter controls whether colors are
2519 used for displaying object details (by things like %psource, %pfile or
2519 used for displaying object details (by things like %psource, %pfile or
2520 the '?' system). This function toggles this value with each call.
2520 the '?' system). This function toggles this value with each call.
2521
2521
2522 Note that unless you have a fairly recent pager (less works better
2522 Note that unless you have a fairly recent pager (less works better
2523 than more) in your system, using colored object information displays
2523 than more) in your system, using colored object information displays
2524 will not work properly. Test it and see."""
2524 will not work properly. Test it and see."""
2525
2525
2526 self.shell.rc.color_info = 1 - self.shell.rc.color_info
2526 self.shell.rc.color_info = 1 - self.shell.rc.color_info
2527 self.magic_colors(self.shell.rc.colors)
2527 self.magic_colors(self.shell.rc.colors)
2528 print 'Object introspection functions have now coloring:',
2528 print 'Object introspection functions have now coloring:',
2529 print ['OFF','ON'][self.shell.rc.color_info]
2529 print ['OFF','ON'][self.shell.rc.color_info]
2530
2530
2531 def magic_Pprint(self, parameter_s=''):
2531 def magic_Pprint(self, parameter_s=''):
2532 """Toggle pretty printing on/off."""
2532 """Toggle pretty printing on/off."""
2533
2533
2534 self.shell.rc.pprint = 1 - self.shell.rc.pprint
2534 self.shell.rc.pprint = 1 - self.shell.rc.pprint
2535 print 'Pretty printing has been turned', \
2535 print 'Pretty printing has been turned', \
2536 ['OFF','ON'][self.shell.rc.pprint]
2536 ['OFF','ON'][self.shell.rc.pprint]
2537
2537
2538 def magic_exit(self, parameter_s=''):
2538 def magic_exit(self, parameter_s=''):
2539 """Exit IPython, confirming if configured to do so.
2539 """Exit IPython, confirming if configured to do so.
2540
2540
2541 You can configure whether IPython asks for confirmation upon exit by
2541 You can configure whether IPython asks for confirmation upon exit by
2542 setting the confirm_exit flag in the ipythonrc file."""
2542 setting the confirm_exit flag in the ipythonrc file."""
2543
2543
2544 self.shell.exit()
2544 self.shell.exit()
2545
2545
2546 def magic_quit(self, parameter_s=''):
2546 def magic_quit(self, parameter_s=''):
2547 """Exit IPython, confirming if configured to do so (like %exit)"""
2547 """Exit IPython, confirming if configured to do so (like %exit)"""
2548
2548
2549 self.shell.exit()
2549 self.shell.exit()
2550
2550
2551 def magic_Exit(self, parameter_s=''):
2551 def magic_Exit(self, parameter_s=''):
2552 """Exit IPython without confirmation."""
2552 """Exit IPython without confirmation."""
2553
2553
2554 self.shell.ask_exit()
2554 self.shell.ask_exit()
2555
2555
2556 #......................................................................
2556 #......................................................................
2557 # Functions to implement unix shell-type things
2557 # Functions to implement unix shell-type things
2558
2558
2559 @testdec.skip_doctest
2559 @testdec.skip_doctest
2560 def magic_alias(self, parameter_s = ''):
2560 def magic_alias(self, parameter_s = ''):
2561 """Define an alias for a system command.
2561 """Define an alias for a system command.
2562
2562
2563 '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
2563 '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
2564
2564
2565 Then, typing 'alias_name params' will execute the system command 'cmd
2565 Then, typing 'alias_name params' will execute the system command 'cmd
2566 params' (from your underlying operating system).
2566 params' (from your underlying operating system).
2567
2567
2568 Aliases have lower precedence than magic functions and Python normal
2568 Aliases have lower precedence than magic functions and Python normal
2569 variables, so if 'foo' is both a Python variable and an alias, the
2569 variables, so if 'foo' is both a Python variable and an alias, the
2570 alias can not be executed until 'del foo' removes the Python variable.
2570 alias can not be executed until 'del foo' removes the Python variable.
2571
2571
2572 You can use the %l specifier in an alias definition to represent the
2572 You can use the %l specifier in an alias definition to represent the
2573 whole line when the alias is called. For example:
2573 whole line when the alias is called. For example:
2574
2574
2575 In [2]: alias all echo "Input in brackets: <%l>"
2575 In [2]: alias all echo "Input in brackets: <%l>"
2576 In [3]: all hello world
2576 In [3]: all hello world
2577 Input in brackets: <hello world>
2577 Input in brackets: <hello world>
2578
2578
2579 You can also define aliases with parameters using %s specifiers (one
2579 You can also define aliases with parameters using %s specifiers (one
2580 per parameter):
2580 per parameter):
2581
2581
2582 In [1]: alias parts echo first %s second %s
2582 In [1]: alias parts echo first %s second %s
2583 In [2]: %parts A B
2583 In [2]: %parts A B
2584 first A second B
2584 first A second B
2585 In [3]: %parts A
2585 In [3]: %parts A
2586 Incorrect number of arguments: 2 expected.
2586 Incorrect number of arguments: 2 expected.
2587 parts is an alias to: 'echo first %s second %s'
2587 parts is an alias to: 'echo first %s second %s'
2588
2588
2589 Note that %l and %s are mutually exclusive. You can only use one or
2589 Note that %l and %s are mutually exclusive. You can only use one or
2590 the other in your aliases.
2590 the other in your aliases.
2591
2591
2592 Aliases expand Python variables just like system calls using ! or !!
2592 Aliases expand Python variables just like system calls using ! or !!
2593 do: all expressions prefixed with '$' get expanded. For details of
2593 do: all expressions prefixed with '$' get expanded. For details of
2594 the semantic rules, see PEP-215:
2594 the semantic rules, see PEP-215:
2595 http://www.python.org/peps/pep-0215.html. This is the library used by
2595 http://www.python.org/peps/pep-0215.html. This is the library used by
2596 IPython for variable expansion. If you want to access a true shell
2596 IPython for variable expansion. If you want to access a true shell
2597 variable, an extra $ is necessary to prevent its expansion by IPython:
2597 variable, an extra $ is necessary to prevent its expansion by IPython:
2598
2598
2599 In [6]: alias show echo
2599 In [6]: alias show echo
2600 In [7]: PATH='A Python string'
2600 In [7]: PATH='A Python string'
2601 In [8]: show $PATH
2601 In [8]: show $PATH
2602 A Python string
2602 A Python string
2603 In [9]: show $$PATH
2603 In [9]: show $$PATH
2604 /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
2604 /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
2605
2605
2606 You can use the alias facility to acess all of $PATH. See the %rehash
2606 You can use the alias facility to acess all of $PATH. See the %rehash
2607 and %rehashx functions, which automatically create aliases for the
2607 and %rehashx functions, which automatically create aliases for the
2608 contents of your $PATH.
2608 contents of your $PATH.
2609
2609
2610 If called with no parameters, %alias prints the current alias table."""
2610 If called with no parameters, %alias prints the current alias table."""
2611
2611
2612 par = parameter_s.strip()
2612 par = parameter_s.strip()
2613 if not par:
2613 if not par:
2614 stored = self.db.get('stored_aliases', {} )
2614 stored = self.db.get('stored_aliases', {} )
2615 atab = self.shell.alias_table
2615 atab = self.shell.alias_table
2616 aliases = atab.keys()
2616 aliases = atab.keys()
2617 aliases.sort()
2617 aliases.sort()
2618 res = []
2618 res = []
2619 showlast = []
2619 showlast = []
2620 for alias in aliases:
2620 for alias in aliases:
2621 special = False
2621 special = False
2622 try:
2622 try:
2623 tgt = atab[alias][1]
2623 tgt = atab[alias][1]
2624 except (TypeError, AttributeError):
2624 except (TypeError, AttributeError):
2625 # unsubscriptable? probably a callable
2625 # unsubscriptable? probably a callable
2626 tgt = atab[alias]
2626 tgt = atab[alias]
2627 special = True
2627 special = True
2628 # 'interesting' aliases
2628 # 'interesting' aliases
2629 if (alias in stored or
2629 if (alias in stored or
2630 special or
2630 special or
2631 alias.lower() != os.path.splitext(tgt)[0].lower() or
2631 alias.lower() != os.path.splitext(tgt)[0].lower() or
2632 ' ' in tgt):
2632 ' ' in tgt):
2633 showlast.append((alias, tgt))
2633 showlast.append((alias, tgt))
2634 else:
2634 else:
2635 res.append((alias, tgt ))
2635 res.append((alias, tgt ))
2636
2636
2637 # show most interesting aliases last
2637 # show most interesting aliases last
2638 res.extend(showlast)
2638 res.extend(showlast)
2639 print "Total number of aliases:",len(aliases)
2639 print "Total number of aliases:",len(aliases)
2640 return res
2640 return res
2641 try:
2641 try:
2642 alias,cmd = par.split(None,1)
2642 alias,cmd = par.split(None,1)
2643 except:
2643 except:
2644 print OInspect.getdoc(self.magic_alias)
2644 print OInspect.getdoc(self.magic_alias)
2645 else:
2645 else:
2646 nargs = cmd.count('%s')
2646 nargs = cmd.count('%s')
2647 if nargs>0 and cmd.find('%l')>=0:
2647 if nargs>0 and cmd.find('%l')>=0:
2648 error('The %s and %l specifiers are mutually exclusive '
2648 error('The %s and %l specifiers are mutually exclusive '
2649 'in alias definitions.')
2649 'in alias definitions.')
2650 else: # all looks OK
2650 else: # all looks OK
2651 self.shell.alias_table[alias] = (nargs,cmd)
2651 self.shell.alias_table[alias] = (nargs,cmd)
2652 self.shell.alias_table_validate(verbose=0)
2652 self.shell.alias_table_validate(verbose=0)
2653 # end magic_alias
2653 # end magic_alias
2654
2654
2655 def magic_unalias(self, parameter_s = ''):
2655 def magic_unalias(self, parameter_s = ''):
2656 """Remove an alias"""
2656 """Remove an alias"""
2657
2657
2658 aname = parameter_s.strip()
2658 aname = parameter_s.strip()
2659 if aname in self.shell.alias_table:
2659 if aname in self.shell.alias_table:
2660 del self.shell.alias_table[aname]
2660 del self.shell.alias_table[aname]
2661 stored = self.db.get('stored_aliases', {} )
2661 stored = self.db.get('stored_aliases', {} )
2662 if aname in stored:
2662 if aname in stored:
2663 print "Removing %stored alias",aname
2663 print "Removing %stored alias",aname
2664 del stored[aname]
2664 del stored[aname]
2665 self.db['stored_aliases'] = stored
2665 self.db['stored_aliases'] = stored
2666
2666
2667
2667
2668 def magic_rehashx(self, parameter_s = ''):
2668 def magic_rehashx(self, parameter_s = ''):
2669 """Update the alias table with all executable files in $PATH.
2669 """Update the alias table with all executable files in $PATH.
2670
2670
2671 This version explicitly checks that every entry in $PATH is a file
2671 This version explicitly checks that every entry in $PATH is a file
2672 with execute access (os.X_OK), so it is much slower than %rehash.
2672 with execute access (os.X_OK), so it is much slower than %rehash.
2673
2673
2674 Under Windows, it checks executability as a match agains a
2674 Under Windows, it checks executability as a match agains a
2675 '|'-separated string of extensions, stored in the IPython config
2675 '|'-separated string of extensions, stored in the IPython config
2676 variable win_exec_ext. This defaults to 'exe|com|bat'.
2676 variable win_exec_ext. This defaults to 'exe|com|bat'.
2677
2677
2678 This function also resets the root module cache of module completer,
2678 This function also resets the root module cache of module completer,
2679 used on slow filesystems.
2679 used on slow filesystems.
2680 """
2680 """
2681
2681
2682
2682
2683 ip = self.api
2683 ip = self.api
2684
2684
2685 # for the benefit of module completer in ipy_completers.py
2685 # for the benefit of module completer in ipy_completers.py
2686 del ip.db['rootmodules']
2686 del ip.db['rootmodules']
2687
2687
2688 path = [os.path.abspath(os.path.expanduser(p)) for p in
2688 path = [os.path.abspath(os.path.expanduser(p)) for p in
2689 os.environ.get('PATH','').split(os.pathsep)]
2689 os.environ.get('PATH','').split(os.pathsep)]
2690 path = filter(os.path.isdir,path)
2690 path = filter(os.path.isdir,path)
2691
2691
2692 alias_table = self.shell.alias_table
2692 alias_table = self.shell.alias_table
2693 syscmdlist = []
2693 syscmdlist = []
2694 if os.name == 'posix':
2694 if os.name == 'posix':
2695 isexec = lambda fname:os.path.isfile(fname) and \
2695 isexec = lambda fname:os.path.isfile(fname) and \
2696 os.access(fname,os.X_OK)
2696 os.access(fname,os.X_OK)
2697 else:
2697 else:
2698
2698
2699 try:
2699 try:
2700 winext = os.environ['pathext'].replace(';','|').replace('.','')
2700 winext = os.environ['pathext'].replace(';','|').replace('.','')
2701 except KeyError:
2701 except KeyError:
2702 winext = 'exe|com|bat|py'
2702 winext = 'exe|com|bat|py'
2703 if 'py' not in winext:
2703 if 'py' not in winext:
2704 winext += '|py'
2704 winext += '|py'
2705 execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
2705 execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
2706 isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
2706 isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
2707 savedir = os.getcwd()
2707 savedir = os.getcwd()
2708 try:
2708 try:
2709 # write the whole loop for posix/Windows so we don't have an if in
2709 # write the whole loop for posix/Windows so we don't have an if in
2710 # the innermost part
2710 # the innermost part
2711 if os.name == 'posix':
2711 if os.name == 'posix':
2712 for pdir in path:
2712 for pdir in path:
2713 os.chdir(pdir)
2713 os.chdir(pdir)
2714 for ff in os.listdir(pdir):
2714 for ff in os.listdir(pdir):
2715 if isexec(ff) and ff not in self.shell.no_alias:
2715 if isexec(ff) and ff not in self.shell.no_alias:
2716 # each entry in the alias table must be (N,name),
2716 # each entry in the alias table must be (N,name),
2717 # where N is the number of positional arguments of the
2717 # where N is the number of positional arguments of the
2718 # alias.
2718 # alias.
2719 # Dots will be removed from alias names, since ipython
2719 # Dots will be removed from alias names, since ipython
2720 # assumes names with dots to be python code
2720 # assumes names with dots to be python code
2721 alias_table[ff.replace('.','')] = (0,ff)
2721 alias_table[ff.replace('.','')] = (0,ff)
2722 syscmdlist.append(ff)
2722 syscmdlist.append(ff)
2723 else:
2723 else:
2724 for pdir in path:
2724 for pdir in path:
2725 os.chdir(pdir)
2725 os.chdir(pdir)
2726 for ff in os.listdir(pdir):
2726 for ff in os.listdir(pdir):
2727 base, ext = os.path.splitext(ff)
2727 base, ext = os.path.splitext(ff)
2728 if isexec(ff) and base.lower() not in self.shell.no_alias:
2728 if isexec(ff) and base.lower() not in self.shell.no_alias:
2729 if ext.lower() == '.exe':
2729 if ext.lower() == '.exe':
2730 ff = base
2730 ff = base
2731 alias_table[base.lower().replace('.','')] = (0,ff)
2731 alias_table[base.lower().replace('.','')] = (0,ff)
2732 syscmdlist.append(ff)
2732 syscmdlist.append(ff)
2733 # Make sure the alias table doesn't contain keywords or builtins
2733 # Make sure the alias table doesn't contain keywords or builtins
2734 self.shell.alias_table_validate()
2734 self.shell.alias_table_validate()
2735 # Call again init_auto_alias() so we get 'rm -i' and other
2735 # Call again init_auto_alias() so we get 'rm -i' and other
2736 # modified aliases since %rehashx will probably clobber them
2736 # modified aliases since %rehashx will probably clobber them
2737
2737
2738 # no, we don't want them. if %rehashx clobbers them, good,
2738 # no, we don't want them. if %rehashx clobbers them, good,
2739 # we'll probably get better versions
2739 # we'll probably get better versions
2740 # self.shell.init_auto_alias()
2740 # self.shell.init_auto_alias()
2741 db = ip.db
2741 db = ip.db
2742 db['syscmdlist'] = syscmdlist
2742 db['syscmdlist'] = syscmdlist
2743 finally:
2743 finally:
2744 os.chdir(savedir)
2744 os.chdir(savedir)
2745
2745
2746 def magic_pwd(self, parameter_s = ''):
2746 def magic_pwd(self, parameter_s = ''):
2747 """Return the current working directory path."""
2747 """Return the current working directory path."""
2748 return os.getcwd()
2748 return os.getcwd()
2749
2749
2750 def magic_cd(self, parameter_s=''):
2750 def magic_cd(self, parameter_s=''):
2751 """Change the current working directory.
2751 """Change the current working directory.
2752
2752
2753 This command automatically maintains an internal list of directories
2753 This command automatically maintains an internal list of directories
2754 you visit during your IPython session, in the variable _dh. The
2754 you visit during your IPython session, in the variable _dh. The
2755 command %dhist shows this history nicely formatted. You can also
2755 command %dhist shows this history nicely formatted. You can also
2756 do 'cd -<tab>' to see directory history conveniently.
2756 do 'cd -<tab>' to see directory history conveniently.
2757
2757
2758 Usage:
2758 Usage:
2759
2759
2760 cd 'dir': changes to directory 'dir'.
2760 cd 'dir': changes to directory 'dir'.
2761
2761
2762 cd -: changes to the last visited directory.
2762 cd -: changes to the last visited directory.
2763
2763
2764 cd -<n>: changes to the n-th directory in the directory history.
2764 cd -<n>: changes to the n-th directory in the directory history.
2765
2765
2766 cd --foo: change to directory that matches 'foo' in history
2766 cd --foo: change to directory that matches 'foo' in history
2767
2767
2768 cd -b <bookmark_name>: jump to a bookmark set by %bookmark
2768 cd -b <bookmark_name>: jump to a bookmark set by %bookmark
2769 (note: cd <bookmark_name> is enough if there is no
2769 (note: cd <bookmark_name> is enough if there is no
2770 directory <bookmark_name>, but a bookmark with the name exists.)
2770 directory <bookmark_name>, but a bookmark with the name exists.)
2771 'cd -b <tab>' allows you to tab-complete bookmark names.
2771 'cd -b <tab>' allows you to tab-complete bookmark names.
2772
2772
2773 Options:
2773 Options:
2774
2774
2775 -q: quiet. Do not print the working directory after the cd command is
2775 -q: quiet. Do not print the working directory after the cd command is
2776 executed. By default IPython's cd command does print this directory,
2776 executed. By default IPython's cd command does print this directory,
2777 since the default prompts do not display path information.
2777 since the default prompts do not display path information.
2778
2778
2779 Note that !cd doesn't work for this purpose because the shell where
2779 Note that !cd doesn't work for this purpose because the shell where
2780 !command runs is immediately discarded after executing 'command'."""
2780 !command runs is immediately discarded after executing 'command'."""
2781
2781
2782 parameter_s = parameter_s.strip()
2782 parameter_s = parameter_s.strip()
2783 #bkms = self.shell.persist.get("bookmarks",{})
2783 #bkms = self.shell.persist.get("bookmarks",{})
2784
2784
2785 oldcwd = os.getcwd()
2785 oldcwd = os.getcwd()
2786 numcd = re.match(r'(-)(\d+)$',parameter_s)
2786 numcd = re.match(r'(-)(\d+)$',parameter_s)
2787 # jump in directory history by number
2787 # jump in directory history by number
2788 if numcd:
2788 if numcd:
2789 nn = int(numcd.group(2))
2789 nn = int(numcd.group(2))
2790 try:
2790 try:
2791 ps = self.shell.user_ns['_dh'][nn]
2791 ps = self.shell.user_ns['_dh'][nn]
2792 except IndexError:
2792 except IndexError:
2793 print 'The requested directory does not exist in history.'
2793 print 'The requested directory does not exist in history.'
2794 return
2794 return
2795 else:
2795 else:
2796 opts = {}
2796 opts = {}
2797 elif parameter_s.startswith('--'):
2797 elif parameter_s.startswith('--'):
2798 ps = None
2798 ps = None
2799 fallback = None
2799 fallback = None
2800 pat = parameter_s[2:]
2800 pat = parameter_s[2:]
2801 dh = self.shell.user_ns['_dh']
2801 dh = self.shell.user_ns['_dh']
2802 # first search only by basename (last component)
2802 # first search only by basename (last component)
2803 for ent in reversed(dh):
2803 for ent in reversed(dh):
2804 if pat in os.path.basename(ent) and os.path.isdir(ent):
2804 if pat in os.path.basename(ent) and os.path.isdir(ent):
2805 ps = ent
2805 ps = ent
2806 break
2806 break
2807
2807
2808 if fallback is None and pat in ent and os.path.isdir(ent):
2808 if fallback is None and pat in ent and os.path.isdir(ent):
2809 fallback = ent
2809 fallback = ent
2810
2810
2811 # if we have no last part match, pick the first full path match
2811 # if we have no last part match, pick the first full path match
2812 if ps is None:
2812 if ps is None:
2813 ps = fallback
2813 ps = fallback
2814
2814
2815 if ps is None:
2815 if ps is None:
2816 print "No matching entry in directory history"
2816 print "No matching entry in directory history"
2817 return
2817 return
2818 else:
2818 else:
2819 opts = {}
2819 opts = {}
2820
2820
2821
2821
2822 else:
2822 else:
2823 #turn all non-space-escaping backslashes to slashes,
2823 #turn all non-space-escaping backslashes to slashes,
2824 # for c:\windows\directory\names\
2824 # for c:\windows\directory\names\
2825 parameter_s = re.sub(r'\\(?! )','/', parameter_s)
2825 parameter_s = re.sub(r'\\(?! )','/', parameter_s)
2826 opts,ps = self.parse_options(parameter_s,'qb',mode='string')
2826 opts,ps = self.parse_options(parameter_s,'qb',mode='string')
2827 # jump to previous
2827 # jump to previous
2828 if ps == '-':
2828 if ps == '-':
2829 try:
2829 try:
2830 ps = self.shell.user_ns['_dh'][-2]
2830 ps = self.shell.user_ns['_dh'][-2]
2831 except IndexError:
2831 except IndexError:
2832 raise UsageError('%cd -: No previous directory to change to.')
2832 raise UsageError('%cd -: No previous directory to change to.')
2833 # jump to bookmark if needed
2833 # jump to bookmark if needed
2834 else:
2834 else:
2835 if not os.path.isdir(ps) or opts.has_key('b'):
2835 if not os.path.isdir(ps) or opts.has_key('b'):
2836 bkms = self.db.get('bookmarks', {})
2836 bkms = self.db.get('bookmarks', {})
2837
2837
2838 if bkms.has_key(ps):
2838 if bkms.has_key(ps):
2839 target = bkms[ps]
2839 target = bkms[ps]
2840 print '(bookmark:%s) -> %s' % (ps,target)
2840 print '(bookmark:%s) -> %s' % (ps,target)
2841 ps = target
2841 ps = target
2842 else:
2842 else:
2843 if opts.has_key('b'):
2843 if opts.has_key('b'):
2844 raise UsageError("Bookmark '%s' not found. "
2844 raise UsageError("Bookmark '%s' not found. "
2845 "Use '%%bookmark -l' to see your bookmarks." % ps)
2845 "Use '%%bookmark -l' to see your bookmarks." % ps)
2846
2846
2847 # at this point ps should point to the target dir
2847 # at this point ps should point to the target dir
2848 if ps:
2848 if ps:
2849 try:
2849 try:
2850 os.chdir(os.path.expanduser(ps))
2850 os.chdir(os.path.expanduser(ps))
2851 if self.shell.rc.term_title:
2851 if self.shell.rc.term_title:
2852 #print 'set term title:',self.shell.rc.term_title # dbg
2852 #print 'set term title:',self.shell.rc.term_title # dbg
2853 platutils.set_term_title('IPy ' + abbrev_cwd())
2853 platutils.set_term_title('IPy ' + abbrev_cwd())
2854 except OSError:
2854 except OSError:
2855 print sys.exc_info()[1]
2855 print sys.exc_info()[1]
2856 else:
2856 else:
2857 cwd = os.getcwd()
2857 cwd = os.getcwd()
2858 dhist = self.shell.user_ns['_dh']
2858 dhist = self.shell.user_ns['_dh']
2859 if oldcwd != cwd:
2859 if oldcwd != cwd:
2860 dhist.append(cwd)
2860 dhist.append(cwd)
2861 self.db['dhist'] = compress_dhist(dhist)[-100:]
2861 self.db['dhist'] = compress_dhist(dhist)[-100:]
2862
2862
2863 else:
2863 else:
2864 os.chdir(self.shell.home_dir)
2864 os.chdir(self.shell.home_dir)
2865 if self.shell.rc.term_title:
2865 if self.shell.rc.term_title:
2866 platutils.set_term_title("IPy ~")
2866 platutils.set_term_title("IPy ~")
2867 cwd = os.getcwd()
2867 cwd = os.getcwd()
2868 dhist = self.shell.user_ns['_dh']
2868 dhist = self.shell.user_ns['_dh']
2869
2869
2870 if oldcwd != cwd:
2870 if oldcwd != cwd:
2871 dhist.append(cwd)
2871 dhist.append(cwd)
2872 self.db['dhist'] = compress_dhist(dhist)[-100:]
2872 self.db['dhist'] = compress_dhist(dhist)[-100:]
2873 if not 'q' in opts and self.shell.user_ns['_dh']:
2873 if not 'q' in opts and self.shell.user_ns['_dh']:
2874 print self.shell.user_ns['_dh'][-1]
2874 print self.shell.user_ns['_dh'][-1]
2875
2875
2876
2876
2877 def magic_env(self, parameter_s=''):
2877 def magic_env(self, parameter_s=''):
2878 """List environment variables."""
2878 """List environment variables."""
2879
2879
2880 return os.environ.data
2880 return os.environ.data
2881
2881
2882 def magic_pushd(self, parameter_s=''):
2882 def magic_pushd(self, parameter_s=''):
2883 """Place the current dir on stack and change directory.
2883 """Place the current dir on stack and change directory.
2884
2884
2885 Usage:\\
2885 Usage:\\
2886 %pushd ['dirname']
2886 %pushd ['dirname']
2887 """
2887 """
2888
2888
2889 dir_s = self.shell.dir_stack
2889 dir_s = self.shell.dir_stack
2890 tgt = os.path.expanduser(parameter_s)
2890 tgt = os.path.expanduser(parameter_s)
2891 cwd = os.getcwd().replace(self.home_dir,'~')
2891 cwd = os.getcwd().replace(self.home_dir,'~')
2892 if tgt:
2892 if tgt:
2893 self.magic_cd(parameter_s)
2893 self.magic_cd(parameter_s)
2894 dir_s.insert(0,cwd)
2894 dir_s.insert(0,cwd)
2895 return self.magic_dirs()
2895 return self.magic_dirs()
2896
2896
2897 def magic_popd(self, parameter_s=''):
2897 def magic_popd(self, parameter_s=''):
2898 """Change to directory popped off the top of the stack.
2898 """Change to directory popped off the top of the stack.
2899 """
2899 """
2900 if not self.shell.dir_stack:
2900 if not self.shell.dir_stack:
2901 raise UsageError("%popd on empty stack")
2901 raise UsageError("%popd on empty stack")
2902 top = self.shell.dir_stack.pop(0)
2902 top = self.shell.dir_stack.pop(0)
2903 self.magic_cd(top)
2903 self.magic_cd(top)
2904 print "popd ->",top
2904 print "popd ->",top
2905
2905
2906 def magic_dirs(self, parameter_s=''):
2906 def magic_dirs(self, parameter_s=''):
2907 """Return the current directory stack."""
2907 """Return the current directory stack."""
2908
2908
2909 return self.shell.dir_stack
2909 return self.shell.dir_stack
2910
2910
2911 def magic_dhist(self, parameter_s=''):
2911 def magic_dhist(self, parameter_s=''):
2912 """Print your history of visited directories.
2912 """Print your history of visited directories.
2913
2913
2914 %dhist -> print full history\\
2914 %dhist -> print full history\\
2915 %dhist n -> print last n entries only\\
2915 %dhist n -> print last n entries only\\
2916 %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\\
2916 %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\\
2917
2917
2918 This history is automatically maintained by the %cd command, and
2918 This history is automatically maintained by the %cd command, and
2919 always available as the global list variable _dh. You can use %cd -<n>
2919 always available as the global list variable _dh. You can use %cd -<n>
2920 to go to directory number <n>.
2920 to go to directory number <n>.
2921
2921
2922 Note that most of time, you should view directory history by entering
2922 Note that most of time, you should view directory history by entering
2923 cd -<TAB>.
2923 cd -<TAB>.
2924
2924
2925 """
2925 """
2926
2926
2927 dh = self.shell.user_ns['_dh']
2927 dh = self.shell.user_ns['_dh']
2928 if parameter_s:
2928 if parameter_s:
2929 try:
2929 try:
2930 args = map(int,parameter_s.split())
2930 args = map(int,parameter_s.split())
2931 except:
2931 except:
2932 self.arg_err(Magic.magic_dhist)
2932 self.arg_err(Magic.magic_dhist)
2933 return
2933 return
2934 if len(args) == 1:
2934 if len(args) == 1:
2935 ini,fin = max(len(dh)-(args[0]),0),len(dh)
2935 ini,fin = max(len(dh)-(args[0]),0),len(dh)
2936 elif len(args) == 2:
2936 elif len(args) == 2:
2937 ini,fin = args
2937 ini,fin = args
2938 else:
2938 else:
2939 self.arg_err(Magic.magic_dhist)
2939 self.arg_err(Magic.magic_dhist)
2940 return
2940 return
2941 else:
2941 else:
2942 ini,fin = 0,len(dh)
2942 ini,fin = 0,len(dh)
2943 nlprint(dh,
2943 nlprint(dh,
2944 header = 'Directory history (kept in _dh)',
2944 header = 'Directory history (kept in _dh)',
2945 start=ini,stop=fin)
2945 start=ini,stop=fin)
2946
2946
2947 @testdec.skip_doctest
2947 @testdec.skip_doctest
2948 def magic_sc(self, parameter_s=''):
2948 def magic_sc(self, parameter_s=''):
2949 """Shell capture - execute a shell command and capture its output.
2949 """Shell capture - execute a shell command and capture its output.
2950
2950
2951 DEPRECATED. Suboptimal, retained for backwards compatibility.
2951 DEPRECATED. Suboptimal, retained for backwards compatibility.
2952
2952
2953 You should use the form 'var = !command' instead. Example:
2953 You should use the form 'var = !command' instead. Example:
2954
2954
2955 "%sc -l myfiles = ls ~" should now be written as
2955 "%sc -l myfiles = ls ~" should now be written as
2956
2956
2957 "myfiles = !ls ~"
2957 "myfiles = !ls ~"
2958
2958
2959 myfiles.s, myfiles.l and myfiles.n still apply as documented
2959 myfiles.s, myfiles.l and myfiles.n still apply as documented
2960 below.
2960 below.
2961
2961
2962 --
2962 --
2963 %sc [options] varname=command
2963 %sc [options] varname=command
2964
2964
2965 IPython will run the given command using commands.getoutput(), and
2965 IPython will run the given command using commands.getoutput(), and
2966 will then update the user's interactive namespace with a variable
2966 will then update the user's interactive namespace with a variable
2967 called varname, containing the value of the call. Your command can
2967 called varname, containing the value of the call. Your command can
2968 contain shell wildcards, pipes, etc.
2968 contain shell wildcards, pipes, etc.
2969
2969
2970 The '=' sign in the syntax is mandatory, and the variable name you
2970 The '=' sign in the syntax is mandatory, and the variable name you
2971 supply must follow Python's standard conventions for valid names.
2971 supply must follow Python's standard conventions for valid names.
2972
2972
2973 (A special format without variable name exists for internal use)
2973 (A special format without variable name exists for internal use)
2974
2974
2975 Options:
2975 Options:
2976
2976
2977 -l: list output. Split the output on newlines into a list before
2977 -l: list output. Split the output on newlines into a list before
2978 assigning it to the given variable. By default the output is stored
2978 assigning it to the given variable. By default the output is stored
2979 as a single string.
2979 as a single string.
2980
2980
2981 -v: verbose. Print the contents of the variable.
2981 -v: verbose. Print the contents of the variable.
2982
2982
2983 In most cases you should not need to split as a list, because the
2983 In most cases you should not need to split as a list, because the
2984 returned value is a special type of string which can automatically
2984 returned value is a special type of string which can automatically
2985 provide its contents either as a list (split on newlines) or as a
2985 provide its contents either as a list (split on newlines) or as a
2986 space-separated string. These are convenient, respectively, either
2986 space-separated string. These are convenient, respectively, either
2987 for sequential processing or to be passed to a shell command.
2987 for sequential processing or to be passed to a shell command.
2988
2988
2989 For example:
2989 For example:
2990
2990
2991 # all-random
2991 # all-random
2992
2992
2993 # Capture into variable a
2993 # Capture into variable a
2994 In [1]: sc a=ls *py
2994 In [1]: sc a=ls *py
2995
2995
2996 # a is a string with embedded newlines
2996 # a is a string with embedded newlines
2997 In [2]: a
2997 In [2]: a
2998 Out[2]: 'setup.py\\nwin32_manual_post_install.py'
2998 Out[2]: 'setup.py\\nwin32_manual_post_install.py'
2999
2999
3000 # which can be seen as a list:
3000 # which can be seen as a list:
3001 In [3]: a.l
3001 In [3]: a.l
3002 Out[3]: ['setup.py', 'win32_manual_post_install.py']
3002 Out[3]: ['setup.py', 'win32_manual_post_install.py']
3003
3003
3004 # or as a whitespace-separated string:
3004 # or as a whitespace-separated string:
3005 In [4]: a.s
3005 In [4]: a.s
3006 Out[4]: 'setup.py win32_manual_post_install.py'
3006 Out[4]: 'setup.py win32_manual_post_install.py'
3007
3007
3008 # a.s is useful to pass as a single command line:
3008 # a.s is useful to pass as a single command line:
3009 In [5]: !wc -l $a.s
3009 In [5]: !wc -l $a.s
3010 146 setup.py
3010 146 setup.py
3011 130 win32_manual_post_install.py
3011 130 win32_manual_post_install.py
3012 276 total
3012 276 total
3013
3013
3014 # while the list form is useful to loop over:
3014 # while the list form is useful to loop over:
3015 In [6]: for f in a.l:
3015 In [6]: for f in a.l:
3016 ...: !wc -l $f
3016 ...: !wc -l $f
3017 ...:
3017 ...:
3018 146 setup.py
3018 146 setup.py
3019 130 win32_manual_post_install.py
3019 130 win32_manual_post_install.py
3020
3020
3021 Similiarly, the lists returned by the -l option are also special, in
3021 Similiarly, the lists returned by the -l option are also special, in
3022 the sense that you can equally invoke the .s attribute on them to
3022 the sense that you can equally invoke the .s attribute on them to
3023 automatically get a whitespace-separated string from their contents:
3023 automatically get a whitespace-separated string from their contents:
3024
3024
3025 In [7]: sc -l b=ls *py
3025 In [7]: sc -l b=ls *py
3026
3026
3027 In [8]: b
3027 In [8]: b
3028 Out[8]: ['setup.py', 'win32_manual_post_install.py']
3028 Out[8]: ['setup.py', 'win32_manual_post_install.py']
3029
3029
3030 In [9]: b.s
3030 In [9]: b.s
3031 Out[9]: 'setup.py win32_manual_post_install.py'
3031 Out[9]: 'setup.py win32_manual_post_install.py'
3032
3032
3033 In summary, both the lists and strings used for ouptut capture have
3033 In summary, both the lists and strings used for ouptut capture have
3034 the following special attributes:
3034 the following special attributes:
3035
3035
3036 .l (or .list) : value as list.
3036 .l (or .list) : value as list.
3037 .n (or .nlstr): value as newline-separated string.
3037 .n (or .nlstr): value as newline-separated string.
3038 .s (or .spstr): value as space-separated string.
3038 .s (or .spstr): value as space-separated string.
3039 """
3039 """
3040
3040
3041 opts,args = self.parse_options(parameter_s,'lv')
3041 opts,args = self.parse_options(parameter_s,'lv')
3042 # Try to get a variable name and command to run
3042 # Try to get a variable name and command to run
3043 try:
3043 try:
3044 # the variable name must be obtained from the parse_options
3044 # the variable name must be obtained from the parse_options
3045 # output, which uses shlex.split to strip options out.
3045 # output, which uses shlex.split to strip options out.
3046 var,_ = args.split('=',1)
3046 var,_ = args.split('=',1)
3047 var = var.strip()
3047 var = var.strip()
3048 # But the the command has to be extracted from the original input
3048 # But the the command has to be extracted from the original input
3049 # parameter_s, not on what parse_options returns, to avoid the
3049 # parameter_s, not on what parse_options returns, to avoid the
3050 # quote stripping which shlex.split performs on it.
3050 # quote stripping which shlex.split performs on it.
3051 _,cmd = parameter_s.split('=',1)
3051 _,cmd = parameter_s.split('=',1)
3052 except ValueError:
3052 except ValueError:
3053 var,cmd = '',''
3053 var,cmd = '',''
3054 # If all looks ok, proceed
3054 # If all looks ok, proceed
3055 out,err = self.shell.getoutputerror(cmd)
3055 out,err = self.shell.getoutputerror(cmd)
3056 if err:
3056 if err:
3057 print >> Term.cerr,err
3057 print >> Term.cerr,err
3058 if opts.has_key('l'):
3058 if opts.has_key('l'):
3059 out = SList(out.split('\n'))
3059 out = SList(out.split('\n'))
3060 else:
3060 else:
3061 out = LSString(out)
3061 out = LSString(out)
3062 if opts.has_key('v'):
3062 if opts.has_key('v'):
3063 print '%s ==\n%s' % (var,pformat(out))
3063 print '%s ==\n%s' % (var,pformat(out))
3064 if var:
3064 if var:
3065 self.shell.user_ns.update({var:out})
3065 self.shell.user_ns.update({var:out})
3066 else:
3066 else:
3067 return out
3067 return out
3068
3068
3069 def magic_sx(self, parameter_s=''):
3069 def magic_sx(self, parameter_s=''):
3070 """Shell execute - run a shell command and capture its output.
3070 """Shell execute - run a shell command and capture its output.
3071
3071
3072 %sx command
3072 %sx command
3073
3073
3074 IPython will run the given command using commands.getoutput(), and
3074 IPython will run the given command using commands.getoutput(), and
3075 return the result formatted as a list (split on '\\n'). Since the
3075 return the result formatted as a list (split on '\\n'). Since the
3076 output is _returned_, it will be stored in ipython's regular output
3076 output is _returned_, it will be stored in ipython's regular output
3077 cache Out[N] and in the '_N' automatic variables.
3077 cache Out[N] and in the '_N' automatic variables.
3078
3078
3079 Notes:
3079 Notes:
3080
3080
3081 1) If an input line begins with '!!', then %sx is automatically
3081 1) If an input line begins with '!!', then %sx is automatically
3082 invoked. That is, while:
3082 invoked. That is, while:
3083 !ls
3083 !ls
3084 causes ipython to simply issue system('ls'), typing
3084 causes ipython to simply issue system('ls'), typing
3085 !!ls
3085 !!ls
3086 is a shorthand equivalent to:
3086 is a shorthand equivalent to:
3087 %sx ls
3087 %sx ls
3088
3088
3089 2) %sx differs from %sc in that %sx automatically splits into a list,
3089 2) %sx differs from %sc in that %sx automatically splits into a list,
3090 like '%sc -l'. The reason for this is to make it as easy as possible
3090 like '%sc -l'. The reason for this is to make it as easy as possible
3091 to process line-oriented shell output via further python commands.
3091 to process line-oriented shell output via further python commands.
3092 %sc is meant to provide much finer control, but requires more
3092 %sc is meant to provide much finer control, but requires more
3093 typing.
3093 typing.
3094
3094
3095 3) Just like %sc -l, this is a list with special attributes:
3095 3) Just like %sc -l, this is a list with special attributes:
3096
3096
3097 .l (or .list) : value as list.
3097 .l (or .list) : value as list.
3098 .n (or .nlstr): value as newline-separated string.
3098 .n (or .nlstr): value as newline-separated string.
3099 .s (or .spstr): value as whitespace-separated string.
3099 .s (or .spstr): value as whitespace-separated string.
3100
3100
3101 This is very useful when trying to use such lists as arguments to
3101 This is very useful when trying to use such lists as arguments to
3102 system commands."""
3102 system commands."""
3103
3103
3104 if parameter_s:
3104 if parameter_s:
3105 out,err = self.shell.getoutputerror(parameter_s)
3105 out,err = self.shell.getoutputerror(parameter_s)
3106 if err:
3106 if err:
3107 print >> Term.cerr,err
3107 print >> Term.cerr,err
3108 return SList(out.split('\n'))
3108 return SList(out.split('\n'))
3109
3109
3110 def magic_bg(self, parameter_s=''):
3110 def magic_bg(self, parameter_s=''):
3111 """Run a job in the background, in a separate thread.
3111 """Run a job in the background, in a separate thread.
3112
3112
3113 For example,
3113 For example,
3114
3114
3115 %bg myfunc(x,y,z=1)
3115 %bg myfunc(x,y,z=1)
3116
3116
3117 will execute 'myfunc(x,y,z=1)' in a background thread. As soon as the
3117 will execute 'myfunc(x,y,z=1)' in a background thread. As soon as the
3118 execution starts, a message will be printed indicating the job
3118 execution starts, a message will be printed indicating the job
3119 number. If your job number is 5, you can use
3119 number. If your job number is 5, you can use
3120
3120
3121 myvar = jobs.result(5) or myvar = jobs[5].result
3121 myvar = jobs.result(5) or myvar = jobs[5].result
3122
3122
3123 to assign this result to variable 'myvar'.
3123 to assign this result to variable 'myvar'.
3124
3124
3125 IPython has a job manager, accessible via the 'jobs' object. You can
3125 IPython has a job manager, accessible via the 'jobs' object. You can
3126 type jobs? to get more information about it, and use jobs.<TAB> to see
3126 type jobs? to get more information about it, and use jobs.<TAB> to see
3127 its attributes. All attributes not starting with an underscore are
3127 its attributes. All attributes not starting with an underscore are
3128 meant for public use.
3128 meant for public use.
3129
3129
3130 In particular, look at the jobs.new() method, which is used to create
3130 In particular, look at the jobs.new() method, which is used to create
3131 new jobs. This magic %bg function is just a convenience wrapper
3131 new jobs. This magic %bg function is just a convenience wrapper
3132 around jobs.new(), for expression-based jobs. If you want to create a
3132 around jobs.new(), for expression-based jobs. If you want to create a
3133 new job with an explicit function object and arguments, you must call
3133 new job with an explicit function object and arguments, you must call
3134 jobs.new() directly.
3134 jobs.new() directly.
3135
3135
3136 The jobs.new docstring also describes in detail several important
3136 The jobs.new docstring also describes in detail several important
3137 caveats associated with a thread-based model for background job
3137 caveats associated with a thread-based model for background job
3138 execution. Type jobs.new? for details.
3138 execution. Type jobs.new? for details.
3139
3139
3140 You can check the status of all jobs with jobs.status().
3140 You can check the status of all jobs with jobs.status().
3141
3141
3142 The jobs variable is set by IPython into the Python builtin namespace.
3142 The jobs variable is set by IPython into the Python builtin namespace.
3143 If you ever declare a variable named 'jobs', you will shadow this
3143 If you ever declare a variable named 'jobs', you will shadow this
3144 name. You can either delete your global jobs variable to regain
3144 name. You can either delete your global jobs variable to regain
3145 access to the job manager, or make a new name and assign it manually
3145 access to the job manager, or make a new name and assign it manually
3146 to the manager (stored in IPython's namespace). For example, to
3146 to the manager (stored in IPython's namespace). For example, to
3147 assign the job manager to the Jobs name, use:
3147 assign the job manager to the Jobs name, use:
3148
3148
3149 Jobs = __builtins__.jobs"""
3149 Jobs = __builtins__.jobs"""
3150
3150
3151 self.shell.jobs.new(parameter_s,self.shell.user_ns)
3151 self.shell.jobs.new(parameter_s,self.shell.user_ns)
3152
3152
3153 def magic_r(self, parameter_s=''):
3153 def magic_r(self, parameter_s=''):
3154 """Repeat previous input.
3154 """Repeat previous input.
3155
3155
3156 Note: Consider using the more powerfull %rep instead!
3156 Note: Consider using the more powerfull %rep instead!
3157
3157
3158 If given an argument, repeats the previous command which starts with
3158 If given an argument, repeats the previous command which starts with
3159 the same string, otherwise it just repeats the previous input.
3159 the same string, otherwise it just repeats the previous input.
3160
3160
3161 Shell escaped commands (with ! as first character) are not recognized
3161 Shell escaped commands (with ! as first character) are not recognized
3162 by this system, only pure python code and magic commands.
3162 by this system, only pure python code and magic commands.
3163 """
3163 """
3164
3164
3165 start = parameter_s.strip()
3165 start = parameter_s.strip()
3166 esc_magic = self.shell.ESC_MAGIC
3166 esc_magic = self.shell.ESC_MAGIC
3167 # Identify magic commands even if automagic is on (which means
3167 # Identify magic commands even if automagic is on (which means
3168 # the in-memory version is different from that typed by the user).
3168 # the in-memory version is different from that typed by the user).
3169 if self.shell.rc.automagic:
3169 if self.shell.rc.automagic:
3170 start_magic = esc_magic+start
3170 start_magic = esc_magic+start
3171 else:
3171 else:
3172 start_magic = start
3172 start_magic = start
3173 # Look through the input history in reverse
3173 # Look through the input history in reverse
3174 for n in range(len(self.shell.input_hist)-2,0,-1):
3174 for n in range(len(self.shell.input_hist)-2,0,-1):
3175 input = self.shell.input_hist[n]
3175 input = self.shell.input_hist[n]
3176 # skip plain 'r' lines so we don't recurse to infinity
3176 # skip plain 'r' lines so we don't recurse to infinity
3177 if input != '_ip.magic("r")\n' and \
3177 if input != '_ip.magic("r")\n' and \
3178 (input.startswith(start) or input.startswith(start_magic)):
3178 (input.startswith(start) or input.startswith(start_magic)):
3179 #print 'match',`input` # dbg
3179 #print 'match',`input` # dbg
3180 print 'Executing:',input,
3180 print 'Executing:',input,
3181 self.shell.runlines(input)
3181 self.shell.runlines(input)
3182 return
3182 return
3183 print 'No previous input matching `%s` found.' % start
3183 print 'No previous input matching `%s` found.' % start
3184
3184
3185
3185
3186 def magic_bookmark(self, parameter_s=''):
3186 def magic_bookmark(self, parameter_s=''):
3187 """Manage IPython's bookmark system.
3187 """Manage IPython's bookmark system.
3188
3188
3189 %bookmark <name> - set bookmark to current dir
3189 %bookmark <name> - set bookmark to current dir
3190 %bookmark <name> <dir> - set bookmark to <dir>
3190 %bookmark <name> <dir> - set bookmark to <dir>
3191 %bookmark -l - list all bookmarks
3191 %bookmark -l - list all bookmarks
3192 %bookmark -d <name> - remove bookmark
3192 %bookmark -d <name> - remove bookmark
3193 %bookmark -r - remove all bookmarks
3193 %bookmark -r - remove all bookmarks
3194
3194
3195 You can later on access a bookmarked folder with:
3195 You can later on access a bookmarked folder with:
3196 %cd -b <name>
3196 %cd -b <name>
3197 or simply '%cd <name>' if there is no directory called <name> AND
3197 or simply '%cd <name>' if there is no directory called <name> AND
3198 there is such a bookmark defined.
3198 there is such a bookmark defined.
3199
3199
3200 Your bookmarks persist through IPython sessions, but they are
3200 Your bookmarks persist through IPython sessions, but they are
3201 associated with each profile."""
3201 associated with each profile."""
3202
3202
3203 opts,args = self.parse_options(parameter_s,'drl',mode='list')
3203 opts,args = self.parse_options(parameter_s,'drl',mode='list')
3204 if len(args) > 2:
3204 if len(args) > 2:
3205 raise UsageError("%bookmark: too many arguments")
3205 raise UsageError("%bookmark: too many arguments")
3206
3206
3207 bkms = self.db.get('bookmarks',{})
3207 bkms = self.db.get('bookmarks',{})
3208
3208
3209 if opts.has_key('d'):
3209 if opts.has_key('d'):
3210 try:
3210 try:
3211 todel = args[0]
3211 todel = args[0]
3212 except IndexError:
3212 except IndexError:
3213 raise UsageError(
3213 raise UsageError(
3214 "%bookmark -d: must provide a bookmark to delete")
3214 "%bookmark -d: must provide a bookmark to delete")
3215 else:
3215 else:
3216 try:
3216 try:
3217 del bkms[todel]
3217 del bkms[todel]
3218 except KeyError:
3218 except KeyError:
3219 raise UsageError(
3219 raise UsageError(
3220 "%%bookmark -d: Can't delete bookmark '%s'" % todel)
3220 "%%bookmark -d: Can't delete bookmark '%s'" % todel)
3221
3221
3222 elif opts.has_key('r'):
3222 elif opts.has_key('r'):
3223 bkms = {}
3223 bkms = {}
3224 elif opts.has_key('l'):
3224 elif opts.has_key('l'):
3225 bks = bkms.keys()
3225 bks = bkms.keys()
3226 bks.sort()
3226 bks.sort()
3227 if bks:
3227 if bks:
3228 size = max(map(len,bks))
3228 size = max(map(len,bks))
3229 else:
3229 else:
3230 size = 0
3230 size = 0
3231 fmt = '%-'+str(size)+'s -> %s'
3231 fmt = '%-'+str(size)+'s -> %s'
3232 print 'Current bookmarks:'
3232 print 'Current bookmarks:'
3233 for bk in bks:
3233 for bk in bks:
3234 print fmt % (bk,bkms[bk])
3234 print fmt % (bk,bkms[bk])
3235 else:
3235 else:
3236 if not args:
3236 if not args:
3237 raise UsageError("%bookmark: You must specify the bookmark name")
3237 raise UsageError("%bookmark: You must specify the bookmark name")
3238 elif len(args)==1:
3238 elif len(args)==1:
3239 bkms[args[0]] = os.getcwd()
3239 bkms[args[0]] = os.getcwd()
3240 elif len(args)==2:
3240 elif len(args)==2:
3241 bkms[args[0]] = args[1]
3241 bkms[args[0]] = args[1]
3242 self.db['bookmarks'] = bkms
3242 self.db['bookmarks'] = bkms
3243
3243
3244 def magic_pycat(self, parameter_s=''):
3244 def magic_pycat(self, parameter_s=''):
3245 """Show a syntax-highlighted file through a pager.
3245 """Show a syntax-highlighted file through a pager.
3246
3246
3247 This magic is similar to the cat utility, but it will assume the file
3247 This magic is similar to the cat utility, but it will assume the file
3248 to be Python source and will show it with syntax highlighting. """
3248 to be Python source and will show it with syntax highlighting. """
3249
3249
3250 try:
3250 try:
3251 filename = get_py_filename(parameter_s)
3251 filename = get_py_filename(parameter_s)
3252 cont = file_read(filename)
3252 cont = file_read(filename)
3253 except IOError:
3253 except IOError:
3254 try:
3254 try:
3255 cont = eval(parameter_s,self.user_ns)
3255 cont = eval(parameter_s,self.user_ns)
3256 except NameError:
3256 except NameError:
3257 cont = None
3257 cont = None
3258 if cont is None:
3258 if cont is None:
3259 print "Error: no such file or variable"
3259 print "Error: no such file or variable"
3260 return
3260 return
3261
3261
3262 page(self.shell.pycolorize(cont),
3262 page(self.shell.pycolorize(cont),
3263 screen_lines=self.shell.rc.screen_length)
3263 screen_lines=self.shell.rc.screen_length)
3264
3264
3265 def magic_cpaste(self, parameter_s=''):
3265 def magic_cpaste(self, parameter_s=''):
3266 """Allows you to paste & execute a pre-formatted code block from clipboard.
3266 """Allows you to paste & execute a pre-formatted code block from clipboard.
3267
3267
3268 You must terminate the block with '--' (two minus-signs) alone on the
3268 You must terminate the block with '--' (two minus-signs) alone on the
3269 line. You can also provide your own sentinel with '%paste -s %%' ('%%'
3269 line. You can also provide your own sentinel with '%paste -s %%' ('%%'
3270 is the new sentinel for this operation)
3270 is the new sentinel for this operation)
3271
3271
3272 The block is dedented prior to execution to enable execution of method
3272 The block is dedented prior to execution to enable execution of method
3273 definitions. '>' and '+' characters at the beginning of a line are
3273 definitions. '>' and '+' characters at the beginning of a line are
3274 ignored, to allow pasting directly from e-mails, diff files and
3274 ignored, to allow pasting directly from e-mails, diff files and
3275 doctests (the '...' continuation prompt is also stripped). The
3275 doctests (the '...' continuation prompt is also stripped). The
3276 executed block is also assigned to variable named 'pasted_block' for
3276 executed block is also assigned to variable named 'pasted_block' for
3277 later editing with '%edit pasted_block'.
3277 later editing with '%edit pasted_block'.
3278
3278
3279 You can also pass a variable name as an argument, e.g. '%cpaste foo'.
3279 You can also pass a variable name as an argument, e.g. '%cpaste foo'.
3280 This assigns the pasted block to variable 'foo' as string, without
3280 This assigns the pasted block to variable 'foo' as string, without
3281 dedenting or executing it (preceding >>> and + is still stripped)
3281 dedenting or executing it (preceding >>> and + is still stripped)
3282
3282
3283 '%cpaste -r' re-executes the block previously entered by cpaste.
3283 '%cpaste -r' re-executes the block previously entered by cpaste.
3284
3284
3285 Do not be alarmed by garbled output on Windows (it's a readline bug).
3285 Do not be alarmed by garbled output on Windows (it's a readline bug).
3286 Just press enter and type -- (and press enter again) and the block
3286 Just press enter and type -- (and press enter again) and the block
3287 will be what was just pasted.
3287 will be what was just pasted.
3288
3288
3289 IPython statements (magics, shell escapes) are not supported (yet).
3289 IPython statements (magics, shell escapes) are not supported (yet).
3290 """
3290 """
3291 opts,args = self.parse_options(parameter_s,'rs:',mode='string')
3291 opts,args = self.parse_options(parameter_s,'rs:',mode='string')
3292 par = args.strip()
3292 par = args.strip()
3293 if opts.has_key('r'):
3293 if opts.has_key('r'):
3294 b = self.user_ns.get('pasted_block', None)
3294 b = self.user_ns.get('pasted_block', None)
3295 if b is None:
3295 if b is None:
3296 raise UsageError('No previous pasted block available')
3296 raise UsageError('No previous pasted block available')
3297 print "Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b))
3297 print "Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b))
3298 exec b in self.user_ns
3298 exec b in self.user_ns
3299 return
3299 return
3300
3300
3301 sentinel = opts.get('s','--')
3301 sentinel = opts.get('s','--')
3302
3302
3303 # Regular expressions that declare text we strip from the input:
3303 # Regular expressions that declare text we strip from the input:
3304 strip_re = [r'^\s*In \[\d+\]:', # IPython input prompt
3304 strip_re = [r'^\s*In \[\d+\]:', # IPython input prompt
3305 r'^\s*(\s?>)+', # Python input prompt
3305 r'^\s*(\s?>)+', # Python input prompt
3306 r'^\s*\.{3,}', # Continuation prompts
3306 r'^\s*\.{3,}', # Continuation prompts
3307 r'^\++',
3307 r'^\++',
3308 ]
3308 ]
3309
3309
3310 strip_from_start = map(re.compile,strip_re)
3310 strip_from_start = map(re.compile,strip_re)
3311
3311
3312 from IPython import iplib
3312 from IPython import iplib
3313 lines = []
3313 lines = []
3314 print "Pasting code; enter '%s' alone on the line to stop." % sentinel
3314 print "Pasting code; enter '%s' alone on the line to stop." % sentinel
3315 while 1:
3315 while 1:
3316 l = iplib.raw_input_original(':')
3316 l = iplib.raw_input_original(':')
3317 if l ==sentinel:
3317 if l ==sentinel:
3318 break
3318 break
3319
3319
3320 for pat in strip_from_start:
3320 for pat in strip_from_start:
3321 l = pat.sub('',l)
3321 l = pat.sub('',l)
3322 lines.append(l)
3322 lines.append(l)
3323
3323
3324 block = "\n".join(lines) + '\n'
3324 block = "\n".join(lines) + '\n'
3325 #print "block:\n",block
3325 #print "block:\n",block
3326 if not par:
3326 if not par:
3327 b = textwrap.dedent(block)
3327 b = textwrap.dedent(block)
3328 self.user_ns['pasted_block'] = b
3328 self.user_ns['pasted_block'] = b
3329 exec b in self.user_ns
3329 exec b in self.user_ns
3330 else:
3330 else:
3331 self.user_ns[par] = SList(block.splitlines())
3331 self.user_ns[par] = SList(block.splitlines())
3332 print "Block assigned to '%s'" % par
3332 print "Block assigned to '%s'" % par
3333
3333
3334 def magic_quickref(self,arg):
3334 def magic_quickref(self,arg):
3335 """ Show a quick reference sheet """
3335 """ Show a quick reference sheet """
3336 import IPython.usage
3336 import IPython.usage
3337 qr = IPython.usage.quick_reference + self.magic_magic('-brief')
3337 qr = IPython.usage.quick_reference + self.magic_magic('-brief')
3338
3338
3339 page(qr)
3339 page(qr)
3340
3340
3341 def magic_upgrade(self,arg):
3341 def magic_upgrade(self,arg):
3342 """ Upgrade your IPython installation
3342 """ Upgrade your IPython installation
3343
3343
3344 This will copy the config files that don't yet exist in your
3344 This will copy the config files that don't yet exist in your
3345 ipython dir from the system config dir. Use this after upgrading
3345 ipython dir from the system config dir. Use this after upgrading
3346 IPython if you don't wish to delete your .ipython dir.
3346 IPython if you don't wish to delete your .ipython dir.
3347
3347
3348 Call with -nolegacy to get rid of ipythonrc* files (recommended for
3348 Call with -nolegacy to get rid of ipythonrc* files (recommended for
3349 new users)
3349 new users)
3350
3350
3351 """
3351 """
3352 ip = self.getapi()
3352 ip = self.getapi()
3353 ipinstallation = path(IPython.__file__).dirname()
3353 ipinstallation = path(IPython.__file__).dirname()
3354 upgrade_script = '%s "%s"' % (sys.executable,ipinstallation / 'upgrade_dir.py')
3354 upgrade_script = '%s "%s"' % (sys.executable,ipinstallation / 'upgrade_dir.py')
3355 src_config = ipinstallation / 'UserConfig'
3355 src_config = ipinstallation / 'UserConfig'
3356 userdir = path(ip.options.ipythondir)
3356 userdir = path(ip.options.ipythondir)
3357 cmd = '%s "%s" "%s"' % (upgrade_script, src_config, userdir)
3357 cmd = '%s "%s" "%s"' % (upgrade_script, src_config, userdir)
3358 print ">",cmd
3358 print ">",cmd
3359 shell(cmd)
3359 shell(cmd)
3360 if arg == '-nolegacy':
3360 if arg == '-nolegacy':
3361 legacy = userdir.files('ipythonrc*')
3361 legacy = userdir.files('ipythonrc*')
3362 print "Nuking legacy files:",legacy
3362 print "Nuking legacy files:",legacy
3363
3363
3364 [p.remove() for p in legacy]
3364 [p.remove() for p in legacy]
3365 suffix = (sys.platform == 'win32' and '.ini' or '')
3365 suffix = (sys.platform == 'win32' and '.ini' or '')
3366 (userdir / ('ipythonrc' + suffix)).write_text('# Empty, see ipy_user_conf.py\n')
3366 (userdir / ('ipythonrc' + suffix)).write_text('# Empty, see ipy_user_conf.py\n')
3367
3367
3368
3368
3369 def magic_doctest_mode(self,parameter_s=''):
3369 def magic_doctest_mode(self,parameter_s=''):
3370 """Toggle doctest mode on and off.
3370 """Toggle doctest mode on and off.
3371
3371
3372 This mode allows you to toggle the prompt behavior between normal
3372 This mode allows you to toggle the prompt behavior between normal
3373 IPython prompts and ones that are as similar to the default IPython
3373 IPython prompts and ones that are as similar to the default IPython
3374 interpreter as possible.
3374 interpreter as possible.
3375
3375
3376 It also supports the pasting of code snippets that have leading '>>>'
3376 It also supports the pasting of code snippets that have leading '>>>'
3377 and '...' prompts in them. This means that you can paste doctests from
3377 and '...' prompts in them. This means that you can paste doctests from
3378 files or docstrings (even if they have leading whitespace), and the
3378 files or docstrings (even if they have leading whitespace), and the
3379 code will execute correctly. You can then use '%history -tn' to see
3379 code will execute correctly. You can then use '%history -tn' to see
3380 the translated history without line numbers; this will give you the
3380 the translated history without line numbers; this will give you the
3381 input after removal of all the leading prompts and whitespace, which
3381 input after removal of all the leading prompts and whitespace, which
3382 can be pasted back into an editor.
3382 can be pasted back into an editor.
3383
3383
3384 With these features, you can switch into this mode easily whenever you
3384 With these features, you can switch into this mode easily whenever you
3385 need to do testing and changes to doctests, without having to leave
3385 need to do testing and changes to doctests, without having to leave
3386 your existing IPython session.
3386 your existing IPython session.
3387 """
3387 """
3388
3388
3389 # XXX - Fix this to have cleaner activate/deactivate calls.
3389 # XXX - Fix this to have cleaner activate/deactivate calls.
3390 from IPython.Extensions import InterpreterPasteInput as ipaste
3390 from IPython.Extensions import InterpreterPasteInput as ipaste
3391 from IPython.ipstruct import Struct
3391 from IPython.ipstruct import Struct
3392
3392
3393 # Shorthands
3393 # Shorthands
3394 shell = self.shell
3394 shell = self.shell
3395 oc = shell.outputcache
3395 oc = shell.outputcache
3396 rc = shell.rc
3396 rc = shell.rc
3397 meta = shell.meta
3397 meta = shell.meta
3398 # dstore is a data store kept in the instance metadata bag to track any
3398 # dstore is a data store kept in the instance metadata bag to track any
3399 # changes we make, so we can undo them later.
3399 # changes we make, so we can undo them later.
3400 dstore = meta.setdefault('doctest_mode',Struct())
3400 dstore = meta.setdefault('doctest_mode',Struct())
3401 save_dstore = dstore.setdefault
3401 save_dstore = dstore.setdefault
3402
3402
3403 # save a few values we'll need to recover later
3403 # save a few values we'll need to recover later
3404 mode = save_dstore('mode',False)
3404 mode = save_dstore('mode',False)
3405 save_dstore('rc_pprint',rc.pprint)
3405 save_dstore('rc_pprint',rc.pprint)
3406 save_dstore('xmode',shell.InteractiveTB.mode)
3406 save_dstore('xmode',shell.InteractiveTB.mode)
3407 save_dstore('rc_separate_out',rc.separate_out)
3407 save_dstore('rc_separate_out',rc.separate_out)
3408 save_dstore('rc_separate_out2',rc.separate_out2)
3408 save_dstore('rc_separate_out2',rc.separate_out2)
3409 save_dstore('rc_prompts_pad_left',rc.prompts_pad_left)
3409 save_dstore('rc_prompts_pad_left',rc.prompts_pad_left)
3410 save_dstore('rc_separate_in',rc.separate_in)
3410 save_dstore('rc_separate_in',rc.separate_in)
3411
3411
3412 if mode == False:
3412 if mode == False:
3413 # turn on
3413 # turn on
3414 ipaste.activate_prefilter()
3414 ipaste.activate_prefilter()
3415
3415
3416 oc.prompt1.p_template = '>>> '
3416 oc.prompt1.p_template = '>>> '
3417 oc.prompt2.p_template = '... '
3417 oc.prompt2.p_template = '... '
3418 oc.prompt_out.p_template = ''
3418 oc.prompt_out.p_template = ''
3419
3419
3420 # Prompt separators like plain python
3420 # Prompt separators like plain python
3421 oc.input_sep = oc.prompt1.sep = ''
3421 oc.input_sep = oc.prompt1.sep = ''
3422 oc.output_sep = ''
3422 oc.output_sep = ''
3423 oc.output_sep2 = ''
3423 oc.output_sep2 = ''
3424
3424
3425 oc.prompt1.pad_left = oc.prompt2.pad_left = \
3425 oc.prompt1.pad_left = oc.prompt2.pad_left = \
3426 oc.prompt_out.pad_left = False
3426 oc.prompt_out.pad_left = False
3427
3427
3428 rc.pprint = False
3428 rc.pprint = False
3429
3429
3430 shell.magic_xmode('Plain')
3430 shell.magic_xmode('Plain')
3431
3431
3432 else:
3432 else:
3433 # turn off
3433 # turn off
3434 ipaste.deactivate_prefilter()
3434 ipaste.deactivate_prefilter()
3435
3435
3436 oc.prompt1.p_template = rc.prompt_in1
3436 oc.prompt1.p_template = rc.prompt_in1
3437 oc.prompt2.p_template = rc.prompt_in2
3437 oc.prompt2.p_template = rc.prompt_in2
3438 oc.prompt_out.p_template = rc.prompt_out
3438 oc.prompt_out.p_template = rc.prompt_out
3439
3439
3440 oc.input_sep = oc.prompt1.sep = dstore.rc_separate_in
3440 oc.input_sep = oc.prompt1.sep = dstore.rc_separate_in
3441
3441
3442 oc.output_sep = dstore.rc_separate_out
3442 oc.output_sep = dstore.rc_separate_out
3443 oc.output_sep2 = dstore.rc_separate_out2
3443 oc.output_sep2 = dstore.rc_separate_out2
3444
3444
3445 oc.prompt1.pad_left = oc.prompt2.pad_left = \
3445 oc.prompt1.pad_left = oc.prompt2.pad_left = \
3446 oc.prompt_out.pad_left = dstore.rc_prompts_pad_left
3446 oc.prompt_out.pad_left = dstore.rc_prompts_pad_left
3447
3447
3448 rc.pprint = dstore.rc_pprint
3448 rc.pprint = dstore.rc_pprint
3449
3449
3450 shell.magic_xmode(dstore.xmode)
3450 shell.magic_xmode(dstore.xmode)
3451
3451
3452 # Store new mode and inform
3452 # Store new mode and inform
3453 dstore.mode = bool(1-int(mode))
3453 dstore.mode = bool(1-int(mode))
3454 print 'Doctest mode is:',
3454 print 'Doctest mode is:',
3455 print ['OFF','ON'][dstore.mode]
3455 print ['OFF','ON'][dstore.mode]
3456
3456
3457 # end Magic
3457 # end Magic
@@ -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.genutils import page,indent,Term
31 from IPython.utils.genutils import page,indent,Term
32 from IPython.Itpl import itpl
32 from IPython.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,627 +1,627 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """
2 """
3 Classes for handling input/output prompts.
3 Classes for handling input/output prompts.
4 """
4 """
5
5
6 #*****************************************************************************
6 #*****************************************************************************
7 # Copyright (C) 2008-2009 The IPython Development Team
7 # Copyright (C) 2008-2009 The IPython Development Team
8 # Copyright (C) 2001-2007 Fernando Perez <fperez@colorado.edu>
8 # Copyright (C) 2001-2007 Fernando Perez <fperez@colorado.edu>
9 #
9 #
10 # Distributed under the terms of the BSD License. The full license is in
10 # Distributed under the terms of the BSD License. The full license is in
11 # the file COPYING, distributed as part of this software.
11 # the file COPYING, distributed as part of this software.
12 #*****************************************************************************
12 #*****************************************************************************
13
13
14 #****************************************************************************
14 #****************************************************************************
15 # Required modules
15 # Required modules
16 import __builtin__
16 import __builtin__
17 import os
17 import os
18 import socket
18 import socket
19 import sys
19 import sys
20 import time
20 import time
21
21
22 # IPython's own
22 # IPython's own
23 from IPython.utils import coloransi
23 from IPython.utils import coloransi
24 from IPython import Release
24 from IPython import Release
25 from IPython.external.Itpl import ItplNS
25 from IPython.external.Itpl import ItplNS
26 from IPython.ipapi import TryNext
26 from IPython.ipapi import TryNext
27 from IPython.ipstruct import Struct
27 from IPython.ipstruct import Struct
28 from IPython.macro import Macro
28 from IPython.macro import Macro
29 import IPython.utils.generics
29 import IPython.utils.generics
30
30
31 from IPython.genutils import *
31 from IPython.utils.genutils import *
32
32
33 #****************************************************************************
33 #****************************************************************************
34 #Color schemes for Prompts.
34 #Color schemes for Prompts.
35
35
36 PromptColors = coloransi.ColorSchemeTable()
36 PromptColors = coloransi.ColorSchemeTable()
37 InputColors = coloransi.InputTermColors # just a shorthand
37 InputColors = coloransi.InputTermColors # just a shorthand
38 Colors = coloransi.TermColors # just a shorthand
38 Colors = coloransi.TermColors # just a shorthand
39
39
40 PromptColors.add_scheme(coloransi.ColorScheme(
40 PromptColors.add_scheme(coloransi.ColorScheme(
41 'NoColor',
41 'NoColor',
42 in_prompt = InputColors.NoColor, # Input prompt
42 in_prompt = InputColors.NoColor, # Input prompt
43 in_number = InputColors.NoColor, # Input prompt number
43 in_number = InputColors.NoColor, # Input prompt number
44 in_prompt2 = InputColors.NoColor, # Continuation prompt
44 in_prompt2 = InputColors.NoColor, # Continuation prompt
45 in_normal = InputColors.NoColor, # color off (usu. Colors.Normal)
45 in_normal = InputColors.NoColor, # color off (usu. Colors.Normal)
46
46
47 out_prompt = Colors.NoColor, # Output prompt
47 out_prompt = Colors.NoColor, # Output prompt
48 out_number = Colors.NoColor, # Output prompt number
48 out_number = Colors.NoColor, # Output prompt number
49
49
50 normal = Colors.NoColor # color off (usu. Colors.Normal)
50 normal = Colors.NoColor # color off (usu. Colors.Normal)
51 ))
51 ))
52
52
53 # make some schemes as instances so we can copy them for modification easily:
53 # make some schemes as instances so we can copy them for modification easily:
54 __PColLinux = coloransi.ColorScheme(
54 __PColLinux = coloransi.ColorScheme(
55 'Linux',
55 'Linux',
56 in_prompt = InputColors.Green,
56 in_prompt = InputColors.Green,
57 in_number = InputColors.LightGreen,
57 in_number = InputColors.LightGreen,
58 in_prompt2 = InputColors.Green,
58 in_prompt2 = InputColors.Green,
59 in_normal = InputColors.Normal, # color off (usu. Colors.Normal)
59 in_normal = InputColors.Normal, # color off (usu. Colors.Normal)
60
60
61 out_prompt = Colors.Red,
61 out_prompt = Colors.Red,
62 out_number = Colors.LightRed,
62 out_number = Colors.LightRed,
63
63
64 normal = Colors.Normal
64 normal = Colors.Normal
65 )
65 )
66 # Don't forget to enter it into the table!
66 # Don't forget to enter it into the table!
67 PromptColors.add_scheme(__PColLinux)
67 PromptColors.add_scheme(__PColLinux)
68
68
69 # Slightly modified Linux for light backgrounds
69 # Slightly modified Linux for light backgrounds
70 __PColLightBG = __PColLinux.copy('LightBG')
70 __PColLightBG = __PColLinux.copy('LightBG')
71
71
72 __PColLightBG.colors.update(
72 __PColLightBG.colors.update(
73 in_prompt = InputColors.Blue,
73 in_prompt = InputColors.Blue,
74 in_number = InputColors.LightBlue,
74 in_number = InputColors.LightBlue,
75 in_prompt2 = InputColors.Blue
75 in_prompt2 = InputColors.Blue
76 )
76 )
77 PromptColors.add_scheme(__PColLightBG)
77 PromptColors.add_scheme(__PColLightBG)
78
78
79 del Colors,InputColors
79 del Colors,InputColors
80
80
81 #-----------------------------------------------------------------------------
81 #-----------------------------------------------------------------------------
82 def multiple_replace(dict, text):
82 def multiple_replace(dict, text):
83 """ Replace in 'text' all occurences of any key in the given
83 """ Replace in 'text' all occurences of any key in the given
84 dictionary by its corresponding value. Returns the new string."""
84 dictionary by its corresponding value. Returns the new string."""
85
85
86 # Function by Xavier Defrang, originally found at:
86 # Function by Xavier Defrang, originally found at:
87 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/81330
87 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/81330
88
88
89 # Create a regular expression from the dictionary keys
89 # Create a regular expression from the dictionary keys
90 regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys())))
90 regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys())))
91 # For each match, look-up corresponding value in dictionary
91 # For each match, look-up corresponding value in dictionary
92 return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text)
92 return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text)
93
93
94 #-----------------------------------------------------------------------------
94 #-----------------------------------------------------------------------------
95 # Special characters that can be used in prompt templates, mainly bash-like
95 # Special characters that can be used in prompt templates, mainly bash-like
96
96
97 # If $HOME isn't defined (Windows), make it an absurd string so that it can
97 # If $HOME isn't defined (Windows), make it an absurd string so that it can
98 # never be expanded out into '~'. Basically anything which can never be a
98 # never be expanded out into '~'. Basically anything which can never be a
99 # reasonable directory name will do, we just want the $HOME -> '~' operation
99 # reasonable directory name will do, we just want the $HOME -> '~' operation
100 # to become a no-op. We pre-compute $HOME here so it's not done on every
100 # to become a no-op. We pre-compute $HOME here so it's not done on every
101 # prompt call.
101 # prompt call.
102
102
103 # FIXME:
103 # FIXME:
104
104
105 # - This should be turned into a class which does proper namespace management,
105 # - This should be turned into a class which does proper namespace management,
106 # since the prompt specials need to be evaluated in a certain namespace.
106 # since the prompt specials need to be evaluated in a certain namespace.
107 # Currently it's just globals, which need to be managed manually by code
107 # Currently it's just globals, which need to be managed manually by code
108 # below.
108 # below.
109
109
110 # - I also need to split up the color schemes from the prompt specials
110 # - I also need to split up the color schemes from the prompt specials
111 # somehow. I don't have a clean design for that quite yet.
111 # somehow. I don't have a clean design for that quite yet.
112
112
113 HOME = os.environ.get("HOME","//////:::::ZZZZZ,,,~~~")
113 HOME = os.environ.get("HOME","//////:::::ZZZZZ,,,~~~")
114
114
115 # We precompute a few more strings here for the prompt_specials, which are
115 # We precompute a few more strings here for the prompt_specials, which are
116 # fixed once ipython starts. This reduces the runtime overhead of computing
116 # fixed once ipython starts. This reduces the runtime overhead of computing
117 # prompt strings.
117 # prompt strings.
118 USER = os.environ.get("USER")
118 USER = os.environ.get("USER")
119 HOSTNAME = socket.gethostname()
119 HOSTNAME = socket.gethostname()
120 HOSTNAME_SHORT = HOSTNAME.split(".")[0]
120 HOSTNAME_SHORT = HOSTNAME.split(".")[0]
121 ROOT_SYMBOL = "$#"[os.name=='nt' or os.getuid()==0]
121 ROOT_SYMBOL = "$#"[os.name=='nt' or os.getuid()==0]
122
122
123 prompt_specials_color = {
123 prompt_specials_color = {
124 # Prompt/history count
124 # Prompt/history count
125 '%n' : '${self.col_num}' '${self.cache.prompt_count}' '${self.col_p}',
125 '%n' : '${self.col_num}' '${self.cache.prompt_count}' '${self.col_p}',
126 r'\#': '${self.col_num}' '${self.cache.prompt_count}' '${self.col_p}',
126 r'\#': '${self.col_num}' '${self.cache.prompt_count}' '${self.col_p}',
127 # Just the prompt counter number, WITHOUT any coloring wrappers, so users
127 # Just the prompt counter number, WITHOUT any coloring wrappers, so users
128 # can get numbers displayed in whatever color they want.
128 # can get numbers displayed in whatever color they want.
129 r'\N': '${self.cache.prompt_count}',
129 r'\N': '${self.cache.prompt_count}',
130
130
131 # Prompt/history count, with the actual digits replaced by dots. Used
131 # Prompt/history count, with the actual digits replaced by dots. Used
132 # mainly in continuation prompts (prompt_in2)
132 # mainly in continuation prompts (prompt_in2)
133 #r'\D': '${"."*len(str(self.cache.prompt_count))}',
133 #r'\D': '${"."*len(str(self.cache.prompt_count))}',
134 # More robust form of the above expression, that uses __builtins__
134 # More robust form of the above expression, that uses __builtins__
135 r'\D': '${"."*__builtins__.len(__builtins__.str(self.cache.prompt_count))}',
135 r'\D': '${"."*__builtins__.len(__builtins__.str(self.cache.prompt_count))}',
136
136
137 # Current working directory
137 # Current working directory
138 r'\w': '${os.getcwd()}',
138 r'\w': '${os.getcwd()}',
139 # Current time
139 # Current time
140 r'\t' : '${time.strftime("%H:%M:%S")}',
140 r'\t' : '${time.strftime("%H:%M:%S")}',
141 # Basename of current working directory.
141 # Basename of current working directory.
142 # (use os.sep to make this portable across OSes)
142 # (use os.sep to make this portable across OSes)
143 r'\W' : '${os.getcwd().split("%s")[-1]}' % os.sep,
143 r'\W' : '${os.getcwd().split("%s")[-1]}' % os.sep,
144 # These X<N> are an extension to the normal bash prompts. They return
144 # These X<N> are an extension to the normal bash prompts. They return
145 # N terms of the path, after replacing $HOME with '~'
145 # N terms of the path, after replacing $HOME with '~'
146 r'\X0': '${os.getcwd().replace("%s","~")}' % HOME,
146 r'\X0': '${os.getcwd().replace("%s","~")}' % HOME,
147 r'\X1': '${self.cwd_filt(1)}',
147 r'\X1': '${self.cwd_filt(1)}',
148 r'\X2': '${self.cwd_filt(2)}',
148 r'\X2': '${self.cwd_filt(2)}',
149 r'\X3': '${self.cwd_filt(3)}',
149 r'\X3': '${self.cwd_filt(3)}',
150 r'\X4': '${self.cwd_filt(4)}',
150 r'\X4': '${self.cwd_filt(4)}',
151 r'\X5': '${self.cwd_filt(5)}',
151 r'\X5': '${self.cwd_filt(5)}',
152 # Y<N> are similar to X<N>, but they show '~' if it's the directory
152 # Y<N> are similar to X<N>, but they show '~' if it's the directory
153 # N+1 in the list. Somewhat like %cN in tcsh.
153 # N+1 in the list. Somewhat like %cN in tcsh.
154 r'\Y0': '${self.cwd_filt2(0)}',
154 r'\Y0': '${self.cwd_filt2(0)}',
155 r'\Y1': '${self.cwd_filt2(1)}',
155 r'\Y1': '${self.cwd_filt2(1)}',
156 r'\Y2': '${self.cwd_filt2(2)}',
156 r'\Y2': '${self.cwd_filt2(2)}',
157 r'\Y3': '${self.cwd_filt2(3)}',
157 r'\Y3': '${self.cwd_filt2(3)}',
158 r'\Y4': '${self.cwd_filt2(4)}',
158 r'\Y4': '${self.cwd_filt2(4)}',
159 r'\Y5': '${self.cwd_filt2(5)}',
159 r'\Y5': '${self.cwd_filt2(5)}',
160 # Hostname up to first .
160 # Hostname up to first .
161 r'\h': HOSTNAME_SHORT,
161 r'\h': HOSTNAME_SHORT,
162 # Full hostname
162 # Full hostname
163 r'\H': HOSTNAME,
163 r'\H': HOSTNAME,
164 # Username of current user
164 # Username of current user
165 r'\u': USER,
165 r'\u': USER,
166 # Escaped '\'
166 # Escaped '\'
167 '\\\\': '\\',
167 '\\\\': '\\',
168 # Newline
168 # Newline
169 r'\n': '\n',
169 r'\n': '\n',
170 # Carriage return
170 # Carriage return
171 r'\r': '\r',
171 r'\r': '\r',
172 # Release version
172 # Release version
173 r'\v': Release.version,
173 r'\v': Release.version,
174 # Root symbol ($ or #)
174 # Root symbol ($ or #)
175 r'\$': ROOT_SYMBOL,
175 r'\$': ROOT_SYMBOL,
176 }
176 }
177
177
178 # A copy of the prompt_specials dictionary but with all color escapes removed,
178 # A copy of the prompt_specials dictionary but with all color escapes removed,
179 # so we can correctly compute the prompt length for the auto_rewrite method.
179 # so we can correctly compute the prompt length for the auto_rewrite method.
180 prompt_specials_nocolor = prompt_specials_color.copy()
180 prompt_specials_nocolor = prompt_specials_color.copy()
181 prompt_specials_nocolor['%n'] = '${self.cache.prompt_count}'
181 prompt_specials_nocolor['%n'] = '${self.cache.prompt_count}'
182 prompt_specials_nocolor[r'\#'] = '${self.cache.prompt_count}'
182 prompt_specials_nocolor[r'\#'] = '${self.cache.prompt_count}'
183
183
184 # Add in all the InputTermColors color escapes as valid prompt characters.
184 # Add in all the InputTermColors color escapes as valid prompt characters.
185 # They all get added as \\C_COLORNAME, so that we don't have any conflicts
185 # They all get added as \\C_COLORNAME, so that we don't have any conflicts
186 # with a color name which may begin with a letter used by any other of the
186 # with a color name which may begin with a letter used by any other of the
187 # allowed specials. This of course means that \\C will never be allowed for
187 # allowed specials. This of course means that \\C will never be allowed for
188 # anything else.
188 # anything else.
189 input_colors = coloransi.InputTermColors
189 input_colors = coloransi.InputTermColors
190 for _color in dir(input_colors):
190 for _color in dir(input_colors):
191 if _color[0] != '_':
191 if _color[0] != '_':
192 c_name = r'\C_'+_color
192 c_name = r'\C_'+_color
193 prompt_specials_color[c_name] = getattr(input_colors,_color)
193 prompt_specials_color[c_name] = getattr(input_colors,_color)
194 prompt_specials_nocolor[c_name] = ''
194 prompt_specials_nocolor[c_name] = ''
195
195
196 # we default to no color for safety. Note that prompt_specials is a global
196 # we default to no color for safety. Note that prompt_specials is a global
197 # variable used by all prompt objects.
197 # variable used by all prompt objects.
198 prompt_specials = prompt_specials_nocolor
198 prompt_specials = prompt_specials_nocolor
199
199
200 #-----------------------------------------------------------------------------
200 #-----------------------------------------------------------------------------
201 def str_safe(arg):
201 def str_safe(arg):
202 """Convert to a string, without ever raising an exception.
202 """Convert to a string, without ever raising an exception.
203
203
204 If str(arg) fails, <ERROR: ... > is returned, where ... is the exception
204 If str(arg) fails, <ERROR: ... > is returned, where ... is the exception
205 error message."""
205 error message."""
206
206
207 try:
207 try:
208 out = str(arg)
208 out = str(arg)
209 except UnicodeError:
209 except UnicodeError:
210 try:
210 try:
211 out = arg.encode('utf_8','replace')
211 out = arg.encode('utf_8','replace')
212 except Exception,msg:
212 except Exception,msg:
213 # let's keep this little duplication here, so that the most common
213 # let's keep this little duplication here, so that the most common
214 # case doesn't suffer from a double try wrapping.
214 # case doesn't suffer from a double try wrapping.
215 out = '<ERROR: %s>' % msg
215 out = '<ERROR: %s>' % msg
216 except Exception,msg:
216 except Exception,msg:
217 out = '<ERROR: %s>' % msg
217 out = '<ERROR: %s>' % msg
218 return out
218 return out
219
219
220 class BasePrompt(object):
220 class BasePrompt(object):
221 """Interactive prompt similar to Mathematica's."""
221 """Interactive prompt similar to Mathematica's."""
222
222
223 def _get_p_template(self):
223 def _get_p_template(self):
224 return self._p_template
224 return self._p_template
225
225
226 def _set_p_template(self,val):
226 def _set_p_template(self,val):
227 self._p_template = val
227 self._p_template = val
228 self.set_p_str()
228 self.set_p_str()
229
229
230 p_template = property(_get_p_template,_set_p_template,
230 p_template = property(_get_p_template,_set_p_template,
231 doc='Template for prompt string creation')
231 doc='Template for prompt string creation')
232
232
233 def __init__(self,cache,sep,prompt,pad_left=False):
233 def __init__(self,cache,sep,prompt,pad_left=False):
234
234
235 # Hack: we access information about the primary prompt through the
235 # Hack: we access information about the primary prompt through the
236 # cache argument. We need this, because we want the secondary prompt
236 # cache argument. We need this, because we want the secondary prompt
237 # to be aligned with the primary one. Color table info is also shared
237 # to be aligned with the primary one. Color table info is also shared
238 # by all prompt classes through the cache. Nice OO spaghetti code!
238 # by all prompt classes through the cache. Nice OO spaghetti code!
239 self.cache = cache
239 self.cache = cache
240 self.sep = sep
240 self.sep = sep
241
241
242 # regexp to count the number of spaces at the end of a prompt
242 # regexp to count the number of spaces at the end of a prompt
243 # expression, useful for prompt auto-rewriting
243 # expression, useful for prompt auto-rewriting
244 self.rspace = re.compile(r'(\s*)$')
244 self.rspace = re.compile(r'(\s*)$')
245 # Flag to left-pad prompt strings to match the length of the primary
245 # Flag to left-pad prompt strings to match the length of the primary
246 # prompt
246 # prompt
247 self.pad_left = pad_left
247 self.pad_left = pad_left
248
248
249 # Set template to create each actual prompt (where numbers change).
249 # Set template to create each actual prompt (where numbers change).
250 # Use a property
250 # Use a property
251 self.p_template = prompt
251 self.p_template = prompt
252 self.set_p_str()
252 self.set_p_str()
253
253
254 def set_p_str(self):
254 def set_p_str(self):
255 """ Set the interpolating prompt strings.
255 """ Set the interpolating prompt strings.
256
256
257 This must be called every time the color settings change, because the
257 This must be called every time the color settings change, because the
258 prompt_specials global may have changed."""
258 prompt_specials global may have changed."""
259
259
260 import os,time # needed in locals for prompt string handling
260 import os,time # needed in locals for prompt string handling
261 loc = locals()
261 loc = locals()
262 try:
262 try:
263 self.p_str = ItplNS('%s%s%s' %
263 self.p_str = ItplNS('%s%s%s' %
264 ('${self.sep}${self.col_p}',
264 ('${self.sep}${self.col_p}',
265 multiple_replace(prompt_specials, self.p_template),
265 multiple_replace(prompt_specials, self.p_template),
266 '${self.col_norm}'),self.cache.user_ns,loc)
266 '${self.col_norm}'),self.cache.user_ns,loc)
267
267
268 self.p_str_nocolor = ItplNS(multiple_replace(prompt_specials_nocolor,
268 self.p_str_nocolor = ItplNS(multiple_replace(prompt_specials_nocolor,
269 self.p_template),
269 self.p_template),
270 self.cache.user_ns,loc)
270 self.cache.user_ns,loc)
271 except:
271 except:
272 print "Illegal prompt template (check $ usage!):",self.p_template
272 print "Illegal prompt template (check $ usage!):",self.p_template
273 self.p_str = self.p_template
273 self.p_str = self.p_template
274 self.p_str_nocolor = self.p_template
274 self.p_str_nocolor = self.p_template
275
275
276 def write(self,msg): # dbg
276 def write(self,msg): # dbg
277 sys.stdout.write(msg)
277 sys.stdout.write(msg)
278 return ''
278 return ''
279
279
280 def __str__(self):
280 def __str__(self):
281 """Return a string form of the prompt.
281 """Return a string form of the prompt.
282
282
283 This for is useful for continuation and output prompts, since it is
283 This for is useful for continuation and output prompts, since it is
284 left-padded to match lengths with the primary one (if the
284 left-padded to match lengths with the primary one (if the
285 self.pad_left attribute is set)."""
285 self.pad_left attribute is set)."""
286
286
287 out_str = str_safe(self.p_str)
287 out_str = str_safe(self.p_str)
288 if self.pad_left:
288 if self.pad_left:
289 # We must find the amount of padding required to match lengths,
289 # We must find the amount of padding required to match lengths,
290 # taking the color escapes (which are invisible on-screen) into
290 # taking the color escapes (which are invisible on-screen) into
291 # account.
291 # account.
292 esc_pad = len(out_str) - len(str_safe(self.p_str_nocolor))
292 esc_pad = len(out_str) - len(str_safe(self.p_str_nocolor))
293 format = '%%%ss' % (len(str(self.cache.last_prompt))+esc_pad)
293 format = '%%%ss' % (len(str(self.cache.last_prompt))+esc_pad)
294 return format % out_str
294 return format % out_str
295 else:
295 else:
296 return out_str
296 return out_str
297
297
298 # these path filters are put in as methods so that we can control the
298 # these path filters are put in as methods so that we can control the
299 # namespace where the prompt strings get evaluated
299 # namespace where the prompt strings get evaluated
300 def cwd_filt(self,depth):
300 def cwd_filt(self,depth):
301 """Return the last depth elements of the current working directory.
301 """Return the last depth elements of the current working directory.
302
302
303 $HOME is always replaced with '~'.
303 $HOME is always replaced with '~'.
304 If depth==0, the full path is returned."""
304 If depth==0, the full path is returned."""
305
305
306 cwd = os.getcwd().replace(HOME,"~")
306 cwd = os.getcwd().replace(HOME,"~")
307 out = os.sep.join(cwd.split(os.sep)[-depth:])
307 out = os.sep.join(cwd.split(os.sep)[-depth:])
308 if out:
308 if out:
309 return out
309 return out
310 else:
310 else:
311 return os.sep
311 return os.sep
312
312
313 def cwd_filt2(self,depth):
313 def cwd_filt2(self,depth):
314 """Return the last depth elements of the current working directory.
314 """Return the last depth elements of the current working directory.
315
315
316 $HOME is always replaced with '~'.
316 $HOME is always replaced with '~'.
317 If depth==0, the full path is returned."""
317 If depth==0, the full path is returned."""
318
318
319 full_cwd = os.getcwd()
319 full_cwd = os.getcwd()
320 cwd = full_cwd.replace(HOME,"~").split(os.sep)
320 cwd = full_cwd.replace(HOME,"~").split(os.sep)
321 if '~' in cwd and len(cwd) == depth+1:
321 if '~' in cwd and len(cwd) == depth+1:
322 depth += 1
322 depth += 1
323 drivepart = ''
323 drivepart = ''
324 if sys.platform == 'win32' and len(cwd) > depth:
324 if sys.platform == 'win32' and len(cwd) > depth:
325 drivepart = os.path.splitdrive(full_cwd)[0]
325 drivepart = os.path.splitdrive(full_cwd)[0]
326 out = drivepart + '/'.join(cwd[-depth:])
326 out = drivepart + '/'.join(cwd[-depth:])
327
327
328 if out:
328 if out:
329 return out
329 return out
330 else:
330 else:
331 return os.sep
331 return os.sep
332
332
333 def __nonzero__(self):
333 def __nonzero__(self):
334 """Implement boolean behavior.
334 """Implement boolean behavior.
335
335
336 Checks whether the p_str attribute is non-empty"""
336 Checks whether the p_str attribute is non-empty"""
337
337
338 return bool(self.p_template)
338 return bool(self.p_template)
339
339
340 class Prompt1(BasePrompt):
340 class Prompt1(BasePrompt):
341 """Input interactive prompt similar to Mathematica's."""
341 """Input interactive prompt similar to Mathematica's."""
342
342
343 def __init__(self,cache,sep='\n',prompt='In [\\#]: ',pad_left=True):
343 def __init__(self,cache,sep='\n',prompt='In [\\#]: ',pad_left=True):
344 BasePrompt.__init__(self,cache,sep,prompt,pad_left)
344 BasePrompt.__init__(self,cache,sep,prompt,pad_left)
345
345
346 def set_colors(self):
346 def set_colors(self):
347 self.set_p_str()
347 self.set_p_str()
348 Colors = self.cache.color_table.active_colors # shorthand
348 Colors = self.cache.color_table.active_colors # shorthand
349 self.col_p = Colors.in_prompt
349 self.col_p = Colors.in_prompt
350 self.col_num = Colors.in_number
350 self.col_num = Colors.in_number
351 self.col_norm = Colors.in_normal
351 self.col_norm = Colors.in_normal
352 # We need a non-input version of these escapes for the '--->'
352 # We need a non-input version of these escapes for the '--->'
353 # auto-call prompts used in the auto_rewrite() method.
353 # auto-call prompts used in the auto_rewrite() method.
354 self.col_p_ni = self.col_p.replace('\001','').replace('\002','')
354 self.col_p_ni = self.col_p.replace('\001','').replace('\002','')
355 self.col_norm_ni = Colors.normal
355 self.col_norm_ni = Colors.normal
356
356
357 def __str__(self):
357 def __str__(self):
358 self.cache.prompt_count += 1
358 self.cache.prompt_count += 1
359 self.cache.last_prompt = str_safe(self.p_str_nocolor).split('\n')[-1]
359 self.cache.last_prompt = str_safe(self.p_str_nocolor).split('\n')[-1]
360 return str_safe(self.p_str)
360 return str_safe(self.p_str)
361
361
362 def auto_rewrite(self):
362 def auto_rewrite(self):
363 """Print a string of the form '--->' which lines up with the previous
363 """Print a string of the form '--->' which lines up with the previous
364 input string. Useful for systems which re-write the user input when
364 input string. Useful for systems which re-write the user input when
365 handling automatically special syntaxes."""
365 handling automatically special syntaxes."""
366
366
367 curr = str(self.cache.last_prompt)
367 curr = str(self.cache.last_prompt)
368 nrspaces = len(self.rspace.search(curr).group())
368 nrspaces = len(self.rspace.search(curr).group())
369 return '%s%s>%s%s' % (self.col_p_ni,'-'*(len(curr)-nrspaces-1),
369 return '%s%s>%s%s' % (self.col_p_ni,'-'*(len(curr)-nrspaces-1),
370 ' '*nrspaces,self.col_norm_ni)
370 ' '*nrspaces,self.col_norm_ni)
371
371
372 class PromptOut(BasePrompt):
372 class PromptOut(BasePrompt):
373 """Output interactive prompt similar to Mathematica's."""
373 """Output interactive prompt similar to Mathematica's."""
374
374
375 def __init__(self,cache,sep='',prompt='Out[\\#]: ',pad_left=True):
375 def __init__(self,cache,sep='',prompt='Out[\\#]: ',pad_left=True):
376 BasePrompt.__init__(self,cache,sep,prompt,pad_left)
376 BasePrompt.__init__(self,cache,sep,prompt,pad_left)
377 if not self.p_template:
377 if not self.p_template:
378 self.__str__ = lambda: ''
378 self.__str__ = lambda: ''
379
379
380 def set_colors(self):
380 def set_colors(self):
381 self.set_p_str()
381 self.set_p_str()
382 Colors = self.cache.color_table.active_colors # shorthand
382 Colors = self.cache.color_table.active_colors # shorthand
383 self.col_p = Colors.out_prompt
383 self.col_p = Colors.out_prompt
384 self.col_num = Colors.out_number
384 self.col_num = Colors.out_number
385 self.col_norm = Colors.normal
385 self.col_norm = Colors.normal
386
386
387 class Prompt2(BasePrompt):
387 class Prompt2(BasePrompt):
388 """Interactive continuation prompt."""
388 """Interactive continuation prompt."""
389
389
390 def __init__(self,cache,prompt=' .\\D.: ',pad_left=True):
390 def __init__(self,cache,prompt=' .\\D.: ',pad_left=True):
391 self.cache = cache
391 self.cache = cache
392 self.p_template = prompt
392 self.p_template = prompt
393 self.pad_left = pad_left
393 self.pad_left = pad_left
394 self.set_p_str()
394 self.set_p_str()
395
395
396 def set_p_str(self):
396 def set_p_str(self):
397 import os,time # needed in locals for prompt string handling
397 import os,time # needed in locals for prompt string handling
398 loc = locals()
398 loc = locals()
399 self.p_str = ItplNS('%s%s%s' %
399 self.p_str = ItplNS('%s%s%s' %
400 ('${self.col_p2}',
400 ('${self.col_p2}',
401 multiple_replace(prompt_specials, self.p_template),
401 multiple_replace(prompt_specials, self.p_template),
402 '$self.col_norm'),
402 '$self.col_norm'),
403 self.cache.user_ns,loc)
403 self.cache.user_ns,loc)
404 self.p_str_nocolor = ItplNS(multiple_replace(prompt_specials_nocolor,
404 self.p_str_nocolor = ItplNS(multiple_replace(prompt_specials_nocolor,
405 self.p_template),
405 self.p_template),
406 self.cache.user_ns,loc)
406 self.cache.user_ns,loc)
407
407
408 def set_colors(self):
408 def set_colors(self):
409 self.set_p_str()
409 self.set_p_str()
410 Colors = self.cache.color_table.active_colors
410 Colors = self.cache.color_table.active_colors
411 self.col_p2 = Colors.in_prompt2
411 self.col_p2 = Colors.in_prompt2
412 self.col_norm = Colors.in_normal
412 self.col_norm = Colors.in_normal
413 # FIXME (2004-06-16) HACK: prevent crashes for users who haven't
413 # FIXME (2004-06-16) HACK: prevent crashes for users who haven't
414 # updated their prompt_in2 definitions. Remove eventually.
414 # updated their prompt_in2 definitions. Remove eventually.
415 self.col_p = Colors.out_prompt
415 self.col_p = Colors.out_prompt
416 self.col_num = Colors.out_number
416 self.col_num = Colors.out_number
417
417
418
418
419 #-----------------------------------------------------------------------------
419 #-----------------------------------------------------------------------------
420 class CachedOutput:
420 class CachedOutput:
421 """Class for printing output from calculations while keeping a cache of
421 """Class for printing output from calculations while keeping a cache of
422 reults. It dynamically creates global variables prefixed with _ which
422 reults. It dynamically creates global variables prefixed with _ which
423 contain these results.
423 contain these results.
424
424
425 Meant to be used as a sys.displayhook replacement, providing numbered
425 Meant to be used as a sys.displayhook replacement, providing numbered
426 prompts and cache services.
426 prompts and cache services.
427
427
428 Initialize with initial and final values for cache counter (this defines
428 Initialize with initial and final values for cache counter (this defines
429 the maximum size of the cache."""
429 the maximum size of the cache."""
430
430
431 def __init__(self,shell,cache_size,Pprint,
431 def __init__(self,shell,cache_size,Pprint,
432 colors='NoColor',input_sep='\n',
432 colors='NoColor',input_sep='\n',
433 output_sep='\n',output_sep2='',
433 output_sep='\n',output_sep2='',
434 ps1 = None, ps2 = None,ps_out = None,pad_left=True):
434 ps1 = None, ps2 = None,ps_out = None,pad_left=True):
435
435
436 cache_size_min = 3
436 cache_size_min = 3
437 if cache_size <= 0:
437 if cache_size <= 0:
438 self.do_full_cache = 0
438 self.do_full_cache = 0
439 cache_size = 0
439 cache_size = 0
440 elif cache_size < cache_size_min:
440 elif cache_size < cache_size_min:
441 self.do_full_cache = 0
441 self.do_full_cache = 0
442 cache_size = 0
442 cache_size = 0
443 warn('caching was disabled (min value for cache size is %s).' %
443 warn('caching was disabled (min value for cache size is %s).' %
444 cache_size_min,level=3)
444 cache_size_min,level=3)
445 else:
445 else:
446 self.do_full_cache = 1
446 self.do_full_cache = 1
447
447
448 self.cache_size = cache_size
448 self.cache_size = cache_size
449 self.input_sep = input_sep
449 self.input_sep = input_sep
450
450
451 # we need a reference to the user-level namespace
451 # we need a reference to the user-level namespace
452 self.shell = shell
452 self.shell = shell
453 self.user_ns = shell.user_ns
453 self.user_ns = shell.user_ns
454 # and to the user's input
454 # and to the user's input
455 self.input_hist = shell.input_hist
455 self.input_hist = shell.input_hist
456 # and to the user's logger, for logging output
456 # and to the user's logger, for logging output
457 self.logger = shell.logger
457 self.logger = shell.logger
458
458
459 # Set input prompt strings and colors
459 # Set input prompt strings and colors
460 if cache_size == 0:
460 if cache_size == 0:
461 if ps1.find('%n') > -1 or ps1.find(r'\#') > -1 \
461 if ps1.find('%n') > -1 or ps1.find(r'\#') > -1 \
462 or ps1.find(r'\N') > -1:
462 or ps1.find(r'\N') > -1:
463 ps1 = '>>> '
463 ps1 = '>>> '
464 if ps2.find('%n') > -1 or ps2.find(r'\#') > -1 \
464 if ps2.find('%n') > -1 or ps2.find(r'\#') > -1 \
465 or ps2.find(r'\N') > -1:
465 or ps2.find(r'\N') > -1:
466 ps2 = '... '
466 ps2 = '... '
467 self.ps1_str = self._set_prompt_str(ps1,'In [\\#]: ','>>> ')
467 self.ps1_str = self._set_prompt_str(ps1,'In [\\#]: ','>>> ')
468 self.ps2_str = self._set_prompt_str(ps2,' .\\D.: ','... ')
468 self.ps2_str = self._set_prompt_str(ps2,' .\\D.: ','... ')
469 self.ps_out_str = self._set_prompt_str(ps_out,'Out[\\#]: ','')
469 self.ps_out_str = self._set_prompt_str(ps_out,'Out[\\#]: ','')
470
470
471 self.color_table = PromptColors
471 self.color_table = PromptColors
472 self.prompt1 = Prompt1(self,sep=input_sep,prompt=self.ps1_str,
472 self.prompt1 = Prompt1(self,sep=input_sep,prompt=self.ps1_str,
473 pad_left=pad_left)
473 pad_left=pad_left)
474 self.prompt2 = Prompt2(self,prompt=self.ps2_str,pad_left=pad_left)
474 self.prompt2 = Prompt2(self,prompt=self.ps2_str,pad_left=pad_left)
475 self.prompt_out = PromptOut(self,sep='',prompt=self.ps_out_str,
475 self.prompt_out = PromptOut(self,sep='',prompt=self.ps_out_str,
476 pad_left=pad_left)
476 pad_left=pad_left)
477 self.set_colors(colors)
477 self.set_colors(colors)
478
478
479 # other more normal stuff
479 # other more normal stuff
480 # b/c each call to the In[] prompt raises it by 1, even the first.
480 # b/c each call to the In[] prompt raises it by 1, even the first.
481 self.prompt_count = 0
481 self.prompt_count = 0
482 # Store the last prompt string each time, we need it for aligning
482 # Store the last prompt string each time, we need it for aligning
483 # continuation and auto-rewrite prompts
483 # continuation and auto-rewrite prompts
484 self.last_prompt = ''
484 self.last_prompt = ''
485 self.Pprint = Pprint
485 self.Pprint = Pprint
486 self.output_sep = output_sep
486 self.output_sep = output_sep
487 self.output_sep2 = output_sep2
487 self.output_sep2 = output_sep2
488 self._,self.__,self.___ = '','',''
488 self._,self.__,self.___ = '','',''
489 self.pprint_types = map(type,[(),[],{}])
489 self.pprint_types = map(type,[(),[],{}])
490
490
491 # these are deliberately global:
491 # these are deliberately global:
492 to_user_ns = {'_':self._,'__':self.__,'___':self.___}
492 to_user_ns = {'_':self._,'__':self.__,'___':self.___}
493 self.user_ns.update(to_user_ns)
493 self.user_ns.update(to_user_ns)
494
494
495 def _set_prompt_str(self,p_str,cache_def,no_cache_def):
495 def _set_prompt_str(self,p_str,cache_def,no_cache_def):
496 if p_str is None:
496 if p_str is None:
497 if self.do_full_cache:
497 if self.do_full_cache:
498 return cache_def
498 return cache_def
499 else:
499 else:
500 return no_cache_def
500 return no_cache_def
501 else:
501 else:
502 return p_str
502 return p_str
503
503
504 def set_colors(self,colors):
504 def set_colors(self,colors):
505 """Set the active color scheme and configure colors for the three
505 """Set the active color scheme and configure colors for the three
506 prompt subsystems."""
506 prompt subsystems."""
507
507
508 # FIXME: the prompt_specials global should be gobbled inside this
508 # FIXME: the prompt_specials global should be gobbled inside this
509 # class instead. Do it when cleaning up the whole 3-prompt system.
509 # class instead. Do it when cleaning up the whole 3-prompt system.
510 global prompt_specials
510 global prompt_specials
511 if colors.lower()=='nocolor':
511 if colors.lower()=='nocolor':
512 prompt_specials = prompt_specials_nocolor
512 prompt_specials = prompt_specials_nocolor
513 else:
513 else:
514 prompt_specials = prompt_specials_color
514 prompt_specials = prompt_specials_color
515
515
516 self.color_table.set_active_scheme(colors)
516 self.color_table.set_active_scheme(colors)
517 self.prompt1.set_colors()
517 self.prompt1.set_colors()
518 self.prompt2.set_colors()
518 self.prompt2.set_colors()
519 self.prompt_out.set_colors()
519 self.prompt_out.set_colors()
520
520
521 def __call__(self,arg=None):
521 def __call__(self,arg=None):
522 """Printing with history cache management.
522 """Printing with history cache management.
523
523
524 This is invoked everytime the interpreter needs to print, and is
524 This is invoked everytime the interpreter needs to print, and is
525 activated by setting the variable sys.displayhook to it."""
525 activated by setting the variable sys.displayhook to it."""
526
526
527 # If something injected a '_' variable in __builtin__, delete
527 # If something injected a '_' variable in __builtin__, delete
528 # ipython's automatic one so we don't clobber that. gettext() in
528 # ipython's automatic one so we don't clobber that. gettext() in
529 # particular uses _, so we need to stay away from it.
529 # particular uses _, so we need to stay away from it.
530 if '_' in __builtin__.__dict__:
530 if '_' in __builtin__.__dict__:
531 try:
531 try:
532 del self.user_ns['_']
532 del self.user_ns['_']
533 except KeyError:
533 except KeyError:
534 pass
534 pass
535 if arg is not None:
535 if arg is not None:
536 cout_write = Term.cout.write # fast lookup
536 cout_write = Term.cout.write # fast lookup
537 # first handle the cache and counters
537 # first handle the cache and counters
538
538
539 # do not print output if input ends in ';'
539 # do not print output if input ends in ';'
540 try:
540 try:
541 if self.input_hist[self.prompt_count].endswith(';\n'):
541 if self.input_hist[self.prompt_count].endswith(';\n'):
542 return
542 return
543 except IndexError:
543 except IndexError:
544 # some uses of ipshellembed may fail here
544 # some uses of ipshellembed may fail here
545 pass
545 pass
546 # don't use print, puts an extra space
546 # don't use print, puts an extra space
547 cout_write(self.output_sep)
547 cout_write(self.output_sep)
548 outprompt = self.shell.hooks.generate_output_prompt()
548 outprompt = self.shell.hooks.generate_output_prompt()
549 if self.do_full_cache:
549 if self.do_full_cache:
550 cout_write(outprompt)
550 cout_write(outprompt)
551
551
552 # and now call a possibly user-defined print mechanism
552 # and now call a possibly user-defined print mechanism
553 manipulated_val = self.display(arg)
553 manipulated_val = self.display(arg)
554
554
555 # user display hooks can change the variable to be stored in
555 # user display hooks can change the variable to be stored in
556 # output history
556 # output history
557
557
558 if manipulated_val is not None:
558 if manipulated_val is not None:
559 arg = manipulated_val
559 arg = manipulated_val
560
560
561 # avoid recursive reference when displaying _oh/Out
561 # avoid recursive reference when displaying _oh/Out
562 if arg is not self.user_ns['_oh']:
562 if arg is not self.user_ns['_oh']:
563 self.update(arg)
563 self.update(arg)
564
564
565 if self.logger.log_output:
565 if self.logger.log_output:
566 self.logger.log_write(repr(arg),'output')
566 self.logger.log_write(repr(arg),'output')
567 cout_write(self.output_sep2)
567 cout_write(self.output_sep2)
568 Term.cout.flush()
568 Term.cout.flush()
569
569
570 def _display(self,arg):
570 def _display(self,arg):
571 """Default printer method, uses pprint.
571 """Default printer method, uses pprint.
572
572
573 Do ip.set_hook("result_display", my_displayhook) for custom result
573 Do ip.set_hook("result_display", my_displayhook) for custom result
574 display, e.g. when your own objects need special formatting.
574 display, e.g. when your own objects need special formatting.
575 """
575 """
576 try:
576 try:
577 return IPython.utils.generics.result_display(arg)
577 return IPython.utils.generics.result_display(arg)
578 except TryNext:
578 except TryNext:
579 return self.shell.hooks.result_display(arg)
579 return self.shell.hooks.result_display(arg)
580
580
581 # Assign the default display method:
581 # Assign the default display method:
582 display = _display
582 display = _display
583
583
584 def update(self,arg):
584 def update(self,arg):
585 #print '***cache_count', self.cache_count # dbg
585 #print '***cache_count', self.cache_count # dbg
586 if len(self.user_ns['_oh']) >= self.cache_size and self.do_full_cache:
586 if len(self.user_ns['_oh']) >= self.cache_size and self.do_full_cache:
587 warn('Output cache limit (currently '+
587 warn('Output cache limit (currently '+
588 `self.cache_size`+' entries) hit.\n'
588 `self.cache_size`+' entries) hit.\n'
589 'Flushing cache and resetting history counter...\n'
589 'Flushing cache and resetting history counter...\n'
590 'The only history variables available will be _,__,___ and _1\n'
590 'The only history variables available will be _,__,___ and _1\n'
591 'with the current result.')
591 'with the current result.')
592
592
593 self.flush()
593 self.flush()
594 # Don't overwrite '_' and friends if '_' is in __builtin__ (otherwise
594 # Don't overwrite '_' and friends if '_' is in __builtin__ (otherwise
595 # we cause buggy behavior for things like gettext).
595 # we cause buggy behavior for things like gettext).
596 if '_' not in __builtin__.__dict__:
596 if '_' not in __builtin__.__dict__:
597 self.___ = self.__
597 self.___ = self.__
598 self.__ = self._
598 self.__ = self._
599 self._ = arg
599 self._ = arg
600 self.user_ns.update({'_':self._,'__':self.__,'___':self.___})
600 self.user_ns.update({'_':self._,'__':self.__,'___':self.___})
601
601
602 # hackish access to top-level namespace to create _1,_2... dynamically
602 # hackish access to top-level namespace to create _1,_2... dynamically
603 to_main = {}
603 to_main = {}
604 if self.do_full_cache:
604 if self.do_full_cache:
605 new_result = '_'+`self.prompt_count`
605 new_result = '_'+`self.prompt_count`
606 to_main[new_result] = arg
606 to_main[new_result] = arg
607 self.user_ns.update(to_main)
607 self.user_ns.update(to_main)
608 self.user_ns['_oh'][self.prompt_count] = arg
608 self.user_ns['_oh'][self.prompt_count] = arg
609
609
610 def flush(self):
610 def flush(self):
611 if not self.do_full_cache:
611 if not self.do_full_cache:
612 raise ValueError,"You shouldn't have reached the cache flush "\
612 raise ValueError,"You shouldn't have reached the cache flush "\
613 "if full caching is not enabled!"
613 "if full caching is not enabled!"
614 # delete auto-generated vars from global namespace
614 # delete auto-generated vars from global namespace
615
615
616 for n in range(1,self.prompt_count + 1):
616 for n in range(1,self.prompt_count + 1):
617 key = '_'+`n`
617 key = '_'+`n`
618 try:
618 try:
619 del self.user_ns[key]
619 del self.user_ns[key]
620 except: pass
620 except: pass
621 self.user_ns['_oh'].clear()
621 self.user_ns['_oh'].clear()
622
622
623 if '_' not in __builtin__.__dict__:
623 if '_' not in __builtin__.__dict__:
624 self.user_ns.update({'_':None,'__':None, '___':None})
624 self.user_ns.update({'_':None,'__':None, '___':None})
625 import gc
625 import gc
626 gc.collect() # xxx needed?
626 gc.collect() # xxx needed?
627
627
@@ -1,1246 +1,1246 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """IPython Shell classes.
2 """IPython Shell classes.
3
3
4 All the matplotlib support code was co-developed with John Hunter,
4 All the matplotlib support code was co-developed with John Hunter,
5 matplotlib's author.
5 matplotlib's author.
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 # Code begins
15 # Code begins
16 # Stdlib imports
16 # Stdlib imports
17 import __builtin__
17 import __builtin__
18 import __main__
18 import __main__
19 import Queue
19 import Queue
20 import inspect
20 import inspect
21 import os
21 import os
22 import sys
22 import sys
23 import thread
23 import thread
24 import threading
24 import threading
25 import time
25 import time
26
26
27 from signal import signal, SIGINT
27 from signal import signal, SIGINT
28
28
29 try:
29 try:
30 import ctypes
30 import ctypes
31 HAS_CTYPES = True
31 HAS_CTYPES = True
32 except ImportError:
32 except ImportError:
33 HAS_CTYPES = False
33 HAS_CTYPES = False
34
34
35 # IPython imports
35 # IPython imports
36 import IPython
36 import IPython
37 from IPython import ultraTB, ipapi
37 from IPython import ultraTB, ipapi
38 from IPython.Magic import Magic
38 from IPython.Magic import Magic
39 from IPython.genutils import Term,warn,error,flag_calls, ask_yes_no
39 from IPython.utils.genutils import Term,warn,error,flag_calls, ask_yes_no
40 from IPython.iplib import InteractiveShell
40 from IPython.iplib import InteractiveShell
41 from IPython.ipmaker import make_IPython
41 from IPython.ipmaker import make_IPython
42 from IPython.ipstruct import Struct
42 from IPython.ipstruct import Struct
43 from IPython.testing import decorators as testdec
43 from IPython.testing import decorators as testdec
44
44
45 # Globals
45 # Globals
46 # global flag to pass around information about Ctrl-C without exceptions
46 # global flag to pass around information about Ctrl-C without exceptions
47 KBINT = False
47 KBINT = False
48
48
49 # global flag to turn on/off Tk support.
49 # global flag to turn on/off Tk support.
50 USE_TK = False
50 USE_TK = False
51
51
52 # ID for the main thread, used for cross-thread exceptions
52 # ID for the main thread, used for cross-thread exceptions
53 MAIN_THREAD_ID = thread.get_ident()
53 MAIN_THREAD_ID = thread.get_ident()
54
54
55 # Tag when runcode() is active, for exception handling
55 # Tag when runcode() is active, for exception handling
56 CODE_RUN = None
56 CODE_RUN = None
57
57
58 # Default timeout for waiting for multithreaded shells (in seconds)
58 # Default timeout for waiting for multithreaded shells (in seconds)
59 GUI_TIMEOUT = 10
59 GUI_TIMEOUT = 10
60
60
61 #-----------------------------------------------------------------------------
61 #-----------------------------------------------------------------------------
62 # This class is trivial now, but I want to have it in to publish a clean
62 # This class is trivial now, but I want to have it in to publish a clean
63 # interface. Later when the internals are reorganized, code that uses this
63 # interface. Later when the internals are reorganized, code that uses this
64 # shouldn't have to change.
64 # shouldn't have to change.
65
65
66 class IPShell:
66 class IPShell:
67 """Create an IPython instance."""
67 """Create an IPython instance."""
68
68
69 def __init__(self,argv=None,user_ns=None,user_global_ns=None,
69 def __init__(self,argv=None,user_ns=None,user_global_ns=None,
70 debug=1,shell_class=InteractiveShell):
70 debug=1,shell_class=InteractiveShell):
71 self.IP = make_IPython(argv,user_ns=user_ns,
71 self.IP = make_IPython(argv,user_ns=user_ns,
72 user_global_ns=user_global_ns,
72 user_global_ns=user_global_ns,
73 debug=debug,shell_class=shell_class)
73 debug=debug,shell_class=shell_class)
74
74
75 def mainloop(self,sys_exit=0,banner=None):
75 def mainloop(self,sys_exit=0,banner=None):
76 self.IP.mainloop(banner)
76 self.IP.mainloop(banner)
77 if sys_exit:
77 if sys_exit:
78 sys.exit()
78 sys.exit()
79
79
80 #-----------------------------------------------------------------------------
80 #-----------------------------------------------------------------------------
81 def kill_embedded(self,parameter_s=''):
81 def kill_embedded(self,parameter_s=''):
82 """%kill_embedded : deactivate for good the current embedded IPython.
82 """%kill_embedded : deactivate for good the current embedded IPython.
83
83
84 This function (after asking for confirmation) sets an internal flag so that
84 This function (after asking for confirmation) sets an internal flag so that
85 an embedded IPython will never activate again. This is useful to
85 an embedded IPython will never activate again. This is useful to
86 permanently disable a shell that is being called inside a loop: once you've
86 permanently disable a shell that is being called inside a loop: once you've
87 figured out what you needed from it, you may then kill it and the program
87 figured out what you needed from it, you may then kill it and the program
88 will then continue to run without the interactive shell interfering again.
88 will then continue to run without the interactive shell interfering again.
89 """
89 """
90
90
91 kill = ask_yes_no("Are you sure you want to kill this embedded instance "
91 kill = ask_yes_no("Are you sure you want to kill this embedded instance "
92 "(y/n)? [y/N] ",'n')
92 "(y/n)? [y/N] ",'n')
93 if kill:
93 if kill:
94 self.shell.embedded_active = False
94 self.shell.embedded_active = False
95 print "This embedded IPython will not reactivate anymore once you exit."
95 print "This embedded IPython will not reactivate anymore once you exit."
96
96
97 class IPShellEmbed:
97 class IPShellEmbed:
98 """Allow embedding an IPython shell into a running program.
98 """Allow embedding an IPython shell into a running program.
99
99
100 Instances of this class are callable, with the __call__ method being an
100 Instances of this class are callable, with the __call__ method being an
101 alias to the embed() method of an InteractiveShell instance.
101 alias to the embed() method of an InteractiveShell instance.
102
102
103 Usage (see also the example-embed.py file for a running example):
103 Usage (see also the example-embed.py file for a running example):
104
104
105 ipshell = IPShellEmbed([argv,banner,exit_msg,rc_override])
105 ipshell = IPShellEmbed([argv,banner,exit_msg,rc_override])
106
106
107 - argv: list containing valid command-line options for IPython, as they
107 - argv: list containing valid command-line options for IPython, as they
108 would appear in sys.argv[1:].
108 would appear in sys.argv[1:].
109
109
110 For example, the following command-line options:
110 For example, the following command-line options:
111
111
112 $ ipython -prompt_in1 'Input <\\#>' -colors LightBG
112 $ ipython -prompt_in1 'Input <\\#>' -colors LightBG
113
113
114 would be passed in the argv list as:
114 would be passed in the argv list as:
115
115
116 ['-prompt_in1','Input <\\#>','-colors','LightBG']
116 ['-prompt_in1','Input <\\#>','-colors','LightBG']
117
117
118 - banner: string which gets printed every time the interpreter starts.
118 - banner: string which gets printed every time the interpreter starts.
119
119
120 - exit_msg: string which gets printed every time the interpreter exits.
120 - exit_msg: string which gets printed every time the interpreter exits.
121
121
122 - rc_override: a dict or Struct of configuration options such as those
122 - rc_override: a dict or Struct of configuration options such as those
123 used by IPython. These options are read from your ~/.ipython/ipythonrc
123 used by IPython. These options are read from your ~/.ipython/ipythonrc
124 file when the Shell object is created. Passing an explicit rc_override
124 file when the Shell object is created. Passing an explicit rc_override
125 dict with any options you want allows you to override those values at
125 dict with any options you want allows you to override those values at
126 creation time without having to modify the file. This way you can create
126 creation time without having to modify the file. This way you can create
127 embeddable instances configured in any way you want without editing any
127 embeddable instances configured in any way you want without editing any
128 global files (thus keeping your interactive IPython configuration
128 global files (thus keeping your interactive IPython configuration
129 unchanged).
129 unchanged).
130
130
131 Then the ipshell instance can be called anywhere inside your code:
131 Then the ipshell instance can be called anywhere inside your code:
132
132
133 ipshell(header='') -> Opens up an IPython shell.
133 ipshell(header='') -> Opens up an IPython shell.
134
134
135 - header: string printed by the IPython shell upon startup. This can let
135 - header: string printed by the IPython shell upon startup. This can let
136 you know where in your code you are when dropping into the shell. Note
136 you know where in your code you are when dropping into the shell. Note
137 that 'banner' gets prepended to all calls, so header is used for
137 that 'banner' gets prepended to all calls, so header is used for
138 location-specific information.
138 location-specific information.
139
139
140 For more details, see the __call__ method below.
140 For more details, see the __call__ method below.
141
141
142 When the IPython shell is exited with Ctrl-D, normal program execution
142 When the IPython shell is exited with Ctrl-D, normal program execution
143 resumes.
143 resumes.
144
144
145 This functionality was inspired by a posting on comp.lang.python by cmkl
145 This functionality was inspired by a posting on comp.lang.python by cmkl
146 <cmkleffner@gmx.de> on Dec. 06/01 concerning similar uses of pyrepl, and
146 <cmkleffner@gmx.de> on Dec. 06/01 concerning similar uses of pyrepl, and
147 by the IDL stop/continue commands."""
147 by the IDL stop/continue commands."""
148
148
149 def __init__(self,argv=None,banner='',exit_msg=None,rc_override=None,
149 def __init__(self,argv=None,banner='',exit_msg=None,rc_override=None,
150 user_ns=None):
150 user_ns=None):
151 """Note that argv here is a string, NOT a list."""
151 """Note that argv here is a string, NOT a list."""
152 self.set_banner(banner)
152 self.set_banner(banner)
153 self.set_exit_msg(exit_msg)
153 self.set_exit_msg(exit_msg)
154 self.set_dummy_mode(0)
154 self.set_dummy_mode(0)
155
155
156 # sys.displayhook is a global, we need to save the user's original
156 # sys.displayhook is a global, we need to save the user's original
157 # Don't rely on __displayhook__, as the user may have changed that.
157 # Don't rely on __displayhook__, as the user may have changed that.
158 self.sys_displayhook_ori = sys.displayhook
158 self.sys_displayhook_ori = sys.displayhook
159
159
160 # save readline completer status
160 # save readline completer status
161 try:
161 try:
162 #print 'Save completer',sys.ipcompleter # dbg
162 #print 'Save completer',sys.ipcompleter # dbg
163 self.sys_ipcompleter_ori = sys.ipcompleter
163 self.sys_ipcompleter_ori = sys.ipcompleter
164 except:
164 except:
165 pass # not nested with IPython
165 pass # not nested with IPython
166
166
167 self.IP = make_IPython(argv,rc_override=rc_override,
167 self.IP = make_IPython(argv,rc_override=rc_override,
168 embedded=True,
168 embedded=True,
169 user_ns=user_ns)
169 user_ns=user_ns)
170
170
171 ip = ipapi.IPApi(self.IP)
171 ip = ipapi.IPApi(self.IP)
172 ip.expose_magic("kill_embedded",kill_embedded)
172 ip.expose_magic("kill_embedded",kill_embedded)
173
173
174 # copy our own displayhook also
174 # copy our own displayhook also
175 self.sys_displayhook_embed = sys.displayhook
175 self.sys_displayhook_embed = sys.displayhook
176 # and leave the system's display hook clean
176 # and leave the system's display hook clean
177 sys.displayhook = self.sys_displayhook_ori
177 sys.displayhook = self.sys_displayhook_ori
178 # don't use the ipython crash handler so that user exceptions aren't
178 # don't use the ipython crash handler so that user exceptions aren't
179 # trapped
179 # trapped
180 sys.excepthook = ultraTB.FormattedTB(color_scheme = self.IP.rc.colors,
180 sys.excepthook = ultraTB.FormattedTB(color_scheme = self.IP.rc.colors,
181 mode = self.IP.rc.xmode,
181 mode = self.IP.rc.xmode,
182 call_pdb = self.IP.rc.pdb)
182 call_pdb = self.IP.rc.pdb)
183 self.restore_system_completer()
183 self.restore_system_completer()
184
184
185 def restore_system_completer(self):
185 def restore_system_completer(self):
186 """Restores the readline completer which was in place.
186 """Restores the readline completer which was in place.
187
187
188 This allows embedded IPython within IPython not to disrupt the
188 This allows embedded IPython within IPython not to disrupt the
189 parent's completion.
189 parent's completion.
190 """
190 """
191
191
192 try:
192 try:
193 self.IP.readline.set_completer(self.sys_ipcompleter_ori)
193 self.IP.readline.set_completer(self.sys_ipcompleter_ori)
194 sys.ipcompleter = self.sys_ipcompleter_ori
194 sys.ipcompleter = self.sys_ipcompleter_ori
195 except:
195 except:
196 pass
196 pass
197
197
198 def __call__(self,header='',local_ns=None,global_ns=None,dummy=None):
198 def __call__(self,header='',local_ns=None,global_ns=None,dummy=None):
199 """Activate the interactive interpreter.
199 """Activate the interactive interpreter.
200
200
201 __call__(self,header='',local_ns=None,global_ns,dummy=None) -> Start
201 __call__(self,header='',local_ns=None,global_ns,dummy=None) -> Start
202 the interpreter shell with the given local and global namespaces, and
202 the interpreter shell with the given local and global namespaces, and
203 optionally print a header string at startup.
203 optionally print a header string at startup.
204
204
205 The shell can be globally activated/deactivated using the
205 The shell can be globally activated/deactivated using the
206 set/get_dummy_mode methods. This allows you to turn off a shell used
206 set/get_dummy_mode methods. This allows you to turn off a shell used
207 for debugging globally.
207 for debugging globally.
208
208
209 However, *each* time you call the shell you can override the current
209 However, *each* time you call the shell you can override the current
210 state of dummy_mode with the optional keyword parameter 'dummy'. For
210 state of dummy_mode with the optional keyword parameter 'dummy'. For
211 example, if you set dummy mode on with IPShell.set_dummy_mode(1), you
211 example, if you set dummy mode on with IPShell.set_dummy_mode(1), you
212 can still have a specific call work by making it as IPShell(dummy=0).
212 can still have a specific call work by making it as IPShell(dummy=0).
213
213
214 The optional keyword parameter dummy controls whether the call
214 The optional keyword parameter dummy controls whether the call
215 actually does anything. """
215 actually does anything. """
216
216
217 # If the user has turned it off, go away
217 # If the user has turned it off, go away
218 if not self.IP.embedded_active:
218 if not self.IP.embedded_active:
219 return
219 return
220
220
221 # Normal exits from interactive mode set this flag, so the shell can't
221 # Normal exits from interactive mode set this flag, so the shell can't
222 # re-enter (it checks this variable at the start of interactive mode).
222 # re-enter (it checks this variable at the start of interactive mode).
223 self.IP.exit_now = False
223 self.IP.exit_now = False
224
224
225 # Allow the dummy parameter to override the global __dummy_mode
225 # Allow the dummy parameter to override the global __dummy_mode
226 if dummy or (dummy != 0 and self.__dummy_mode):
226 if dummy or (dummy != 0 and self.__dummy_mode):
227 return
227 return
228
228
229 # Set global subsystems (display,completions) to our values
229 # Set global subsystems (display,completions) to our values
230 sys.displayhook = self.sys_displayhook_embed
230 sys.displayhook = self.sys_displayhook_embed
231 if self.IP.has_readline:
231 if self.IP.has_readline:
232 self.IP.set_completer()
232 self.IP.set_completer()
233
233
234 if self.banner and header:
234 if self.banner and header:
235 format = '%s\n%s\n'
235 format = '%s\n%s\n'
236 else:
236 else:
237 format = '%s%s\n'
237 format = '%s%s\n'
238 banner = format % (self.banner,header)
238 banner = format % (self.banner,header)
239
239
240 # Call the embedding code with a stack depth of 1 so it can skip over
240 # Call the embedding code with a stack depth of 1 so it can skip over
241 # our call and get the original caller's namespaces.
241 # our call and get the original caller's namespaces.
242 self.IP.embed_mainloop(banner,local_ns,global_ns,stack_depth=1)
242 self.IP.embed_mainloop(banner,local_ns,global_ns,stack_depth=1)
243
243
244 if self.exit_msg:
244 if self.exit_msg:
245 print self.exit_msg
245 print self.exit_msg
246
246
247 # Restore global systems (display, completion)
247 # Restore global systems (display, completion)
248 sys.displayhook = self.sys_displayhook_ori
248 sys.displayhook = self.sys_displayhook_ori
249 self.restore_system_completer()
249 self.restore_system_completer()
250
250
251 def set_dummy_mode(self,dummy):
251 def set_dummy_mode(self,dummy):
252 """Sets the embeddable shell's dummy mode parameter.
252 """Sets the embeddable shell's dummy mode parameter.
253
253
254 set_dummy_mode(dummy): dummy = 0 or 1.
254 set_dummy_mode(dummy): dummy = 0 or 1.
255
255
256 This parameter is persistent and makes calls to the embeddable shell
256 This parameter is persistent and makes calls to the embeddable shell
257 silently return without performing any action. This allows you to
257 silently return without performing any action. This allows you to
258 globally activate or deactivate a shell you're using with a single call.
258 globally activate or deactivate a shell you're using with a single call.
259
259
260 If you need to manually"""
260 If you need to manually"""
261
261
262 if dummy not in [0,1,False,True]:
262 if dummy not in [0,1,False,True]:
263 raise ValueError,'dummy parameter must be boolean'
263 raise ValueError,'dummy parameter must be boolean'
264 self.__dummy_mode = dummy
264 self.__dummy_mode = dummy
265
265
266 def get_dummy_mode(self):
266 def get_dummy_mode(self):
267 """Return the current value of the dummy mode parameter.
267 """Return the current value of the dummy mode parameter.
268 """
268 """
269 return self.__dummy_mode
269 return self.__dummy_mode
270
270
271 def set_banner(self,banner):
271 def set_banner(self,banner):
272 """Sets the global banner.
272 """Sets the global banner.
273
273
274 This banner gets prepended to every header printed when the shell
274 This banner gets prepended to every header printed when the shell
275 instance is called."""
275 instance is called."""
276
276
277 self.banner = banner
277 self.banner = banner
278
278
279 def set_exit_msg(self,exit_msg):
279 def set_exit_msg(self,exit_msg):
280 """Sets the global exit_msg.
280 """Sets the global exit_msg.
281
281
282 This exit message gets printed upon exiting every time the embedded
282 This exit message gets printed upon exiting every time the embedded
283 shell is called. It is None by default. """
283 shell is called. It is None by default. """
284
284
285 self.exit_msg = exit_msg
285 self.exit_msg = exit_msg
286
286
287 #-----------------------------------------------------------------------------
287 #-----------------------------------------------------------------------------
288 if HAS_CTYPES:
288 if HAS_CTYPES:
289 # Add async exception support. Trick taken from:
289 # Add async exception support. Trick taken from:
290 # http://sebulba.wikispaces.com/recipe+thread2
290 # http://sebulba.wikispaces.com/recipe+thread2
291 def _async_raise(tid, exctype):
291 def _async_raise(tid, exctype):
292 """raises the exception, performs cleanup if needed"""
292 """raises the exception, performs cleanup if needed"""
293 if not inspect.isclass(exctype):
293 if not inspect.isclass(exctype):
294 raise TypeError("Only types can be raised (not instances)")
294 raise TypeError("Only types can be raised (not instances)")
295 # Explicit cast to c_long is necessary for 64-bit support:
295 # Explicit cast to c_long is necessary for 64-bit support:
296 # See https://bugs.launchpad.net/ipython/+bug/237073
296 # See https://bugs.launchpad.net/ipython/+bug/237073
297 res = ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(tid),
297 res = ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(tid),
298 ctypes.py_object(exctype))
298 ctypes.py_object(exctype))
299 if res == 0:
299 if res == 0:
300 raise ValueError("invalid thread id")
300 raise ValueError("invalid thread id")
301 elif res != 1:
301 elif res != 1:
302 # If it returns a number greater than one, you're in trouble,
302 # If it returns a number greater than one, you're in trouble,
303 # and you should call it again with exc=NULL to revert the effect
303 # and you should call it again with exc=NULL to revert the effect
304 ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, 0)
304 ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, 0)
305 raise SystemError("PyThreadState_SetAsyncExc failed")
305 raise SystemError("PyThreadState_SetAsyncExc failed")
306
306
307 def sigint_handler(signum,stack_frame):
307 def sigint_handler(signum,stack_frame):
308 """Sigint handler for threaded apps.
308 """Sigint handler for threaded apps.
309
309
310 This is a horrible hack to pass information about SIGINT _without_
310 This is a horrible hack to pass information about SIGINT _without_
311 using exceptions, since I haven't been able to properly manage
311 using exceptions, since I haven't been able to properly manage
312 cross-thread exceptions in GTK/WX. In fact, I don't think it can be
312 cross-thread exceptions in GTK/WX. In fact, I don't think it can be
313 done (or at least that's my understanding from a c.l.py thread where
313 done (or at least that's my understanding from a c.l.py thread where
314 this was discussed)."""
314 this was discussed)."""
315
315
316 global KBINT
316 global KBINT
317
317
318 if CODE_RUN:
318 if CODE_RUN:
319 _async_raise(MAIN_THREAD_ID,KeyboardInterrupt)
319 _async_raise(MAIN_THREAD_ID,KeyboardInterrupt)
320 else:
320 else:
321 KBINT = True
321 KBINT = True
322 print '\nKeyboardInterrupt - Press <Enter> to continue.',
322 print '\nKeyboardInterrupt - Press <Enter> to continue.',
323 Term.cout.flush()
323 Term.cout.flush()
324
324
325 else:
325 else:
326 def sigint_handler(signum,stack_frame):
326 def sigint_handler(signum,stack_frame):
327 """Sigint handler for threaded apps.
327 """Sigint handler for threaded apps.
328
328
329 This is a horrible hack to pass information about SIGINT _without_
329 This is a horrible hack to pass information about SIGINT _without_
330 using exceptions, since I haven't been able to properly manage
330 using exceptions, since I haven't been able to properly manage
331 cross-thread exceptions in GTK/WX. In fact, I don't think it can be
331 cross-thread exceptions in GTK/WX. In fact, I don't think it can be
332 done (or at least that's my understanding from a c.l.py thread where
332 done (or at least that's my understanding from a c.l.py thread where
333 this was discussed)."""
333 this was discussed)."""
334
334
335 global KBINT
335 global KBINT
336
336
337 print '\nKeyboardInterrupt - Press <Enter> to continue.',
337 print '\nKeyboardInterrupt - Press <Enter> to continue.',
338 Term.cout.flush()
338 Term.cout.flush()
339 # Set global flag so that runsource can know that Ctrl-C was hit
339 # Set global flag so that runsource can know that Ctrl-C was hit
340 KBINT = True
340 KBINT = True
341
341
342
342
343 class MTInteractiveShell(InteractiveShell):
343 class MTInteractiveShell(InteractiveShell):
344 """Simple multi-threaded shell."""
344 """Simple multi-threaded shell."""
345
345
346 # Threading strategy taken from:
346 # Threading strategy taken from:
347 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/65109, by Brian
347 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/65109, by Brian
348 # McErlean and John Finlay. Modified with corrections by Antoon Pardon,
348 # McErlean and John Finlay. Modified with corrections by Antoon Pardon,
349 # from the pygtk mailing list, to avoid lockups with system calls.
349 # from the pygtk mailing list, to avoid lockups with system calls.
350
350
351 # class attribute to indicate whether the class supports threads or not.
351 # class attribute to indicate whether the class supports threads or not.
352 # Subclasses with thread support should override this as needed.
352 # Subclasses with thread support should override this as needed.
353 isthreaded = True
353 isthreaded = True
354
354
355 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
355 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
356 user_ns=None,user_global_ns=None,banner2='',
356 user_ns=None,user_global_ns=None,banner2='',
357 gui_timeout=GUI_TIMEOUT,**kw):
357 gui_timeout=GUI_TIMEOUT,**kw):
358 """Similar to the normal InteractiveShell, but with threading control"""
358 """Similar to the normal InteractiveShell, but with threading control"""
359
359
360 InteractiveShell.__init__(self,name,usage,rc,user_ns,
360 InteractiveShell.__init__(self,name,usage,rc,user_ns,
361 user_global_ns,banner2)
361 user_global_ns,banner2)
362
362
363 # Timeout we wait for GUI thread
363 # Timeout we wait for GUI thread
364 self.gui_timeout = gui_timeout
364 self.gui_timeout = gui_timeout
365
365
366 # A queue to hold the code to be executed.
366 # A queue to hold the code to be executed.
367 self.code_queue = Queue.Queue()
367 self.code_queue = Queue.Queue()
368
368
369 # Stuff to do at closing time
369 # Stuff to do at closing time
370 self._kill = None
370 self._kill = None
371 on_kill = kw.get('on_kill', [])
371 on_kill = kw.get('on_kill', [])
372 # Check that all things to kill are callable:
372 # Check that all things to kill are callable:
373 for t in on_kill:
373 for t in on_kill:
374 if not callable(t):
374 if not callable(t):
375 raise TypeError,'on_kill must be a list of callables'
375 raise TypeError,'on_kill must be a list of callables'
376 self.on_kill = on_kill
376 self.on_kill = on_kill
377 # thread identity of the "worker thread" (that may execute code directly)
377 # thread identity of the "worker thread" (that may execute code directly)
378 self.worker_ident = None
378 self.worker_ident = None
379
379
380 def runsource(self, source, filename="<input>", symbol="single"):
380 def runsource(self, source, filename="<input>", symbol="single"):
381 """Compile and run some source in the interpreter.
381 """Compile and run some source in the interpreter.
382
382
383 Modified version of code.py's runsource(), to handle threading issues.
383 Modified version of code.py's runsource(), to handle threading issues.
384 See the original for full docstring details."""
384 See the original for full docstring details."""
385
385
386 global KBINT
386 global KBINT
387
387
388 # If Ctrl-C was typed, we reset the flag and return right away
388 # If Ctrl-C was typed, we reset the flag and return right away
389 if KBINT:
389 if KBINT:
390 KBINT = False
390 KBINT = False
391 return False
391 return False
392
392
393 if self._kill:
393 if self._kill:
394 # can't queue new code if we are being killed
394 # can't queue new code if we are being killed
395 return True
395 return True
396
396
397 try:
397 try:
398 code = self.compile(source, filename, symbol)
398 code = self.compile(source, filename, symbol)
399 except (OverflowError, SyntaxError, ValueError):
399 except (OverflowError, SyntaxError, ValueError):
400 # Case 1
400 # Case 1
401 self.showsyntaxerror(filename)
401 self.showsyntaxerror(filename)
402 return False
402 return False
403
403
404 if code is None:
404 if code is None:
405 # Case 2
405 # Case 2
406 return True
406 return True
407
407
408 # shortcut - if we are in worker thread, or the worker thread is not
408 # shortcut - if we are in worker thread, or the worker thread is not
409 # running, execute directly (to allow recursion and prevent deadlock if
409 # running, execute directly (to allow recursion and prevent deadlock if
410 # code is run early in IPython construction)
410 # code is run early in IPython construction)
411
411
412 if (self.worker_ident is None
412 if (self.worker_ident is None
413 or self.worker_ident == thread.get_ident() ):
413 or self.worker_ident == thread.get_ident() ):
414 InteractiveShell.runcode(self,code)
414 InteractiveShell.runcode(self,code)
415 return False
415 return False
416
416
417 # Case 3
417 # Case 3
418 # Store code in queue, so the execution thread can handle it.
418 # Store code in queue, so the execution thread can handle it.
419
419
420 completed_ev, received_ev = threading.Event(), threading.Event()
420 completed_ev, received_ev = threading.Event(), threading.Event()
421
421
422 self.code_queue.put((code,completed_ev, received_ev))
422 self.code_queue.put((code,completed_ev, received_ev))
423 # first make sure the message was received, with timeout
423 # first make sure the message was received, with timeout
424 received_ev.wait(self.gui_timeout)
424 received_ev.wait(self.gui_timeout)
425 if not received_ev.isSet():
425 if not received_ev.isSet():
426 # the mainloop is dead, start executing code directly
426 # the mainloop is dead, start executing code directly
427 print "Warning: Timeout for mainloop thread exceeded"
427 print "Warning: Timeout for mainloop thread exceeded"
428 print "switching to nonthreaded mode (until mainloop wakes up again)"
428 print "switching to nonthreaded mode (until mainloop wakes up again)"
429 self.worker_ident = None
429 self.worker_ident = None
430 else:
430 else:
431 completed_ev.wait()
431 completed_ev.wait()
432 return False
432 return False
433
433
434 def runcode(self):
434 def runcode(self):
435 """Execute a code object.
435 """Execute a code object.
436
436
437 Multithreaded wrapper around IPython's runcode()."""
437 Multithreaded wrapper around IPython's runcode()."""
438
438
439 global CODE_RUN
439 global CODE_RUN
440
440
441 # we are in worker thread, stash out the id for runsource()
441 # we are in worker thread, stash out the id for runsource()
442 self.worker_ident = thread.get_ident()
442 self.worker_ident = thread.get_ident()
443
443
444 if self._kill:
444 if self._kill:
445 print >>Term.cout, 'Closing threads...',
445 print >>Term.cout, 'Closing threads...',
446 Term.cout.flush()
446 Term.cout.flush()
447 for tokill in self.on_kill:
447 for tokill in self.on_kill:
448 tokill()
448 tokill()
449 print >>Term.cout, 'Done.'
449 print >>Term.cout, 'Done.'
450 # allow kill() to return
450 # allow kill() to return
451 self._kill.set()
451 self._kill.set()
452 return True
452 return True
453
453
454 # Install sigint handler. We do it every time to ensure that if user
454 # Install sigint handler. We do it every time to ensure that if user
455 # code modifies it, we restore our own handling.
455 # code modifies it, we restore our own handling.
456 try:
456 try:
457 signal(SIGINT,sigint_handler)
457 signal(SIGINT,sigint_handler)
458 except SystemError:
458 except SystemError:
459 # This happens under Windows, which seems to have all sorts
459 # This happens under Windows, which seems to have all sorts
460 # of problems with signal handling. Oh well...
460 # of problems with signal handling. Oh well...
461 pass
461 pass
462
462
463 # Flush queue of pending code by calling the run methood of the parent
463 # Flush queue of pending code by calling the run methood of the parent
464 # class with all items which may be in the queue.
464 # class with all items which may be in the queue.
465 code_to_run = None
465 code_to_run = None
466 while 1:
466 while 1:
467 try:
467 try:
468 code_to_run, completed_ev, received_ev = self.code_queue.get_nowait()
468 code_to_run, completed_ev, received_ev = self.code_queue.get_nowait()
469 except Queue.Empty:
469 except Queue.Empty:
470 break
470 break
471 received_ev.set()
471 received_ev.set()
472
472
473 # Exceptions need to be raised differently depending on which
473 # Exceptions need to be raised differently depending on which
474 # thread is active. This convoluted try/except is only there to
474 # thread is active. This convoluted try/except is only there to
475 # protect against asynchronous exceptions, to ensure that a KBINT
475 # protect against asynchronous exceptions, to ensure that a KBINT
476 # at the wrong time doesn't deadlock everything. The global
476 # at the wrong time doesn't deadlock everything. The global
477 # CODE_TO_RUN is set to true/false as close as possible to the
477 # CODE_TO_RUN is set to true/false as close as possible to the
478 # runcode() call, so that the KBINT handler is correctly informed.
478 # runcode() call, so that the KBINT handler is correctly informed.
479 try:
479 try:
480 try:
480 try:
481 CODE_RUN = True
481 CODE_RUN = True
482 InteractiveShell.runcode(self,code_to_run)
482 InteractiveShell.runcode(self,code_to_run)
483 except KeyboardInterrupt:
483 except KeyboardInterrupt:
484 print "Keyboard interrupted in mainloop"
484 print "Keyboard interrupted in mainloop"
485 while not self.code_queue.empty():
485 while not self.code_queue.empty():
486 code, ev1,ev2 = self.code_queue.get_nowait()
486 code, ev1,ev2 = self.code_queue.get_nowait()
487 ev1.set()
487 ev1.set()
488 ev2.set()
488 ev2.set()
489 break
489 break
490 finally:
490 finally:
491 CODE_RUN = False
491 CODE_RUN = False
492 # allow runsource() return from wait
492 # allow runsource() return from wait
493 completed_ev.set()
493 completed_ev.set()
494
494
495
495
496 # This MUST return true for gtk threading to work
496 # This MUST return true for gtk threading to work
497 return True
497 return True
498
498
499 def kill(self):
499 def kill(self):
500 """Kill the thread, returning when it has been shut down."""
500 """Kill the thread, returning when it has been shut down."""
501 self._kill = threading.Event()
501 self._kill = threading.Event()
502 self._kill.wait()
502 self._kill.wait()
503
503
504 class MatplotlibShellBase:
504 class MatplotlibShellBase:
505 """Mixin class to provide the necessary modifications to regular IPython
505 """Mixin class to provide the necessary modifications to regular IPython
506 shell classes for matplotlib support.
506 shell classes for matplotlib support.
507
507
508 Given Python's MRO, this should be used as the FIRST class in the
508 Given Python's MRO, this should be used as the FIRST class in the
509 inheritance hierarchy, so that it overrides the relevant methods."""
509 inheritance hierarchy, so that it overrides the relevant methods."""
510
510
511 def _matplotlib_config(self,name,user_ns,user_global_ns=None):
511 def _matplotlib_config(self,name,user_ns,user_global_ns=None):
512 """Return items needed to setup the user's shell with matplotlib"""
512 """Return items needed to setup the user's shell with matplotlib"""
513
513
514 # Initialize matplotlib to interactive mode always
514 # Initialize matplotlib to interactive mode always
515 import matplotlib
515 import matplotlib
516 from matplotlib import backends
516 from matplotlib import backends
517 matplotlib.interactive(True)
517 matplotlib.interactive(True)
518
518
519 def use(arg):
519 def use(arg):
520 """IPython wrapper for matplotlib's backend switcher.
520 """IPython wrapper for matplotlib's backend switcher.
521
521
522 In interactive use, we can not allow switching to a different
522 In interactive use, we can not allow switching to a different
523 interactive backend, since thread conflicts will most likely crash
523 interactive backend, since thread conflicts will most likely crash
524 the python interpreter. This routine does a safety check first,
524 the python interpreter. This routine does a safety check first,
525 and refuses to perform a dangerous switch. It still allows
525 and refuses to perform a dangerous switch. It still allows
526 switching to non-interactive backends."""
526 switching to non-interactive backends."""
527
527
528 if arg in backends.interactive_bk and arg != self.mpl_backend:
528 if arg in backends.interactive_bk and arg != self.mpl_backend:
529 m=('invalid matplotlib backend switch.\n'
529 m=('invalid matplotlib backend switch.\n'
530 'This script attempted to switch to the interactive '
530 'This script attempted to switch to the interactive '
531 'backend: `%s`\n'
531 'backend: `%s`\n'
532 'Your current choice of interactive backend is: `%s`\n\n'
532 'Your current choice of interactive backend is: `%s`\n\n'
533 'Switching interactive matplotlib backends at runtime\n'
533 'Switching interactive matplotlib backends at runtime\n'
534 'would crash the python interpreter, '
534 'would crash the python interpreter, '
535 'and IPython has blocked it.\n\n'
535 'and IPython has blocked it.\n\n'
536 'You need to either change your choice of matplotlib backend\n'
536 'You need to either change your choice of matplotlib backend\n'
537 'by editing your .matplotlibrc file, or run this script as a \n'
537 'by editing your .matplotlibrc file, or run this script as a \n'
538 'standalone file from the command line, not using IPython.\n' %
538 'standalone file from the command line, not using IPython.\n' %
539 (arg,self.mpl_backend) )
539 (arg,self.mpl_backend) )
540 raise RuntimeError, m
540 raise RuntimeError, m
541 else:
541 else:
542 self.mpl_use(arg)
542 self.mpl_use(arg)
543 self.mpl_use._called = True
543 self.mpl_use._called = True
544
544
545 self.matplotlib = matplotlib
545 self.matplotlib = matplotlib
546 self.mpl_backend = matplotlib.rcParams['backend']
546 self.mpl_backend = matplotlib.rcParams['backend']
547
547
548 # we also need to block switching of interactive backends by use()
548 # we also need to block switching of interactive backends by use()
549 self.mpl_use = matplotlib.use
549 self.mpl_use = matplotlib.use
550 self.mpl_use._called = False
550 self.mpl_use._called = False
551 # overwrite the original matplotlib.use with our wrapper
551 # overwrite the original matplotlib.use with our wrapper
552 matplotlib.use = use
552 matplotlib.use = use
553
553
554 # This must be imported last in the matplotlib series, after
554 # This must be imported last in the matplotlib series, after
555 # backend/interactivity choices have been made
555 # backend/interactivity choices have been made
556 import matplotlib.pylab as pylab
556 import matplotlib.pylab as pylab
557 self.pylab = pylab
557 self.pylab = pylab
558
558
559 self.pylab.show._needmain = False
559 self.pylab.show._needmain = False
560 # We need to detect at runtime whether show() is called by the user.
560 # We need to detect at runtime whether show() is called by the user.
561 # For this, we wrap it into a decorator which adds a 'called' flag.
561 # For this, we wrap it into a decorator which adds a 'called' flag.
562 self.pylab.draw_if_interactive = flag_calls(self.pylab.draw_if_interactive)
562 self.pylab.draw_if_interactive = flag_calls(self.pylab.draw_if_interactive)
563
563
564 # Build a user namespace initialized with matplotlib/matlab features.
564 # Build a user namespace initialized with matplotlib/matlab features.
565 user_ns, user_global_ns = IPython.ipapi.make_user_namespaces(user_ns,
565 user_ns, user_global_ns = IPython.ipapi.make_user_namespaces(user_ns,
566 user_global_ns)
566 user_global_ns)
567
567
568 # Import numpy as np/pyplot as plt are conventions we're trying to
568 # Import numpy as np/pyplot as plt are conventions we're trying to
569 # somewhat standardize on. Making them available to users by default
569 # somewhat standardize on. Making them available to users by default
570 # will greatly help this.
570 # will greatly help this.
571 exec ("import numpy\n"
571 exec ("import numpy\n"
572 "import numpy as np\n"
572 "import numpy as np\n"
573 "import matplotlib\n"
573 "import matplotlib\n"
574 "import matplotlib.pylab as pylab\n"
574 "import matplotlib.pylab as pylab\n"
575 "try:\n"
575 "try:\n"
576 " import matplotlib.pyplot as plt\n"
576 " import matplotlib.pyplot as plt\n"
577 "except ImportError:\n"
577 "except ImportError:\n"
578 " pass\n"
578 " pass\n"
579 ) in user_ns
579 ) in user_ns
580
580
581 # Build matplotlib info banner
581 # Build matplotlib info banner
582 b="""
582 b="""
583 Welcome to pylab, a matplotlib-based Python environment.
583 Welcome to pylab, a matplotlib-based Python environment.
584 For more information, type 'help(pylab)'.
584 For more information, type 'help(pylab)'.
585 """
585 """
586 return user_ns,user_global_ns,b
586 return user_ns,user_global_ns,b
587
587
588 def mplot_exec(self,fname,*where,**kw):
588 def mplot_exec(self,fname,*where,**kw):
589 """Execute a matplotlib script.
589 """Execute a matplotlib script.
590
590
591 This is a call to execfile(), but wrapped in safeties to properly
591 This is a call to execfile(), but wrapped in safeties to properly
592 handle interactive rendering and backend switching."""
592 handle interactive rendering and backend switching."""
593
593
594 #print '*** Matplotlib runner ***' # dbg
594 #print '*** Matplotlib runner ***' # dbg
595 # turn off rendering until end of script
595 # turn off rendering until end of script
596 isInteractive = self.matplotlib.rcParams['interactive']
596 isInteractive = self.matplotlib.rcParams['interactive']
597 self.matplotlib.interactive(False)
597 self.matplotlib.interactive(False)
598 self.safe_execfile(fname,*where,**kw)
598 self.safe_execfile(fname,*where,**kw)
599 self.matplotlib.interactive(isInteractive)
599 self.matplotlib.interactive(isInteractive)
600 # make rendering call now, if the user tried to do it
600 # make rendering call now, if the user tried to do it
601 if self.pylab.draw_if_interactive.called:
601 if self.pylab.draw_if_interactive.called:
602 self.pylab.draw()
602 self.pylab.draw()
603 self.pylab.draw_if_interactive.called = False
603 self.pylab.draw_if_interactive.called = False
604
604
605 # if a backend switch was performed, reverse it now
605 # if a backend switch was performed, reverse it now
606 if self.mpl_use._called:
606 if self.mpl_use._called:
607 self.matplotlib.rcParams['backend'] = self.mpl_backend
607 self.matplotlib.rcParams['backend'] = self.mpl_backend
608
608
609 @testdec.skip_doctest
609 @testdec.skip_doctest
610 def magic_run(self,parameter_s=''):
610 def magic_run(self,parameter_s=''):
611 Magic.magic_run(self,parameter_s,runner=self.mplot_exec)
611 Magic.magic_run(self,parameter_s,runner=self.mplot_exec)
612
612
613 # Fix the docstring so users see the original as well
613 # Fix the docstring so users see the original as well
614 magic_run.__doc__ = "%s\n%s" % (Magic.magic_run.__doc__,
614 magic_run.__doc__ = "%s\n%s" % (Magic.magic_run.__doc__,
615 "\n *** Modified %run for Matplotlib,"
615 "\n *** Modified %run for Matplotlib,"
616 " with proper interactive handling ***")
616 " with proper interactive handling ***")
617
617
618 # Now we provide 2 versions of a matplotlib-aware IPython base shells, single
618 # Now we provide 2 versions of a matplotlib-aware IPython base shells, single
619 # and multithreaded. Note that these are meant for internal use, the IPShell*
619 # and multithreaded. Note that these are meant for internal use, the IPShell*
620 # classes below are the ones meant for public consumption.
620 # classes below are the ones meant for public consumption.
621
621
622 class MatplotlibShell(MatplotlibShellBase,InteractiveShell):
622 class MatplotlibShell(MatplotlibShellBase,InteractiveShell):
623 """Single-threaded shell with matplotlib support."""
623 """Single-threaded shell with matplotlib support."""
624
624
625 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
625 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
626 user_ns=None,user_global_ns=None,**kw):
626 user_ns=None,user_global_ns=None,**kw):
627 user_ns,user_global_ns,b2 = self._matplotlib_config(name,user_ns,user_global_ns)
627 user_ns,user_global_ns,b2 = self._matplotlib_config(name,user_ns,user_global_ns)
628 InteractiveShell.__init__(self,name,usage,rc,user_ns,user_global_ns,
628 InteractiveShell.__init__(self,name,usage,rc,user_ns,user_global_ns,
629 banner2=b2,**kw)
629 banner2=b2,**kw)
630
630
631 class MatplotlibMTShell(MatplotlibShellBase,MTInteractiveShell):
631 class MatplotlibMTShell(MatplotlibShellBase,MTInteractiveShell):
632 """Multi-threaded shell with matplotlib support."""
632 """Multi-threaded shell with matplotlib support."""
633
633
634 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
634 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
635 user_ns=None,user_global_ns=None, **kw):
635 user_ns=None,user_global_ns=None, **kw):
636 user_ns,user_global_ns,b2 = self._matplotlib_config(name,user_ns,user_global_ns)
636 user_ns,user_global_ns,b2 = self._matplotlib_config(name,user_ns,user_global_ns)
637 MTInteractiveShell.__init__(self,name,usage,rc,user_ns,user_global_ns,
637 MTInteractiveShell.__init__(self,name,usage,rc,user_ns,user_global_ns,
638 banner2=b2,**kw)
638 banner2=b2,**kw)
639
639
640 #-----------------------------------------------------------------------------
640 #-----------------------------------------------------------------------------
641 # Utility functions for the different GUI enabled IPShell* classes.
641 # Utility functions for the different GUI enabled IPShell* classes.
642
642
643 def get_tk():
643 def get_tk():
644 """Tries to import Tkinter and returns a withdrawn Tkinter root
644 """Tries to import Tkinter and returns a withdrawn Tkinter root
645 window. If Tkinter is already imported or not available, this
645 window. If Tkinter is already imported or not available, this
646 returns None. This function calls `hijack_tk` underneath.
646 returns None. This function calls `hijack_tk` underneath.
647 """
647 """
648 if not USE_TK or sys.modules.has_key('Tkinter'):
648 if not USE_TK or sys.modules.has_key('Tkinter'):
649 return None
649 return None
650 else:
650 else:
651 try:
651 try:
652 import Tkinter
652 import Tkinter
653 except ImportError:
653 except ImportError:
654 return None
654 return None
655 else:
655 else:
656 hijack_tk()
656 hijack_tk()
657 r = Tkinter.Tk()
657 r = Tkinter.Tk()
658 r.withdraw()
658 r.withdraw()
659 return r
659 return r
660
660
661 def hijack_tk():
661 def hijack_tk():
662 """Modifies Tkinter's mainloop with a dummy so when a module calls
662 """Modifies Tkinter's mainloop with a dummy so when a module calls
663 mainloop, it does not block.
663 mainloop, it does not block.
664
664
665 """
665 """
666 def misc_mainloop(self, n=0):
666 def misc_mainloop(self, n=0):
667 pass
667 pass
668 def tkinter_mainloop(n=0):
668 def tkinter_mainloop(n=0):
669 pass
669 pass
670
670
671 import Tkinter
671 import Tkinter
672 Tkinter.Misc.mainloop = misc_mainloop
672 Tkinter.Misc.mainloop = misc_mainloop
673 Tkinter.mainloop = tkinter_mainloop
673 Tkinter.mainloop = tkinter_mainloop
674
674
675 def update_tk(tk):
675 def update_tk(tk):
676 """Updates the Tkinter event loop. This is typically called from
676 """Updates the Tkinter event loop. This is typically called from
677 the respective WX or GTK mainloops.
677 the respective WX or GTK mainloops.
678 """
678 """
679 if tk:
679 if tk:
680 tk.update()
680 tk.update()
681
681
682 def hijack_wx():
682 def hijack_wx():
683 """Modifies wxPython's MainLoop with a dummy so user code does not
683 """Modifies wxPython's MainLoop with a dummy so user code does not
684 block IPython. The hijacked mainloop function is returned.
684 block IPython. The hijacked mainloop function is returned.
685 """
685 """
686 def dummy_mainloop(*args, **kw):
686 def dummy_mainloop(*args, **kw):
687 pass
687 pass
688
688
689 try:
689 try:
690 import wx
690 import wx
691 except ImportError:
691 except ImportError:
692 # For very old versions of WX
692 # For very old versions of WX
693 import wxPython as wx
693 import wxPython as wx
694
694
695 ver = wx.__version__
695 ver = wx.__version__
696 orig_mainloop = None
696 orig_mainloop = None
697 if ver[:3] >= '2.5':
697 if ver[:3] >= '2.5':
698 import wx
698 import wx
699 if hasattr(wx, '_core_'): core = getattr(wx, '_core_')
699 if hasattr(wx, '_core_'): core = getattr(wx, '_core_')
700 elif hasattr(wx, '_core'): core = getattr(wx, '_core')
700 elif hasattr(wx, '_core'): core = getattr(wx, '_core')
701 else: raise AttributeError('Could not find wx core module')
701 else: raise AttributeError('Could not find wx core module')
702 orig_mainloop = core.PyApp_MainLoop
702 orig_mainloop = core.PyApp_MainLoop
703 core.PyApp_MainLoop = dummy_mainloop
703 core.PyApp_MainLoop = dummy_mainloop
704 elif ver[:3] == '2.4':
704 elif ver[:3] == '2.4':
705 orig_mainloop = wx.wxc.wxPyApp_MainLoop
705 orig_mainloop = wx.wxc.wxPyApp_MainLoop
706 wx.wxc.wxPyApp_MainLoop = dummy_mainloop
706 wx.wxc.wxPyApp_MainLoop = dummy_mainloop
707 else:
707 else:
708 warn("Unable to find either wxPython version 2.4 or >= 2.5.")
708 warn("Unable to find either wxPython version 2.4 or >= 2.5.")
709 return orig_mainloop
709 return orig_mainloop
710
710
711 def hijack_gtk():
711 def hijack_gtk():
712 """Modifies pyGTK's mainloop with a dummy so user code does not
712 """Modifies pyGTK's mainloop with a dummy so user code does not
713 block IPython. This function returns the original `gtk.mainloop`
713 block IPython. This function returns the original `gtk.mainloop`
714 function that has been hijacked.
714 function that has been hijacked.
715 """
715 """
716 def dummy_mainloop(*args, **kw):
716 def dummy_mainloop(*args, **kw):
717 pass
717 pass
718 import gtk
718 import gtk
719 if gtk.pygtk_version >= (2,4,0): orig_mainloop = gtk.main
719 if gtk.pygtk_version >= (2,4,0): orig_mainloop = gtk.main
720 else: orig_mainloop = gtk.mainloop
720 else: orig_mainloop = gtk.mainloop
721 gtk.mainloop = dummy_mainloop
721 gtk.mainloop = dummy_mainloop
722 gtk.main = dummy_mainloop
722 gtk.main = dummy_mainloop
723 return orig_mainloop
723 return orig_mainloop
724
724
725 def hijack_qt():
725 def hijack_qt():
726 """Modifies PyQt's mainloop with a dummy so user code does not
726 """Modifies PyQt's mainloop with a dummy so user code does not
727 block IPython. This function returns the original
727 block IPython. This function returns the original
728 `qt.qApp.exec_loop` function that has been hijacked.
728 `qt.qApp.exec_loop` function that has been hijacked.
729 """
729 """
730 def dummy_mainloop(*args, **kw):
730 def dummy_mainloop(*args, **kw):
731 pass
731 pass
732 import qt
732 import qt
733 orig_mainloop = qt.qApp.exec_loop
733 orig_mainloop = qt.qApp.exec_loop
734 qt.qApp.exec_loop = dummy_mainloop
734 qt.qApp.exec_loop = dummy_mainloop
735 qt.QApplication.exec_loop = dummy_mainloop
735 qt.QApplication.exec_loop = dummy_mainloop
736 return orig_mainloop
736 return orig_mainloop
737
737
738 def hijack_qt4():
738 def hijack_qt4():
739 """Modifies PyQt4's mainloop with a dummy so user code does not
739 """Modifies PyQt4's mainloop with a dummy so user code does not
740 block IPython. This function returns the original
740 block IPython. This function returns the original
741 `QtGui.qApp.exec_` function that has been hijacked.
741 `QtGui.qApp.exec_` function that has been hijacked.
742 """
742 """
743 def dummy_mainloop(*args, **kw):
743 def dummy_mainloop(*args, **kw):
744 pass
744 pass
745 from PyQt4 import QtGui, QtCore
745 from PyQt4 import QtGui, QtCore
746 orig_mainloop = QtGui.qApp.exec_
746 orig_mainloop = QtGui.qApp.exec_
747 QtGui.qApp.exec_ = dummy_mainloop
747 QtGui.qApp.exec_ = dummy_mainloop
748 QtGui.QApplication.exec_ = dummy_mainloop
748 QtGui.QApplication.exec_ = dummy_mainloop
749 QtCore.QCoreApplication.exec_ = dummy_mainloop
749 QtCore.QCoreApplication.exec_ = dummy_mainloop
750 return orig_mainloop
750 return orig_mainloop
751
751
752 #-----------------------------------------------------------------------------
752 #-----------------------------------------------------------------------------
753 # The IPShell* classes below are the ones meant to be run by external code as
753 # The IPShell* classes below are the ones meant to be run by external code as
754 # IPython instances. Note that unless a specific threading strategy is
754 # IPython instances. Note that unless a specific threading strategy is
755 # desired, the factory function start() below should be used instead (it
755 # desired, the factory function start() below should be used instead (it
756 # selects the proper threaded class).
756 # selects the proper threaded class).
757
757
758 class IPThread(threading.Thread):
758 class IPThread(threading.Thread):
759 def run(self):
759 def run(self):
760 self.IP.mainloop(self._banner)
760 self.IP.mainloop(self._banner)
761 self.IP.kill()
761 self.IP.kill()
762
762
763 class IPShellGTK(IPThread):
763 class IPShellGTK(IPThread):
764 """Run a gtk mainloop() in a separate thread.
764 """Run a gtk mainloop() in a separate thread.
765
765
766 Python commands can be passed to the thread where they will be executed.
766 Python commands can be passed to the thread where they will be executed.
767 This is implemented by periodically checking for passed code using a
767 This is implemented by periodically checking for passed code using a
768 GTK timeout callback."""
768 GTK timeout callback."""
769
769
770 TIMEOUT = 100 # Millisecond interval between timeouts.
770 TIMEOUT = 100 # Millisecond interval between timeouts.
771
771
772 def __init__(self,argv=None,user_ns=None,user_global_ns=None,
772 def __init__(self,argv=None,user_ns=None,user_global_ns=None,
773 debug=1,shell_class=MTInteractiveShell):
773 debug=1,shell_class=MTInteractiveShell):
774
774
775 import gtk
775 import gtk
776 # Check for set_interactive, coming up in new pygtk.
776 # Check for set_interactive, coming up in new pygtk.
777 # Disable it so that this code works, but notify
777 # Disable it so that this code works, but notify
778 # the user that he has a better option as well.
778 # the user that he has a better option as well.
779 # XXX TODO better support when set_interactive is released
779 # XXX TODO better support when set_interactive is released
780 try:
780 try:
781 gtk.set_interactive(False)
781 gtk.set_interactive(False)
782 print "Your PyGtk has set_interactive(), so you can use the"
782 print "Your PyGtk has set_interactive(), so you can use the"
783 print "more stable single-threaded Gtk mode."
783 print "more stable single-threaded Gtk mode."
784 print "See https://bugs.launchpad.net/ipython/+bug/270856"
784 print "See https://bugs.launchpad.net/ipython/+bug/270856"
785 except AttributeError:
785 except AttributeError:
786 pass
786 pass
787
787
788 self.gtk = gtk
788 self.gtk = gtk
789 self.gtk_mainloop = hijack_gtk()
789 self.gtk_mainloop = hijack_gtk()
790
790
791 # Allows us to use both Tk and GTK.
791 # Allows us to use both Tk and GTK.
792 self.tk = get_tk()
792 self.tk = get_tk()
793
793
794 if gtk.pygtk_version >= (2,4,0): mainquit = self.gtk.main_quit
794 if gtk.pygtk_version >= (2,4,0): mainquit = self.gtk.main_quit
795 else: mainquit = self.gtk.mainquit
795 else: mainquit = self.gtk.mainquit
796
796
797 self.IP = make_IPython(argv,user_ns=user_ns,
797 self.IP = make_IPython(argv,user_ns=user_ns,
798 user_global_ns=user_global_ns,
798 user_global_ns=user_global_ns,
799 debug=debug,
799 debug=debug,
800 shell_class=shell_class,
800 shell_class=shell_class,
801 on_kill=[mainquit])
801 on_kill=[mainquit])
802
802
803 # HACK: slot for banner in self; it will be passed to the mainloop
803 # HACK: slot for banner in self; it will be passed to the mainloop
804 # method only and .run() needs it. The actual value will be set by
804 # method only and .run() needs it. The actual value will be set by
805 # .mainloop().
805 # .mainloop().
806 self._banner = None
806 self._banner = None
807
807
808 threading.Thread.__init__(self)
808 threading.Thread.__init__(self)
809
809
810 def mainloop(self,sys_exit=0,banner=None):
810 def mainloop(self,sys_exit=0,banner=None):
811
811
812 self._banner = banner
812 self._banner = banner
813
813
814 if self.gtk.pygtk_version >= (2,4,0):
814 if self.gtk.pygtk_version >= (2,4,0):
815 import gobject
815 import gobject
816 gobject.idle_add(self.on_timer)
816 gobject.idle_add(self.on_timer)
817 else:
817 else:
818 self.gtk.idle_add(self.on_timer)
818 self.gtk.idle_add(self.on_timer)
819
819
820 if sys.platform != 'win32':
820 if sys.platform != 'win32':
821 try:
821 try:
822 if self.gtk.gtk_version[0] >= 2:
822 if self.gtk.gtk_version[0] >= 2:
823 self.gtk.gdk.threads_init()
823 self.gtk.gdk.threads_init()
824 except AttributeError:
824 except AttributeError:
825 pass
825 pass
826 except RuntimeError:
826 except RuntimeError:
827 error('Your pyGTK likely has not been compiled with '
827 error('Your pyGTK likely has not been compiled with '
828 'threading support.\n'
828 'threading support.\n'
829 'The exception printout is below.\n'
829 'The exception printout is below.\n'
830 'You can either rebuild pyGTK with threads, or '
830 'You can either rebuild pyGTK with threads, or '
831 'try using \n'
831 'try using \n'
832 'matplotlib with a different backend (like Tk or WX).\n'
832 'matplotlib with a different backend (like Tk or WX).\n'
833 'Note that matplotlib will most likely not work in its '
833 'Note that matplotlib will most likely not work in its '
834 'current state!')
834 'current state!')
835 self.IP.InteractiveTB()
835 self.IP.InteractiveTB()
836
836
837 self.start()
837 self.start()
838 self.gtk.gdk.threads_enter()
838 self.gtk.gdk.threads_enter()
839 self.gtk_mainloop()
839 self.gtk_mainloop()
840 self.gtk.gdk.threads_leave()
840 self.gtk.gdk.threads_leave()
841 self.join()
841 self.join()
842
842
843 def on_timer(self):
843 def on_timer(self):
844 """Called when GTK is idle.
844 """Called when GTK is idle.
845
845
846 Must return True always, otherwise GTK stops calling it"""
846 Must return True always, otherwise GTK stops calling it"""
847
847
848 update_tk(self.tk)
848 update_tk(self.tk)
849 self.IP.runcode()
849 self.IP.runcode()
850 time.sleep(0.01)
850 time.sleep(0.01)
851 return True
851 return True
852
852
853
853
854 class IPShellWX(IPThread):
854 class IPShellWX(IPThread):
855 """Run a wx mainloop() in a separate thread.
855 """Run a wx mainloop() in a separate thread.
856
856
857 Python commands can be passed to the thread where they will be executed.
857 Python commands can be passed to the thread where they will be executed.
858 This is implemented by periodically checking for passed code using a
858 This is implemented by periodically checking for passed code using a
859 GTK timeout callback."""
859 GTK timeout callback."""
860
860
861 TIMEOUT = 100 # Millisecond interval between timeouts.
861 TIMEOUT = 100 # Millisecond interval between timeouts.
862
862
863 def __init__(self,argv=None,user_ns=None,user_global_ns=None,
863 def __init__(self,argv=None,user_ns=None,user_global_ns=None,
864 debug=1,shell_class=MTInteractiveShell):
864 debug=1,shell_class=MTInteractiveShell):
865
865
866 self.IP = make_IPython(argv,user_ns=user_ns,
866 self.IP = make_IPython(argv,user_ns=user_ns,
867 user_global_ns=user_global_ns,
867 user_global_ns=user_global_ns,
868 debug=debug,
868 debug=debug,
869 shell_class=shell_class,
869 shell_class=shell_class,
870 on_kill=[self.wxexit])
870 on_kill=[self.wxexit])
871
871
872 wantedwxversion=self.IP.rc.wxversion
872 wantedwxversion=self.IP.rc.wxversion
873 if wantedwxversion!="0":
873 if wantedwxversion!="0":
874 try:
874 try:
875 import wxversion
875 import wxversion
876 except ImportError:
876 except ImportError:
877 error('The wxversion module is needed for WX version selection')
877 error('The wxversion module is needed for WX version selection')
878 else:
878 else:
879 try:
879 try:
880 wxversion.select(wantedwxversion)
880 wxversion.select(wantedwxversion)
881 except:
881 except:
882 self.IP.InteractiveTB()
882 self.IP.InteractiveTB()
883 error('Requested wxPython version %s could not be loaded' %
883 error('Requested wxPython version %s could not be loaded' %
884 wantedwxversion)
884 wantedwxversion)
885
885
886 import wx
886 import wx
887
887
888 threading.Thread.__init__(self)
888 threading.Thread.__init__(self)
889 self.wx = wx
889 self.wx = wx
890 self.wx_mainloop = hijack_wx()
890 self.wx_mainloop = hijack_wx()
891
891
892 # Allows us to use both Tk and GTK.
892 # Allows us to use both Tk and GTK.
893 self.tk = get_tk()
893 self.tk = get_tk()
894
894
895 # HACK: slot for banner in self; it will be passed to the mainloop
895 # HACK: slot for banner in self; it will be passed to the mainloop
896 # method only and .run() needs it. The actual value will be set by
896 # method only and .run() needs it. The actual value will be set by
897 # .mainloop().
897 # .mainloop().
898 self._banner = None
898 self._banner = None
899
899
900 self.app = None
900 self.app = None
901
901
902 def wxexit(self, *args):
902 def wxexit(self, *args):
903 if self.app is not None:
903 if self.app is not None:
904 self.app.agent.timer.Stop()
904 self.app.agent.timer.Stop()
905 self.app.ExitMainLoop()
905 self.app.ExitMainLoop()
906
906
907 def mainloop(self,sys_exit=0,banner=None):
907 def mainloop(self,sys_exit=0,banner=None):
908
908
909 self._banner = banner
909 self._banner = banner
910
910
911 self.start()
911 self.start()
912
912
913 class TimerAgent(self.wx.MiniFrame):
913 class TimerAgent(self.wx.MiniFrame):
914 wx = self.wx
914 wx = self.wx
915 IP = self.IP
915 IP = self.IP
916 tk = self.tk
916 tk = self.tk
917 def __init__(self, parent, interval):
917 def __init__(self, parent, interval):
918 style = self.wx.DEFAULT_FRAME_STYLE | self.wx.TINY_CAPTION_HORIZ
918 style = self.wx.DEFAULT_FRAME_STYLE | self.wx.TINY_CAPTION_HORIZ
919 self.wx.MiniFrame.__init__(self, parent, -1, ' ', pos=(200, 200),
919 self.wx.MiniFrame.__init__(self, parent, -1, ' ', pos=(200, 200),
920 size=(100, 100),style=style)
920 size=(100, 100),style=style)
921 self.Show(False)
921 self.Show(False)
922 self.interval = interval
922 self.interval = interval
923 self.timerId = self.wx.NewId()
923 self.timerId = self.wx.NewId()
924
924
925 def StartWork(self):
925 def StartWork(self):
926 self.timer = self.wx.Timer(self, self.timerId)
926 self.timer = self.wx.Timer(self, self.timerId)
927 self.wx.EVT_TIMER(self, self.timerId, self.OnTimer)
927 self.wx.EVT_TIMER(self, self.timerId, self.OnTimer)
928 self.timer.Start(self.interval)
928 self.timer.Start(self.interval)
929
929
930 def OnTimer(self, event):
930 def OnTimer(self, event):
931 update_tk(self.tk)
931 update_tk(self.tk)
932 self.IP.runcode()
932 self.IP.runcode()
933
933
934 class App(self.wx.App):
934 class App(self.wx.App):
935 wx = self.wx
935 wx = self.wx
936 TIMEOUT = self.TIMEOUT
936 TIMEOUT = self.TIMEOUT
937 def OnInit(self):
937 def OnInit(self):
938 'Create the main window and insert the custom frame'
938 'Create the main window and insert the custom frame'
939 self.agent = TimerAgent(None, self.TIMEOUT)
939 self.agent = TimerAgent(None, self.TIMEOUT)
940 self.agent.Show(False)
940 self.agent.Show(False)
941 self.agent.StartWork()
941 self.agent.StartWork()
942 return True
942 return True
943
943
944 self.app = App(redirect=False)
944 self.app = App(redirect=False)
945 self.wx_mainloop(self.app)
945 self.wx_mainloop(self.app)
946 self.join()
946 self.join()
947
947
948
948
949 class IPShellQt(IPThread):
949 class IPShellQt(IPThread):
950 """Run a Qt event loop in a separate thread.
950 """Run a Qt event loop in a separate thread.
951
951
952 Python commands can be passed to the thread where they will be executed.
952 Python commands can be passed to the thread where they will be executed.
953 This is implemented by periodically checking for passed code using a
953 This is implemented by periodically checking for passed code using a
954 Qt timer / slot."""
954 Qt timer / slot."""
955
955
956 TIMEOUT = 100 # Millisecond interval between timeouts.
956 TIMEOUT = 100 # Millisecond interval between timeouts.
957
957
958 def __init__(self, argv=None, user_ns=None, user_global_ns=None,
958 def __init__(self, argv=None, user_ns=None, user_global_ns=None,
959 debug=0, shell_class=MTInteractiveShell):
959 debug=0, shell_class=MTInteractiveShell):
960
960
961 import qt
961 import qt
962
962
963 self.exec_loop = hijack_qt()
963 self.exec_loop = hijack_qt()
964
964
965 # Allows us to use both Tk and QT.
965 # Allows us to use both Tk and QT.
966 self.tk = get_tk()
966 self.tk = get_tk()
967
967
968 self.IP = make_IPython(argv,
968 self.IP = make_IPython(argv,
969 user_ns=user_ns,
969 user_ns=user_ns,
970 user_global_ns=user_global_ns,
970 user_global_ns=user_global_ns,
971 debug=debug,
971 debug=debug,
972 shell_class=shell_class,
972 shell_class=shell_class,
973 on_kill=[qt.qApp.exit])
973 on_kill=[qt.qApp.exit])
974
974
975 # HACK: slot for banner in self; it will be passed to the mainloop
975 # HACK: slot for banner in self; it will be passed to the mainloop
976 # method only and .run() needs it. The actual value will be set by
976 # method only and .run() needs it. The actual value will be set by
977 # .mainloop().
977 # .mainloop().
978 self._banner = None
978 self._banner = None
979
979
980 threading.Thread.__init__(self)
980 threading.Thread.__init__(self)
981
981
982 def mainloop(self, sys_exit=0, banner=None):
982 def mainloop(self, sys_exit=0, banner=None):
983
983
984 import qt
984 import qt
985
985
986 self._banner = banner
986 self._banner = banner
987
987
988 if qt.QApplication.startingUp():
988 if qt.QApplication.startingUp():
989 a = qt.QApplication(sys.argv)
989 a = qt.QApplication(sys.argv)
990
990
991 self.timer = qt.QTimer()
991 self.timer = qt.QTimer()
992 qt.QObject.connect(self.timer,
992 qt.QObject.connect(self.timer,
993 qt.SIGNAL('timeout()'),
993 qt.SIGNAL('timeout()'),
994 self.on_timer)
994 self.on_timer)
995
995
996 self.start()
996 self.start()
997 self.timer.start(self.TIMEOUT, True)
997 self.timer.start(self.TIMEOUT, True)
998 while True:
998 while True:
999 if self.IP._kill: break
999 if self.IP._kill: break
1000 self.exec_loop()
1000 self.exec_loop()
1001 self.join()
1001 self.join()
1002
1002
1003 def on_timer(self):
1003 def on_timer(self):
1004 update_tk(self.tk)
1004 update_tk(self.tk)
1005 result = self.IP.runcode()
1005 result = self.IP.runcode()
1006 self.timer.start(self.TIMEOUT, True)
1006 self.timer.start(self.TIMEOUT, True)
1007 return result
1007 return result
1008
1008
1009
1009
1010 class IPShellQt4(IPThread):
1010 class IPShellQt4(IPThread):
1011 """Run a Qt event loop in a separate thread.
1011 """Run a Qt event loop in a separate thread.
1012
1012
1013 Python commands can be passed to the thread where they will be executed.
1013 Python commands can be passed to the thread where they will be executed.
1014 This is implemented by periodically checking for passed code using a
1014 This is implemented by periodically checking for passed code using a
1015 Qt timer / slot."""
1015 Qt timer / slot."""
1016
1016
1017 TIMEOUT = 100 # Millisecond interval between timeouts.
1017 TIMEOUT = 100 # Millisecond interval between timeouts.
1018
1018
1019 def __init__(self, argv=None, user_ns=None, user_global_ns=None,
1019 def __init__(self, argv=None, user_ns=None, user_global_ns=None,
1020 debug=0, shell_class=MTInteractiveShell):
1020 debug=0, shell_class=MTInteractiveShell):
1021
1021
1022 from PyQt4 import QtCore, QtGui
1022 from PyQt4 import QtCore, QtGui
1023
1023
1024 try:
1024 try:
1025 # present in PyQt4-4.2.1 or later
1025 # present in PyQt4-4.2.1 or later
1026 QtCore.pyqtRemoveInputHook()
1026 QtCore.pyqtRemoveInputHook()
1027 except AttributeError:
1027 except AttributeError:
1028 pass
1028 pass
1029
1029
1030 if QtCore.PYQT_VERSION_STR == '4.3':
1030 if QtCore.PYQT_VERSION_STR == '4.3':
1031 warn('''PyQt4 version 4.3 detected.
1031 warn('''PyQt4 version 4.3 detected.
1032 If you experience repeated threading warnings, please update PyQt4.
1032 If you experience repeated threading warnings, please update PyQt4.
1033 ''')
1033 ''')
1034
1034
1035 self.exec_ = hijack_qt4()
1035 self.exec_ = hijack_qt4()
1036
1036
1037 # Allows us to use both Tk and QT.
1037 # Allows us to use both Tk and QT.
1038 self.tk = get_tk()
1038 self.tk = get_tk()
1039
1039
1040 self.IP = make_IPython(argv,
1040 self.IP = make_IPython(argv,
1041 user_ns=user_ns,
1041 user_ns=user_ns,
1042 user_global_ns=user_global_ns,
1042 user_global_ns=user_global_ns,
1043 debug=debug,
1043 debug=debug,
1044 shell_class=shell_class,
1044 shell_class=shell_class,
1045 on_kill=[QtGui.qApp.exit])
1045 on_kill=[QtGui.qApp.exit])
1046
1046
1047 # HACK: slot for banner in self; it will be passed to the mainloop
1047 # HACK: slot for banner in self; it will be passed to the mainloop
1048 # method only and .run() needs it. The actual value will be set by
1048 # method only and .run() needs it. The actual value will be set by
1049 # .mainloop().
1049 # .mainloop().
1050 self._banner = None
1050 self._banner = None
1051
1051
1052 threading.Thread.__init__(self)
1052 threading.Thread.__init__(self)
1053
1053
1054 def mainloop(self, sys_exit=0, banner=None):
1054 def mainloop(self, sys_exit=0, banner=None):
1055
1055
1056 from PyQt4 import QtCore, QtGui
1056 from PyQt4 import QtCore, QtGui
1057
1057
1058 self._banner = banner
1058 self._banner = banner
1059
1059
1060 if QtGui.QApplication.startingUp():
1060 if QtGui.QApplication.startingUp():
1061 a = QtGui.QApplication(sys.argv)
1061 a = QtGui.QApplication(sys.argv)
1062
1062
1063 self.timer = QtCore.QTimer()
1063 self.timer = QtCore.QTimer()
1064 QtCore.QObject.connect(self.timer,
1064 QtCore.QObject.connect(self.timer,
1065 QtCore.SIGNAL('timeout()'),
1065 QtCore.SIGNAL('timeout()'),
1066 self.on_timer)
1066 self.on_timer)
1067
1067
1068 self.start()
1068 self.start()
1069 self.timer.start(self.TIMEOUT)
1069 self.timer.start(self.TIMEOUT)
1070 while True:
1070 while True:
1071 if self.IP._kill: break
1071 if self.IP._kill: break
1072 self.exec_()
1072 self.exec_()
1073 self.join()
1073 self.join()
1074
1074
1075 def on_timer(self):
1075 def on_timer(self):
1076 update_tk(self.tk)
1076 update_tk(self.tk)
1077 result = self.IP.runcode()
1077 result = self.IP.runcode()
1078 self.timer.start(self.TIMEOUT)
1078 self.timer.start(self.TIMEOUT)
1079 return result
1079 return result
1080
1080
1081
1081
1082 # A set of matplotlib public IPython shell classes, for single-threaded (Tk*
1082 # A set of matplotlib public IPython shell classes, for single-threaded (Tk*
1083 # and FLTK*) and multithreaded (GTK*, WX* and Qt*) backends to use.
1083 # and FLTK*) and multithreaded (GTK*, WX* and Qt*) backends to use.
1084 def _load_pylab(user_ns):
1084 def _load_pylab(user_ns):
1085 """Allow users to disable pulling all of pylab into the top-level
1085 """Allow users to disable pulling all of pylab into the top-level
1086 namespace.
1086 namespace.
1087
1087
1088 This little utility must be called AFTER the actual ipython instance is
1088 This little utility must be called AFTER the actual ipython instance is
1089 running, since only then will the options file have been fully parsed."""
1089 running, since only then will the options file have been fully parsed."""
1090
1090
1091 ip = IPython.ipapi.get()
1091 ip = IPython.ipapi.get()
1092 if ip.options.pylab_import_all:
1092 if ip.options.pylab_import_all:
1093 ip.ex("from matplotlib.pylab import *")
1093 ip.ex("from matplotlib.pylab import *")
1094 ip.IP.user_config_ns.update(ip.user_ns)
1094 ip.IP.user_config_ns.update(ip.user_ns)
1095
1095
1096
1096
1097 class IPShellMatplotlib(IPShell):
1097 class IPShellMatplotlib(IPShell):
1098 """Subclass IPShell with MatplotlibShell as the internal shell.
1098 """Subclass IPShell with MatplotlibShell as the internal shell.
1099
1099
1100 Single-threaded class, meant for the Tk* and FLTK* backends.
1100 Single-threaded class, meant for the Tk* and FLTK* backends.
1101
1101
1102 Having this on a separate class simplifies the external driver code."""
1102 Having this on a separate class simplifies the external driver code."""
1103
1103
1104 def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
1104 def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
1105 IPShell.__init__(self,argv,user_ns,user_global_ns,debug,
1105 IPShell.__init__(self,argv,user_ns,user_global_ns,debug,
1106 shell_class=MatplotlibShell)
1106 shell_class=MatplotlibShell)
1107 _load_pylab(self.IP.user_ns)
1107 _load_pylab(self.IP.user_ns)
1108
1108
1109 class IPShellMatplotlibGTK(IPShellGTK):
1109 class IPShellMatplotlibGTK(IPShellGTK):
1110 """Subclass IPShellGTK with MatplotlibMTShell as the internal shell.
1110 """Subclass IPShellGTK with MatplotlibMTShell as the internal shell.
1111
1111
1112 Multi-threaded class, meant for the GTK* backends."""
1112 Multi-threaded class, meant for the GTK* backends."""
1113
1113
1114 def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
1114 def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
1115 IPShellGTK.__init__(self,argv,user_ns,user_global_ns,debug,
1115 IPShellGTK.__init__(self,argv,user_ns,user_global_ns,debug,
1116 shell_class=MatplotlibMTShell)
1116 shell_class=MatplotlibMTShell)
1117 _load_pylab(self.IP.user_ns)
1117 _load_pylab(self.IP.user_ns)
1118
1118
1119 class IPShellMatplotlibWX(IPShellWX):
1119 class IPShellMatplotlibWX(IPShellWX):
1120 """Subclass IPShellWX with MatplotlibMTShell as the internal shell.
1120 """Subclass IPShellWX with MatplotlibMTShell as the internal shell.
1121
1121
1122 Multi-threaded class, meant for the WX* backends."""
1122 Multi-threaded class, meant for the WX* backends."""
1123
1123
1124 def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
1124 def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
1125 IPShellWX.__init__(self,argv,user_ns,user_global_ns,debug,
1125 IPShellWX.__init__(self,argv,user_ns,user_global_ns,debug,
1126 shell_class=MatplotlibMTShell)
1126 shell_class=MatplotlibMTShell)
1127 _load_pylab(self.IP.user_ns)
1127 _load_pylab(self.IP.user_ns)
1128
1128
1129 class IPShellMatplotlibQt(IPShellQt):
1129 class IPShellMatplotlibQt(IPShellQt):
1130 """Subclass IPShellQt with MatplotlibMTShell as the internal shell.
1130 """Subclass IPShellQt with MatplotlibMTShell as the internal shell.
1131
1131
1132 Multi-threaded class, meant for the Qt* backends."""
1132 Multi-threaded class, meant for the Qt* backends."""
1133
1133
1134 def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
1134 def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
1135 IPShellQt.__init__(self,argv,user_ns,user_global_ns,debug,
1135 IPShellQt.__init__(self,argv,user_ns,user_global_ns,debug,
1136 shell_class=MatplotlibMTShell)
1136 shell_class=MatplotlibMTShell)
1137 _load_pylab(self.IP.user_ns)
1137 _load_pylab(self.IP.user_ns)
1138
1138
1139 class IPShellMatplotlibQt4(IPShellQt4):
1139 class IPShellMatplotlibQt4(IPShellQt4):
1140 """Subclass IPShellQt4 with MatplotlibMTShell as the internal shell.
1140 """Subclass IPShellQt4 with MatplotlibMTShell as the internal shell.
1141
1141
1142 Multi-threaded class, meant for the Qt4* backends."""
1142 Multi-threaded class, meant for the Qt4* backends."""
1143
1143
1144 def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
1144 def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
1145 IPShellQt4.__init__(self,argv,user_ns,user_global_ns,debug,
1145 IPShellQt4.__init__(self,argv,user_ns,user_global_ns,debug,
1146 shell_class=MatplotlibMTShell)
1146 shell_class=MatplotlibMTShell)
1147 _load_pylab(self.IP.user_ns)
1147 _load_pylab(self.IP.user_ns)
1148
1148
1149 #-----------------------------------------------------------------------------
1149 #-----------------------------------------------------------------------------
1150 # Factory functions to actually start the proper thread-aware shell
1150 # Factory functions to actually start the proper thread-aware shell
1151
1151
1152 def _select_shell(argv):
1152 def _select_shell(argv):
1153 """Select a shell from the given argv vector.
1153 """Select a shell from the given argv vector.
1154
1154
1155 This function implements the threading selection policy, allowing runtime
1155 This function implements the threading selection policy, allowing runtime
1156 control of the threading mode, both for general users and for matplotlib.
1156 control of the threading mode, both for general users and for matplotlib.
1157
1157
1158 Return:
1158 Return:
1159 Shell class to be instantiated for runtime operation.
1159 Shell class to be instantiated for runtime operation.
1160 """
1160 """
1161
1161
1162 global USE_TK
1162 global USE_TK
1163
1163
1164 mpl_shell = {'gthread' : IPShellMatplotlibGTK,
1164 mpl_shell = {'gthread' : IPShellMatplotlibGTK,
1165 'wthread' : IPShellMatplotlibWX,
1165 'wthread' : IPShellMatplotlibWX,
1166 'qthread' : IPShellMatplotlibQt,
1166 'qthread' : IPShellMatplotlibQt,
1167 'q4thread' : IPShellMatplotlibQt4,
1167 'q4thread' : IPShellMatplotlibQt4,
1168 'tkthread' : IPShellMatplotlib, # Tk is built-in
1168 'tkthread' : IPShellMatplotlib, # Tk is built-in
1169 }
1169 }
1170
1170
1171 th_shell = {'gthread' : IPShellGTK,
1171 th_shell = {'gthread' : IPShellGTK,
1172 'wthread' : IPShellWX,
1172 'wthread' : IPShellWX,
1173 'qthread' : IPShellQt,
1173 'qthread' : IPShellQt,
1174 'q4thread' : IPShellQt4,
1174 'q4thread' : IPShellQt4,
1175 'tkthread' : IPShell, # Tk is built-in
1175 'tkthread' : IPShell, # Tk is built-in
1176 }
1176 }
1177
1177
1178 backends = {'gthread' : 'GTKAgg',
1178 backends = {'gthread' : 'GTKAgg',
1179 'wthread' : 'WXAgg',
1179 'wthread' : 'WXAgg',
1180 'qthread' : 'QtAgg',
1180 'qthread' : 'QtAgg',
1181 'q4thread' :'Qt4Agg',
1181 'q4thread' :'Qt4Agg',
1182 'tkthread' :'TkAgg',
1182 'tkthread' :'TkAgg',
1183 }
1183 }
1184
1184
1185 all_opts = set(['tk','pylab','gthread','qthread','q4thread','wthread',
1185 all_opts = set(['tk','pylab','gthread','qthread','q4thread','wthread',
1186 'tkthread'])
1186 'tkthread'])
1187 user_opts = set([s.replace('-','') for s in argv[:3]])
1187 user_opts = set([s.replace('-','') for s in argv[:3]])
1188 special_opts = user_opts & all_opts
1188 special_opts = user_opts & all_opts
1189
1189
1190 if 'tk' in special_opts:
1190 if 'tk' in special_opts:
1191 USE_TK = True
1191 USE_TK = True
1192 special_opts.remove('tk')
1192 special_opts.remove('tk')
1193
1193
1194 if 'pylab' in special_opts:
1194 if 'pylab' in special_opts:
1195
1195
1196 try:
1196 try:
1197 import matplotlib
1197 import matplotlib
1198 except ImportError:
1198 except ImportError:
1199 error('matplotlib could NOT be imported! Starting normal IPython.')
1199 error('matplotlib could NOT be imported! Starting normal IPython.')
1200 return IPShell
1200 return IPShell
1201
1201
1202 special_opts.remove('pylab')
1202 special_opts.remove('pylab')
1203 # If there's any option left, it means the user wants to force the
1203 # If there's any option left, it means the user wants to force the
1204 # threading backend, else it's auto-selected from the rc file
1204 # threading backend, else it's auto-selected from the rc file
1205 if special_opts:
1205 if special_opts:
1206 th_mode = special_opts.pop()
1206 th_mode = special_opts.pop()
1207 matplotlib.rcParams['backend'] = backends[th_mode]
1207 matplotlib.rcParams['backend'] = backends[th_mode]
1208 else:
1208 else:
1209 backend = matplotlib.rcParams['backend']
1209 backend = matplotlib.rcParams['backend']
1210 if backend.startswith('GTK'):
1210 if backend.startswith('GTK'):
1211 th_mode = 'gthread'
1211 th_mode = 'gthread'
1212 elif backend.startswith('WX'):
1212 elif backend.startswith('WX'):
1213 th_mode = 'wthread'
1213 th_mode = 'wthread'
1214 elif backend.startswith('Qt4'):
1214 elif backend.startswith('Qt4'):
1215 th_mode = 'q4thread'
1215 th_mode = 'q4thread'
1216 elif backend.startswith('Qt'):
1216 elif backend.startswith('Qt'):
1217 th_mode = 'qthread'
1217 th_mode = 'qthread'
1218 else:
1218 else:
1219 # Any other backend, use plain Tk
1219 # Any other backend, use plain Tk
1220 th_mode = 'tkthread'
1220 th_mode = 'tkthread'
1221
1221
1222 return mpl_shell[th_mode]
1222 return mpl_shell[th_mode]
1223 else:
1223 else:
1224 # No pylab requested, just plain threads
1224 # No pylab requested, just plain threads
1225 try:
1225 try:
1226 th_mode = special_opts.pop()
1226 th_mode = special_opts.pop()
1227 except KeyError:
1227 except KeyError:
1228 th_mode = 'tkthread'
1228 th_mode = 'tkthread'
1229 return th_shell[th_mode]
1229 return th_shell[th_mode]
1230
1230
1231
1231
1232 # This is the one which should be called by external code.
1232 # This is the one which should be called by external code.
1233 def start(user_ns = None):
1233 def start(user_ns = None):
1234 """Return a running shell instance, dealing with threading options.
1234 """Return a running shell instance, dealing with threading options.
1235
1235
1236 This is a factory function which will instantiate the proper IPython shell
1236 This is a factory function which will instantiate the proper IPython shell
1237 based on the user's threading choice. Such a selector is needed because
1237 based on the user's threading choice. Such a selector is needed because
1238 different GUI toolkits require different thread handling details."""
1238 different GUI toolkits require different thread handling details."""
1239
1239
1240 shell = _select_shell(sys.argv)
1240 shell = _select_shell(sys.argv)
1241 return shell(user_ns = user_ns)
1241 return shell(user_ns = user_ns)
1242
1242
1243 # Some aliases for backwards compatibility
1243 # Some aliases for backwards compatibility
1244 IPythonShell = IPShell
1244 IPythonShell = IPShell
1245 IPythonShellEmbed = IPShellEmbed
1245 IPythonShellEmbed = IPShellEmbed
1246 #************************ End of file <Shell.py> ***************************
1246 #************************ End of file <Shell.py> ***************************
@@ -1,631 +1,631 b''
1 # -*- Mode: Shell-Script -*- Not really, but shows comments correctly
1 # -*- Mode: Shell-Script -*- Not really, but shows comments correctly
2
2
3 #***************************************************************************
3 #***************************************************************************
4 #
4 #
5 # Configuration file for IPython -- ipythonrc format
5 # Configuration file for IPython -- ipythonrc format
6 #
6 #
7 # ===========================================================
7 # ===========================================================
8 # Deprecation note: you should look into modifying ipy_user_conf.py (located
8 # Deprecation note: you should look into modifying ipy_user_conf.py (located
9 # in ~/.ipython or ~/_ipython, depending on your platform) instead, it's a
9 # in ~/.ipython or ~/_ipython, depending on your platform) instead, it's a
10 # more flexible and robust (and better supported!) configuration
10 # more flexible and robust (and better supported!) configuration
11 # method.
11 # method.
12 # ===========================================================
12 # ===========================================================
13 #
13 #
14 # The format of this file is simply one of 'key value' lines.
14 # The format of this file is simply one of 'key value' lines.
15 # Lines containing only whitespace at the beginning and then a # are ignored
15 # Lines containing only whitespace at the beginning and then a # are ignored
16 # as comments. But comments can NOT be put on lines with data.
16 # as comments. But comments can NOT be put on lines with data.
17
17
18 # The meaning and use of each key are explained below.
18 # The meaning and use of each key are explained below.
19
19
20 #---------------------------------------------------------------------------
20 #---------------------------------------------------------------------------
21 # Section: included files
21 # Section: included files
22
22
23 # Put one or more *config* files (with the syntax of this file) you want to
23 # Put one or more *config* files (with the syntax of this file) you want to
24 # include. For keys with a unique value the outermost file has precedence. For
24 # include. For keys with a unique value the outermost file has precedence. For
25 # keys with multiple values, they all get assembled into a list which then
25 # keys with multiple values, they all get assembled into a list which then
26 # gets loaded by IPython.
26 # gets loaded by IPython.
27
27
28 # In this file, all lists of things should simply be space-separated.
28 # In this file, all lists of things should simply be space-separated.
29
29
30 # This allows you to build hierarchies of files which recursively load
30 # This allows you to build hierarchies of files which recursively load
31 # lower-level services. If this is your main ~/.ipython/ipythonrc file, you
31 # lower-level services. If this is your main ~/.ipython/ipythonrc file, you
32 # should only keep here basic things you always want available. Then you can
32 # should only keep here basic things you always want available. Then you can
33 # include it in every other special-purpose config file you create.
33 # include it in every other special-purpose config file you create.
34 include
34 include
35
35
36 #---------------------------------------------------------------------------
36 #---------------------------------------------------------------------------
37 # Section: startup setup
37 # Section: startup setup
38
38
39 # These are mostly things which parallel a command line option of the same
39 # These are mostly things which parallel a command line option of the same
40 # name.
40 # name.
41
41
42 # Keys in this section should only appear once. If any key from this section
42 # Keys in this section should only appear once. If any key from this section
43 # is encountered more than once, the last value remains, all earlier ones get
43 # is encountered more than once, the last value remains, all earlier ones get
44 # discarded.
44 # discarded.
45
45
46
46
47 # Automatic calling of callable objects. If set to 1 or 2, callable objects
47 # Automatic calling of callable objects. If set to 1 or 2, callable objects
48 # are automatically called when invoked at the command line, even if you don't
48 # are automatically called when invoked at the command line, even if you don't
49 # type parentheses. IPython adds the parentheses for you. For example:
49 # type parentheses. IPython adds the parentheses for you. For example:
50
50
51 #In [1]: str 45
51 #In [1]: str 45
52 #------> str(45)
52 #------> str(45)
53 #Out[1]: '45'
53 #Out[1]: '45'
54
54
55 # IPython reprints your line with '---->' indicating that it added
55 # IPython reprints your line with '---->' indicating that it added
56 # parentheses. While this option is very convenient for interactive use, it
56 # parentheses. While this option is very convenient for interactive use, it
57 # may occasionally cause problems with objects which have side-effects if
57 # may occasionally cause problems with objects which have side-effects if
58 # called unexpectedly.
58 # called unexpectedly.
59
59
60 # The valid values for autocall are:
60 # The valid values for autocall are:
61
61
62 # autocall 0 -> disabled (you can toggle it at runtime with the %autocall magic)
62 # autocall 0 -> disabled (you can toggle it at runtime with the %autocall magic)
63
63
64 # autocall 1 -> active, but do not apply if there are no arguments on the line.
64 # autocall 1 -> active, but do not apply if there are no arguments on the line.
65
65
66 # In this mode, you get:
66 # In this mode, you get:
67
67
68 #In [1]: callable
68 #In [1]: callable
69 #Out[1]: <built-in function callable>
69 #Out[1]: <built-in function callable>
70
70
71 #In [2]: callable 'hello'
71 #In [2]: callable 'hello'
72 #------> callable('hello')
72 #------> callable('hello')
73 #Out[2]: False
73 #Out[2]: False
74
74
75 # 2 -> Active always. Even if no arguments are present, the callable object
75 # 2 -> Active always. Even if no arguments are present, the callable object
76 # is called:
76 # is called:
77
77
78 #In [4]: callable
78 #In [4]: callable
79 #------> callable()
79 #------> callable()
80
80
81 # Note that even with autocall off, you can still use '/' at the start of a
81 # Note that even with autocall off, you can still use '/' at the start of a
82 # line to treat the first argument on the command line as a function and add
82 # line to treat the first argument on the command line as a function and add
83 # parentheses to it:
83 # parentheses to it:
84
84
85 #In [8]: /str 43
85 #In [8]: /str 43
86 #------> str(43)
86 #------> str(43)
87 #Out[8]: '43'
87 #Out[8]: '43'
88
88
89 autocall 1
89 autocall 1
90
90
91 # Auto-edit syntax errors. When you use the %edit magic in ipython to edit
91 # Auto-edit syntax errors. When you use the %edit magic in ipython to edit
92 # source code (see the 'editor' variable below), it is possible that you save
92 # source code (see the 'editor' variable below), it is possible that you save
93 # a file with syntax errors in it. If this variable is true, IPython will ask
93 # a file with syntax errors in it. If this variable is true, IPython will ask
94 # you whether to re-open the editor immediately to correct such an error.
94 # you whether to re-open the editor immediately to correct such an error.
95
95
96 autoedit_syntax 0
96 autoedit_syntax 0
97
97
98 # Auto-indent. IPython can recognize lines ending in ':' and indent the next
98 # Auto-indent. IPython can recognize lines ending in ':' and indent the next
99 # line, while also un-indenting automatically after 'raise' or 'return'.
99 # line, while also un-indenting automatically after 'raise' or 'return'.
100
100
101 # This feature uses the readline library, so it will honor your ~/.inputrc
101 # This feature uses the readline library, so it will honor your ~/.inputrc
102 # configuration (or whatever file your INPUTRC variable points to). Adding
102 # configuration (or whatever file your INPUTRC variable points to). Adding
103 # the following lines to your .inputrc file can make indent/unindenting more
103 # the following lines to your .inputrc file can make indent/unindenting more
104 # convenient (M-i indents, M-u unindents):
104 # convenient (M-i indents, M-u unindents):
105
105
106 # $if Python
106 # $if Python
107 # "\M-i": " "
107 # "\M-i": " "
108 # "\M-u": "\d\d\d\d"
108 # "\M-u": "\d\d\d\d"
109 # $endif
109 # $endif
110
110
111 # The feature is potentially a bit dangerous, because it can cause problems
111 # The feature is potentially a bit dangerous, because it can cause problems
112 # with pasting of indented code (the pasted code gets re-indented on each
112 # with pasting of indented code (the pasted code gets re-indented on each
113 # line). But it's a huge time-saver when working interactively. The magic
113 # line). But it's a huge time-saver when working interactively. The magic
114 # function %autoindent allows you to toggle it on/off at runtime.
114 # function %autoindent allows you to toggle it on/off at runtime.
115
115
116 autoindent 1
116 autoindent 1
117
117
118 # Auto-magic. This gives you access to all the magic functions without having
118 # Auto-magic. This gives you access to all the magic functions without having
119 # to prepend them with an % sign. If you define a variable with the same name
119 # to prepend them with an % sign. If you define a variable with the same name
120 # as a magic function (say who=1), you will need to access the magic function
120 # as a magic function (say who=1), you will need to access the magic function
121 # with % (%who in this example). However, if later you delete your variable
121 # with % (%who in this example). However, if later you delete your variable
122 # (del who), you'll recover the automagic calling form.
122 # (del who), you'll recover the automagic calling form.
123
123
124 # Considering that many magic functions provide a lot of shell-like
124 # Considering that many magic functions provide a lot of shell-like
125 # functionality, automagic gives you something close to a full Python+system
125 # functionality, automagic gives you something close to a full Python+system
126 # shell environment (and you can extend it further if you want).
126 # shell environment (and you can extend it further if you want).
127
127
128 automagic 1
128 automagic 1
129
129
130 # Size of the output cache. After this many entries are stored, the cache will
130 # Size of the output cache. After this many entries are stored, the cache will
131 # get flushed. Depending on the size of your intermediate calculations, you
131 # get flushed. Depending on the size of your intermediate calculations, you
132 # may have memory problems if you make it too big, since keeping things in the
132 # may have memory problems if you make it too big, since keeping things in the
133 # cache prevents Python from reclaiming the memory for old results. Experiment
133 # cache prevents Python from reclaiming the memory for old results. Experiment
134 # with a value that works well for you.
134 # with a value that works well for you.
135
135
136 # If you choose cache_size 0 IPython will revert to python's regular >>>
136 # If you choose cache_size 0 IPython will revert to python's regular >>>
137 # unnumbered prompt. You will still have _, __ and ___ for your last three
137 # unnumbered prompt. You will still have _, __ and ___ for your last three
138 # results, but that will be it. No dynamic _1, _2, etc. will be created. If
138 # results, but that will be it. No dynamic _1, _2, etc. will be created. If
139 # you are running on a slow machine or with very limited memory, this may
139 # you are running on a slow machine or with very limited memory, this may
140 # help.
140 # help.
141
141
142 cache_size 1000
142 cache_size 1000
143
143
144 # Classic mode: Setting 'classic 1' you lose many of IPython niceties,
144 # Classic mode: Setting 'classic 1' you lose many of IPython niceties,
145 # but that's your choice! Classic 1 -> same as IPython -classic.
145 # but that's your choice! Classic 1 -> same as IPython -classic.
146 # Note that this is _not_ the normal python interpreter, it's simply
146 # Note that this is _not_ the normal python interpreter, it's simply
147 # IPython emulating most of the classic interpreter's behavior.
147 # IPython emulating most of the classic interpreter's behavior.
148 classic 0
148 classic 0
149
149
150 # colors - Coloring option for prompts and traceback printouts.
150 # colors - Coloring option for prompts and traceback printouts.
151
151
152 # Currently available schemes: NoColor, Linux, LightBG.
152 # Currently available schemes: NoColor, Linux, LightBG.
153
153
154 # This option allows coloring the prompts and traceback printouts. This
154 # This option allows coloring the prompts and traceback printouts. This
155 # requires a terminal which can properly handle color escape sequences. If you
155 # requires a terminal which can properly handle color escape sequences. If you
156 # are having problems with this, use the NoColor scheme (uses no color escapes
156 # are having problems with this, use the NoColor scheme (uses no color escapes
157 # at all).
157 # at all).
158
158
159 # The Linux option works well in linux console type environments: dark
159 # The Linux option works well in linux console type environments: dark
160 # background with light fonts.
160 # background with light fonts.
161
161
162 # LightBG is similar to Linux but swaps dark/light colors to be more readable
162 # LightBG is similar to Linux but swaps dark/light colors to be more readable
163 # in light background terminals.
163 # in light background terminals.
164
164
165 # keep uncommented only the one you want:
165 # keep uncommented only the one you want:
166 colors Linux
166 colors Linux
167 #colors LightBG
167 #colors LightBG
168 #colors NoColor
168 #colors NoColor
169
169
170 ########################
170 ########################
171 # Note to Windows users
171 # Note to Windows users
172 #
172 #
173 # Color and readline support is avaialble to Windows users via Gary Bishop's
173 # Color and readline support is avaialble to Windows users via Gary Bishop's
174 # readline library. You can find Gary's tools at
174 # readline library. You can find Gary's tools at
175 # http://sourceforge.net/projects/uncpythontools.
175 # http://sourceforge.net/projects/uncpythontools.
176 # Note that his readline module requires in turn the ctypes library, available
176 # Note that his readline module requires in turn the ctypes library, available
177 # at http://starship.python.net/crew/theller/ctypes.
177 # at http://starship.python.net/crew/theller/ctypes.
178 ########################
178 ########################
179
179
180 # color_info: IPython can display information about objects via a set of
180 # color_info: IPython can display information about objects via a set of
181 # functions, and optionally can use colors for this, syntax highlighting
181 # functions, and optionally can use colors for this, syntax highlighting
182 # source code and various other elements. This information is passed through a
182 # source code and various other elements. This information is passed through a
183 # pager (it defaults to 'less' if $PAGER is not set).
183 # pager (it defaults to 'less' if $PAGER is not set).
184
184
185 # If your pager has problems, try to setting it to properly handle escapes
185 # If your pager has problems, try to setting it to properly handle escapes
186 # (see the less manpage for detail), or disable this option. The magic
186 # (see the less manpage for detail), or disable this option. The magic
187 # function %color_info allows you to toggle this interactively for testing.
187 # function %color_info allows you to toggle this interactively for testing.
188
188
189 color_info 1
189 color_info 1
190
190
191 # confirm_exit: set to 1 if you want IPython to confirm when you try to exit
191 # confirm_exit: set to 1 if you want IPython to confirm when you try to exit
192 # with an EOF (Control-d in Unix, Control-Z/Enter in Windows). Note that using
192 # with an EOF (Control-d in Unix, Control-Z/Enter in Windows). Note that using
193 # the magic functions %Exit or %Quit you can force a direct exit, bypassing
193 # the magic functions %Exit or %Quit you can force a direct exit, bypassing
194 # any confirmation.
194 # any confirmation.
195
195
196 confirm_exit 1
196 confirm_exit 1
197
197
198 # Use deep_reload() as a substitute for reload() by default. deep_reload() is
198 # Use deep_reload() as a substitute for reload() by default. deep_reload() is
199 # still available as dreload() and appears as a builtin.
199 # still available as dreload() and appears as a builtin.
200
200
201 deep_reload 0
201 deep_reload 0
202
202
203 # Which editor to use with the %edit command. If you leave this at 0, IPython
203 # Which editor to use with the %edit command. If you leave this at 0, IPython
204 # will honor your EDITOR environment variable. Since this editor is invoked on
204 # will honor your EDITOR environment variable. Since this editor is invoked on
205 # the fly by ipython and is meant for editing small code snippets, you may
205 # the fly by ipython and is meant for editing small code snippets, you may
206 # want to use a small, lightweight editor here.
206 # want to use a small, lightweight editor here.
207
207
208 # For Emacs users, setting up your Emacs server properly as described in the
208 # For Emacs users, setting up your Emacs server properly as described in the
209 # manual is a good idea. An alternative is to use jed, a very light editor
209 # manual is a good idea. An alternative is to use jed, a very light editor
210 # with much of the feel of Emacs (though not as powerful for heavy-duty work).
210 # with much of the feel of Emacs (though not as powerful for heavy-duty work).
211
211
212 editor 0
212 editor 0
213
213
214 # log 1 -> same as ipython -log. This automatically logs to ./ipython.log
214 # log 1 -> same as ipython -log. This automatically logs to ./ipython.log
215 log 0
215 log 0
216
216
217 # Same as ipython -Logfile YourLogfileName.
217 # Same as ipython -Logfile YourLogfileName.
218 # Don't use with log 1 (use one or the other)
218 # Don't use with log 1 (use one or the other)
219 logfile ''
219 logfile ''
220
220
221 # banner 0 -> same as ipython -nobanner
221 # banner 0 -> same as ipython -nobanner
222 banner 1
222 banner 1
223
223
224 # messages 0 -> same as ipython -nomessages
224 # messages 0 -> same as ipython -nomessages
225 messages 1
225 messages 1
226
226
227 # Automatically call the pdb debugger after every uncaught exception. If you
227 # Automatically call the pdb debugger after every uncaught exception. If you
228 # are used to debugging using pdb, this puts you automatically inside of it
228 # are used to debugging using pdb, this puts you automatically inside of it
229 # after any call (either in IPython or in code called by it) which triggers an
229 # after any call (either in IPython or in code called by it) which triggers an
230 # exception which goes uncaught.
230 # exception which goes uncaught.
231 pdb 0
231 pdb 0
232
232
233 # Enable the pprint module for printing. pprint tends to give a more readable
233 # Enable the pprint module for printing. pprint tends to give a more readable
234 # display (than print) for complex nested data structures.
234 # display (than print) for complex nested data structures.
235 pprint 1
235 pprint 1
236
236
237 # Prompt strings
237 # Prompt strings
238
238
239 # Most bash-like escapes can be used to customize IPython's prompts, as well as
239 # Most bash-like escapes can be used to customize IPython's prompts, as well as
240 # a few additional ones which are IPython-specific. All valid prompt escapes
240 # a few additional ones which are IPython-specific. All valid prompt escapes
241 # are described in detail in the Customization section of the IPython HTML/PDF
241 # are described in detail in the Customization section of the IPython HTML/PDF
242 # manual.
242 # manual.
243
243
244 # Use \# to represent the current prompt number, and quote them to protect
244 # Use \# to represent the current prompt number, and quote them to protect
245 # spaces.
245 # spaces.
246 prompt_in1 'In [\#]: '
246 prompt_in1 'In [\#]: '
247
247
248 # \D is replaced by as many dots as there are digits in the
248 # \D is replaced by as many dots as there are digits in the
249 # current value of \#.
249 # current value of \#.
250 prompt_in2 ' .\D.: '
250 prompt_in2 ' .\D.: '
251
251
252 prompt_out 'Out[\#]: '
252 prompt_out 'Out[\#]: '
253
253
254 # Select whether to left-pad the output prompts to match the length of the
254 # Select whether to left-pad the output prompts to match the length of the
255 # input ones. This allows you for example to use a simple '>' as an output
255 # input ones. This allows you for example to use a simple '>' as an output
256 # prompt, and yet have the output line up with the input. If set to false,
256 # prompt, and yet have the output line up with the input. If set to false,
257 # the output prompts will be unpadded (flush left).
257 # the output prompts will be unpadded (flush left).
258 prompts_pad_left 1
258 prompts_pad_left 1
259
259
260 # Pylab support: when ipython is started with the -pylab switch, by default it
260 # Pylab support: when ipython is started with the -pylab switch, by default it
261 # executes 'from matplotlib.pylab import *'. Set this variable to false if you
261 # executes 'from matplotlib.pylab import *'. Set this variable to false if you
262 # want to disable this behavior.
262 # want to disable this behavior.
263
263
264 # For details on pylab, see the matplotlib website:
264 # For details on pylab, see the matplotlib website:
265 # http://matplotlib.sf.net
265 # http://matplotlib.sf.net
266 pylab_import_all 1
266 pylab_import_all 1
267
267
268
268
269 # quick 1 -> same as ipython -quick
269 # quick 1 -> same as ipython -quick
270 quick 0
270 quick 0
271
271
272 # Use the readline library (1) or not (0). Most users will want this on, but
272 # Use the readline library (1) or not (0). Most users will want this on, but
273 # if you experience strange problems with line management (mainly when using
273 # if you experience strange problems with line management (mainly when using
274 # IPython inside Emacs buffers) you may try disabling it. Not having it on
274 # IPython inside Emacs buffers) you may try disabling it. Not having it on
275 # prevents you from getting command history with the arrow keys, searching and
275 # prevents you from getting command history with the arrow keys, searching and
276 # name completion using TAB.
276 # name completion using TAB.
277
277
278 readline 1
278 readline 1
279
279
280 # Screen Length: number of lines of your screen. This is used to control
280 # Screen Length: number of lines of your screen. This is used to control
281 # printing of very long strings. Strings longer than this number of lines will
281 # printing of very long strings. Strings longer than this number of lines will
282 # be paged with the less command instead of directly printed.
282 # be paged with the less command instead of directly printed.
283
283
284 # The default value for this is 0, which means IPython will auto-detect your
284 # The default value for this is 0, which means IPython will auto-detect your
285 # screen size every time it needs to print. If for some reason this isn't
285 # screen size every time it needs to print. If for some reason this isn't
286 # working well (it needs curses support), specify it yourself. Otherwise don't
286 # working well (it needs curses support), specify it yourself. Otherwise don't
287 # change the default.
287 # change the default.
288
288
289 screen_length 0
289 screen_length 0
290
290
291 # Prompt separators for input and output.
291 # Prompt separators for input and output.
292 # Use \n for newline explicitly, without quotes.
292 # Use \n for newline explicitly, without quotes.
293 # Use 0 (like at the cmd line) to turn off a given separator.
293 # Use 0 (like at the cmd line) to turn off a given separator.
294
294
295 # The structure of prompt printing is:
295 # The structure of prompt printing is:
296 # (SeparateIn)Input....
296 # (SeparateIn)Input....
297 # (SeparateOut)Output...
297 # (SeparateOut)Output...
298 # (SeparateOut2), # that is, no newline is printed after Out2
298 # (SeparateOut2), # that is, no newline is printed after Out2
299 # By choosing these you can organize your output any way you want.
299 # By choosing these you can organize your output any way you want.
300
300
301 separate_in \n
301 separate_in \n
302 separate_out 0
302 separate_out 0
303 separate_out2 0
303 separate_out2 0
304
304
305 # 'nosep 1' is a shorthand for '-SeparateIn 0 -SeparateOut 0 -SeparateOut2 0'.
305 # 'nosep 1' is a shorthand for '-SeparateIn 0 -SeparateOut 0 -SeparateOut2 0'.
306 # Simply removes all input/output separators, overriding the choices above.
306 # Simply removes all input/output separators, overriding the choices above.
307 nosep 0
307 nosep 0
308
308
309 # Wildcard searches - IPython has a system for searching names using
309 # Wildcard searches - IPython has a system for searching names using
310 # shell-like wildcards; type %psearch? for details. This variables sets
310 # shell-like wildcards; type %psearch? for details. This variables sets
311 # whether by default such searches should be case sensitive or not. You can
311 # whether by default such searches should be case sensitive or not. You can
312 # always override the default at the system command line or the IPython
312 # always override the default at the system command line or the IPython
313 # prompt.
313 # prompt.
314
314
315 wildcards_case_sensitive 1
315 wildcards_case_sensitive 1
316
316
317 # Object information: at what level of detail to display the string form of an
317 # Object information: at what level of detail to display the string form of an
318 # object. If set to 0, ipython will compute the string form of any object X,
318 # object. If set to 0, ipython will compute the string form of any object X,
319 # by calling str(X), when X? is typed. If set to 1, str(X) will only be
319 # by calling str(X), when X? is typed. If set to 1, str(X) will only be
320 # computed when X?? is given, and if set to 2 or higher, it will never be
320 # computed when X?? is given, and if set to 2 or higher, it will never be
321 # computed (there is no X??? level of detail). This is mostly of use to
321 # computed (there is no X??? level of detail). This is mostly of use to
322 # people who frequently manipulate objects whose string representation is
322 # people who frequently manipulate objects whose string representation is
323 # extremely expensive to compute.
323 # extremely expensive to compute.
324
324
325 object_info_string_level 0
325 object_info_string_level 0
326
326
327 # xmode - Exception reporting mode.
327 # xmode - Exception reporting mode.
328
328
329 # Valid modes: Plain, Context and Verbose.
329 # Valid modes: Plain, Context and Verbose.
330
330
331 # Plain: similar to python's normal traceback printing.
331 # Plain: similar to python's normal traceback printing.
332
332
333 # Context: prints 5 lines of context source code around each line in the
333 # Context: prints 5 lines of context source code around each line in the
334 # traceback.
334 # traceback.
335
335
336 # Verbose: similar to Context, but additionally prints the variables currently
336 # Verbose: similar to Context, but additionally prints the variables currently
337 # visible where the exception happened (shortening their strings if too
337 # visible where the exception happened (shortening their strings if too
338 # long). This can potentially be very slow, if you happen to have a huge data
338 # long). This can potentially be very slow, if you happen to have a huge data
339 # structure whose string representation is complex to compute. Your computer
339 # structure whose string representation is complex to compute. Your computer
340 # may appear to freeze for a while with cpu usage at 100%. If this occurs, you
340 # may appear to freeze for a while with cpu usage at 100%. If this occurs, you
341 # can cancel the traceback with Ctrl-C (maybe hitting it more than once).
341 # can cancel the traceback with Ctrl-C (maybe hitting it more than once).
342
342
343 #xmode Plain
343 #xmode Plain
344 xmode Context
344 xmode Context
345 #xmode Verbose
345 #xmode Verbose
346
346
347 # multi_line_specials: if true, allow magics, aliases and shell escapes (via
347 # multi_line_specials: if true, allow magics, aliases and shell escapes (via
348 # !cmd) to be used in multi-line input (like for loops). For example, if you
348 # !cmd) to be used in multi-line input (like for loops). For example, if you
349 # have this active, the following is valid in IPython:
349 # have this active, the following is valid in IPython:
350 #
350 #
351 #In [17]: for i in range(3):
351 #In [17]: for i in range(3):
352 # ....: mkdir $i
352 # ....: mkdir $i
353 # ....: !touch $i/hello
353 # ....: !touch $i/hello
354 # ....: ls -l $i
354 # ....: ls -l $i
355
355
356 multi_line_specials 1
356 multi_line_specials 1
357
357
358
358
359 # System calls: When IPython makes system calls (e.g. via special syntax like
359 # System calls: When IPython makes system calls (e.g. via special syntax like
360 # !cmd or !!cmd, or magics like %sc or %sx), it can print the command it is
360 # !cmd or !!cmd, or magics like %sc or %sx), it can print the command it is
361 # executing to standard output, prefixed by a header string.
361 # executing to standard output, prefixed by a header string.
362
362
363 system_header "IPython system call: "
363 system_header "IPython system call: "
364
364
365 system_verbose 1
365 system_verbose 1
366
366
367 # wxversion: request a specific wxPython version (used for -wthread)
367 # wxversion: request a specific wxPython version (used for -wthread)
368
368
369 # Set this to the value of wxPython you want to use, but note that this
369 # Set this to the value of wxPython you want to use, but note that this
370 # feature requires you to have the wxversion Python module to work. If you
370 # feature requires you to have the wxversion Python module to work. If you
371 # don't have the wxversion module (try 'import wxversion' at the prompt to
371 # don't have the wxversion module (try 'import wxversion' at the prompt to
372 # check) or simply want to leave the system to pick up the default, leave this
372 # check) or simply want to leave the system to pick up the default, leave this
373 # variable at 0.
373 # variable at 0.
374
374
375 wxversion 0
375 wxversion 0
376
376
377 #---------------------------------------------------------------------------
377 #---------------------------------------------------------------------------
378 # Section: Readline configuration (readline is not available for MS-Windows)
378 # Section: Readline configuration (readline is not available for MS-Windows)
379
379
380 # This is done via the following options:
380 # This is done via the following options:
381
381
382 # (i) readline_parse_and_bind: this option can appear as many times as you
382 # (i) readline_parse_and_bind: this option can appear as many times as you
383 # want, each time defining a string to be executed via a
383 # want, each time defining a string to be executed via a
384 # readline.parse_and_bind() command. The syntax for valid commands of this
384 # readline.parse_and_bind() command. The syntax for valid commands of this
385 # kind can be found by reading the documentation for the GNU readline library,
385 # kind can be found by reading the documentation for the GNU readline library,
386 # as these commands are of the kind which readline accepts in its
386 # as these commands are of the kind which readline accepts in its
387 # configuration file.
387 # configuration file.
388
388
389 # The TAB key can be used to complete names at the command line in one of two
389 # The TAB key can be used to complete names at the command line in one of two
390 # ways: 'complete' and 'menu-complete'. The difference is that 'complete' only
390 # ways: 'complete' and 'menu-complete'. The difference is that 'complete' only
391 # completes as much as possible while 'menu-complete' cycles through all
391 # completes as much as possible while 'menu-complete' cycles through all
392 # possible completions. Leave the one you prefer uncommented.
392 # possible completions. Leave the one you prefer uncommented.
393
393
394 readline_parse_and_bind tab: complete
394 readline_parse_and_bind tab: complete
395 #readline_parse_and_bind tab: menu-complete
395 #readline_parse_and_bind tab: menu-complete
396
396
397 # This binds Control-l to printing the list of all possible completions when
397 # This binds Control-l to printing the list of all possible completions when
398 # there is more than one (what 'complete' does when hitting TAB twice, or at
398 # there is more than one (what 'complete' does when hitting TAB twice, or at
399 # the first TAB if show-all-if-ambiguous is on)
399 # the first TAB if show-all-if-ambiguous is on)
400 readline_parse_and_bind "\C-l": possible-completions
400 readline_parse_and_bind "\C-l": possible-completions
401
401
402 # This forces readline to automatically print the above list when tab
402 # This forces readline to automatically print the above list when tab
403 # completion is set to 'complete'. You can still get this list manually by
403 # completion is set to 'complete'. You can still get this list manually by
404 # using the key bound to 'possible-completions' (Control-l by default) or by
404 # using the key bound to 'possible-completions' (Control-l by default) or by
405 # hitting TAB twice. Turning this on makes the printing happen at the first
405 # hitting TAB twice. Turning this on makes the printing happen at the first
406 # TAB.
406 # TAB.
407 readline_parse_and_bind set show-all-if-ambiguous on
407 readline_parse_and_bind set show-all-if-ambiguous on
408
408
409 # If you have TAB set to complete names, you can rebind any key (Control-o by
409 # If you have TAB set to complete names, you can rebind any key (Control-o by
410 # default) to insert a true TAB character.
410 # default) to insert a true TAB character.
411 readline_parse_and_bind "\C-o": tab-insert
411 readline_parse_and_bind "\C-o": tab-insert
412
412
413 # These commands allow you to indent/unindent easily, with the 4-space
413 # These commands allow you to indent/unindent easily, with the 4-space
414 # convention of the Python coding standards. Since IPython's internal
414 # convention of the Python coding standards. Since IPython's internal
415 # auto-indent system also uses 4 spaces, you should not change the number of
415 # auto-indent system also uses 4 spaces, you should not change the number of
416 # spaces in the code below.
416 # spaces in the code below.
417 readline_parse_and_bind "\M-i": " "
417 readline_parse_and_bind "\M-i": " "
418 readline_parse_and_bind "\M-o": "\d\d\d\d"
418 readline_parse_and_bind "\M-o": "\d\d\d\d"
419 readline_parse_and_bind "\M-I": "\d\d\d\d"
419 readline_parse_and_bind "\M-I": "\d\d\d\d"
420
420
421 # Bindings for incremental searches in the history. These searches use the
421 # Bindings for incremental searches in the history. These searches use the
422 # string typed so far on the command line and search anything in the previous
422 # string typed so far on the command line and search anything in the previous
423 # input history containing them.
423 # input history containing them.
424 readline_parse_and_bind "\C-r": reverse-search-history
424 readline_parse_and_bind "\C-r": reverse-search-history
425 readline_parse_and_bind "\C-s": forward-search-history
425 readline_parse_and_bind "\C-s": forward-search-history
426
426
427 # Bindings for completing the current line in the history of previous
427 # Bindings for completing the current line in the history of previous
428 # commands. This allows you to recall any previous command by typing its first
428 # commands. This allows you to recall any previous command by typing its first
429 # few letters and hitting Control-p, bypassing all intermediate commands which
429 # few letters and hitting Control-p, bypassing all intermediate commands which
430 # may be in the history (much faster than hitting up-arrow 50 times!)
430 # may be in the history (much faster than hitting up-arrow 50 times!)
431 readline_parse_and_bind "\C-p": history-search-backward
431 readline_parse_and_bind "\C-p": history-search-backward
432 readline_parse_and_bind "\C-n": history-search-forward
432 readline_parse_and_bind "\C-n": history-search-forward
433
433
434 # I also like to have the same functionality on the plain arrow keys. If you'd
434 # I also like to have the same functionality on the plain arrow keys. If you'd
435 # rather have the arrows use all the history (and not just match what you've
435 # rather have the arrows use all the history (and not just match what you've
436 # typed so far), comment out or delete the next two lines.
436 # typed so far), comment out or delete the next two lines.
437 readline_parse_and_bind "\e[A": history-search-backward
437 readline_parse_and_bind "\e[A": history-search-backward
438 readline_parse_and_bind "\e[B": history-search-forward
438 readline_parse_and_bind "\e[B": history-search-forward
439
439
440 # These are typically on by default under *nix, but not win32.
440 # These are typically on by default under *nix, but not win32.
441 readline_parse_and_bind "\C-k": kill-line
441 readline_parse_and_bind "\C-k": kill-line
442 readline_parse_and_bind "\C-u": unix-line-discard
442 readline_parse_and_bind "\C-u": unix-line-discard
443
443
444 # (ii) readline_remove_delims: a string of characters to be removed from the
444 # (ii) readline_remove_delims: a string of characters to be removed from the
445 # default word-delimiters list used by readline, so that completions may be
445 # default word-delimiters list used by readline, so that completions may be
446 # performed on strings which contain them.
446 # performed on strings which contain them.
447
447
448 readline_remove_delims -/~
448 readline_remove_delims -/~
449
449
450 # (iii) readline_merge_completions: whether to merge the result of all
450 # (iii) readline_merge_completions: whether to merge the result of all
451 # possible completions or not. If true, IPython will complete filenames,
451 # possible completions or not. If true, IPython will complete filenames,
452 # python names and aliases and return all possible completions. If you set it
452 # python names and aliases and return all possible completions. If you set it
453 # to false, each completer is used at a time, and only if it doesn't return
453 # to false, each completer is used at a time, and only if it doesn't return
454 # any completions is the next one used.
454 # any completions is the next one used.
455
455
456 # The default order is: [python_matches, file_matches, alias_matches]
456 # The default order is: [python_matches, file_matches, alias_matches]
457
457
458 readline_merge_completions 1
458 readline_merge_completions 1
459
459
460 # (iv) readline_omit__names: normally hitting <tab> after a '.' in a name
460 # (iv) readline_omit__names: normally hitting <tab> after a '.' in a name
461 # will complete all attributes of an object, including all the special methods
461 # will complete all attributes of an object, including all the special methods
462 # whose names start with single or double underscores (like __getitem__ or
462 # whose names start with single or double underscores (like __getitem__ or
463 # __class__).
463 # __class__).
464
464
465 # This variable allows you to control this completion behavior:
465 # This variable allows you to control this completion behavior:
466
466
467 # readline_omit__names 1 -> completion will omit showing any names starting
467 # readline_omit__names 1 -> completion will omit showing any names starting
468 # with two __, but it will still show names starting with one _.
468 # with two __, but it will still show names starting with one _.
469
469
470 # readline_omit__names 2 -> completion will omit all names beginning with one
470 # readline_omit__names 2 -> completion will omit all names beginning with one
471 # _ (which obviously means filtering out the double __ ones).
471 # _ (which obviously means filtering out the double __ ones).
472
472
473 # Even when this option is set, you can still see those names by explicitly
473 # Even when this option is set, you can still see those names by explicitly
474 # typing a _ after the period and hitting <tab>: 'name._<tab>' will always
474 # typing a _ after the period and hitting <tab>: 'name._<tab>' will always
475 # complete attribute names starting with '_'.
475 # complete attribute names starting with '_'.
476
476
477 # This option is off by default so that new users see all attributes of any
477 # This option is off by default so that new users see all attributes of any
478 # objects they are dealing with.
478 # objects they are dealing with.
479
479
480 readline_omit__names 0
480 readline_omit__names 0
481
481
482 #---------------------------------------------------------------------------
482 #---------------------------------------------------------------------------
483 # Section: modules to be loaded with 'import ...'
483 # Section: modules to be loaded with 'import ...'
484
484
485 # List, separated by spaces, the names of the modules you want to import
485 # List, separated by spaces, the names of the modules you want to import
486
486
487 # Example:
487 # Example:
488 # import_mod sys os
488 # import_mod sys os
489 # will produce internally the statements
489 # will produce internally the statements
490 # import sys
490 # import sys
491 # import os
491 # import os
492
492
493 # Each import is executed in its own try/except block, so if one module
493 # Each import is executed in its own try/except block, so if one module
494 # fails to load the others will still be ok.
494 # fails to load the others will still be ok.
495
495
496 import_mod
496 import_mod
497
497
498 #---------------------------------------------------------------------------
498 #---------------------------------------------------------------------------
499 # Section: modules to import some functions from: 'from ... import ...'
499 # Section: modules to import some functions from: 'from ... import ...'
500
500
501 # List, one per line, the modules for which you want only to import some
501 # List, one per line, the modules for which you want only to import some
502 # functions. Give the module name first and then the name of functions to be
502 # functions. Give the module name first and then the name of functions to be
503 # imported from that module.
503 # imported from that module.
504
504
505 # Example:
505 # Example:
506
506
507 # import_some IPython.genutils timing timings
507 # import_some IPython.utils.genutils timing timings
508 # will produce internally the statement
508 # will produce internally the statement
509 # from IPython.genutils import timing, timings
509 # from IPython.utils.genutils import timing, timings
510
510
511 # timing() and timings() are two IPython utilities for timing the execution of
511 # timing() and timings() are two IPython utilities for timing the execution of
512 # your own functions, which you may find useful. Just commment out the above
512 # your own functions, which you may find useful. Just commment out the above
513 # line if you want to test them.
513 # line if you want to test them.
514
514
515 # If you have more than one modules_some line, each gets its own try/except
515 # If you have more than one modules_some line, each gets its own try/except
516 # block (like modules, see above).
516 # block (like modules, see above).
517
517
518 import_some
518 import_some
519
519
520 #---------------------------------------------------------------------------
520 #---------------------------------------------------------------------------
521 # Section: modules to import all from : 'from ... import *'
521 # Section: modules to import all from : 'from ... import *'
522
522
523 # List (same syntax as import_mod above) those modules for which you want to
523 # List (same syntax as import_mod above) those modules for which you want to
524 # import all functions. Remember, this is a potentially dangerous thing to do,
524 # import all functions. Remember, this is a potentially dangerous thing to do,
525 # since it is very easy to overwrite names of things you need. Use with
525 # since it is very easy to overwrite names of things you need. Use with
526 # caution.
526 # caution.
527
527
528 # Example:
528 # Example:
529 # import_all sys os
529 # import_all sys os
530 # will produce internally the statements
530 # will produce internally the statements
531 # from sys import *
531 # from sys import *
532 # from os import *
532 # from os import *
533
533
534 # As before, each will be called in a separate try/except block.
534 # As before, each will be called in a separate try/except block.
535
535
536 import_all
536 import_all
537
537
538 #---------------------------------------------------------------------------
538 #---------------------------------------------------------------------------
539 # Section: Python code to execute.
539 # Section: Python code to execute.
540
540
541 # Put here code to be explicitly executed (keep it simple!)
541 # Put here code to be explicitly executed (keep it simple!)
542 # Put one line of python code per line. All whitespace is removed (this is a
542 # Put one line of python code per line. All whitespace is removed (this is a
543 # feature, not a bug), so don't get fancy building loops here.
543 # feature, not a bug), so don't get fancy building loops here.
544 # This is just for quick convenient creation of things you want available.
544 # This is just for quick convenient creation of things you want available.
545
545
546 # Example:
546 # Example:
547 # execute x = 1
547 # execute x = 1
548 # execute print 'hello world'; y = z = 'a'
548 # execute print 'hello world'; y = z = 'a'
549 # will produce internally
549 # will produce internally
550 # x = 1
550 # x = 1
551 # print 'hello world'; y = z = 'a'
551 # print 'hello world'; y = z = 'a'
552 # and each *line* (not each statement, we don't do python syntax parsing) is
552 # and each *line* (not each statement, we don't do python syntax parsing) is
553 # executed in its own try/except block.
553 # executed in its own try/except block.
554
554
555 execute
555 execute
556
556
557 # Note for the adventurous: you can use this to define your own names for the
557 # Note for the adventurous: you can use this to define your own names for the
558 # magic functions, by playing some namespace tricks:
558 # magic functions, by playing some namespace tricks:
559
559
560 # execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
560 # execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
561
561
562 # defines %pf as a new name for %profile.
562 # defines %pf as a new name for %profile.
563
563
564 #---------------------------------------------------------------------------
564 #---------------------------------------------------------------------------
565 # Section: Pyhton files to load and execute.
565 # Section: Pyhton files to load and execute.
566
566
567 # Put here the full names of files you want executed with execfile(file). If
567 # Put here the full names of files you want executed with execfile(file). If
568 # you want complicated initialization, just write whatever you want in a
568 # you want complicated initialization, just write whatever you want in a
569 # regular python file and load it from here.
569 # regular python file and load it from here.
570
570
571 # Filenames defined here (which *must* include the extension) are searched for
571 # Filenames defined here (which *must* include the extension) are searched for
572 # through all of sys.path. Since IPython adds your .ipython directory to
572 # through all of sys.path. Since IPython adds your .ipython directory to
573 # sys.path, they can also be placed in your .ipython dir and will be
573 # sys.path, they can also be placed in your .ipython dir and will be
574 # found. Otherwise (if you want to execute things not in .ipyton nor in
574 # found. Otherwise (if you want to execute things not in .ipyton nor in
575 # sys.path) give a full path (you can use ~, it gets expanded)
575 # sys.path) give a full path (you can use ~, it gets expanded)
576
576
577 # Example:
577 # Example:
578 # execfile file1.py ~/file2.py
578 # execfile file1.py ~/file2.py
579 # will generate
579 # will generate
580 # execfile('file1.py')
580 # execfile('file1.py')
581 # execfile('_path_to_your_home/file2.py')
581 # execfile('_path_to_your_home/file2.py')
582
582
583 # As before, each file gets its own try/except block.
583 # As before, each file gets its own try/except block.
584
584
585 execfile
585 execfile
586
586
587 # If you are feeling adventurous, you can even add functionality to IPython
587 # If you are feeling adventurous, you can even add functionality to IPython
588 # through here. IPython works through a global variable called __ip which
588 # through here. IPython works through a global variable called __ip which
589 # exists at the time when these files are read. If you know what you are doing
589 # exists at the time when these files are read. If you know what you are doing
590 # (read the source) you can add functions to __ip in files loaded here.
590 # (read the source) you can add functions to __ip in files loaded here.
591
591
592 # The file example-magic.py contains a simple but correct example. Try it:
592 # The file example-magic.py contains a simple but correct example. Try it:
593
593
594 # execfile example-magic.py
594 # execfile example-magic.py
595
595
596 # Look at the examples in IPython/iplib.py for more details on how these magic
596 # Look at the examples in IPython/iplib.py for more details on how these magic
597 # functions need to process their arguments.
597 # functions need to process their arguments.
598
598
599 #---------------------------------------------------------------------------
599 #---------------------------------------------------------------------------
600 # Section: aliases for system shell commands
600 # Section: aliases for system shell commands
601
601
602 # Here you can define your own names for system commands. The syntax is
602 # Here you can define your own names for system commands. The syntax is
603 # similar to that of the builtin %alias function:
603 # similar to that of the builtin %alias function:
604
604
605 # alias alias_name command_string
605 # alias alias_name command_string
606
606
607 # The resulting aliases are auto-generated magic functions (hence usable as
607 # The resulting aliases are auto-generated magic functions (hence usable as
608 # %alias_name)
608 # %alias_name)
609
609
610 # For example:
610 # For example:
611
611
612 # alias myls ls -la
612 # alias myls ls -la
613
613
614 # will define 'myls' as an alias for executing the system command 'ls -la'.
614 # will define 'myls' as an alias for executing the system command 'ls -la'.
615 # This allows you to customize IPython's environment to have the same aliases
615 # This allows you to customize IPython's environment to have the same aliases
616 # you are accustomed to from your own shell.
616 # you are accustomed to from your own shell.
617
617
618 # You can also define aliases with parameters using %s specifiers (one per
618 # You can also define aliases with parameters using %s specifiers (one per
619 # parameter):
619 # parameter):
620
620
621 # alias parts echo first %s second %s
621 # alias parts echo first %s second %s
622
622
623 # will give you in IPython:
623 # will give you in IPython:
624 # >>> %parts A B
624 # >>> %parts A B
625 # first A second B
625 # first A second B
626
626
627 # Use one 'alias' statement per alias you wish to define.
627 # Use one 'alias' statement per alias you wish to define.
628
628
629 # alias
629 # alias
630
630
631 #************************* end of file <ipythonrc> ************************
631 #************************* end of file <ipythonrc> ************************
@@ -1,102 +1,102 b''
1 # encoding: utf-8
1 # encoding: utf-8
2
2
3 """This is the official entry point to IPython's configuration system. """
3 """This is the official entry point to IPython's configuration system. """
4
4
5 __docformat__ = "restructuredtext en"
5 __docformat__ = "restructuredtext en"
6
6
7 #-------------------------------------------------------------------------------
7 #-------------------------------------------------------------------------------
8 # Copyright (C) 2008 The IPython Development Team
8 # Copyright (C) 2008 The IPython Development Team
9 #
9 #
10 # Distributed under the terms of the BSD License. The full license is in
10 # Distributed under the terms of the BSD License. The full license is in
11 # the file COPYING, distributed as part of this software.
11 # the file COPYING, distributed as part of this software.
12 #-------------------------------------------------------------------------------
12 #-------------------------------------------------------------------------------
13
13
14 #-------------------------------------------------------------------------------
14 #-------------------------------------------------------------------------------
15 # Imports
15 # Imports
16 #-------------------------------------------------------------------------------
16 #-------------------------------------------------------------------------------
17
17
18 import os
18 import os
19 from os.path import join as pjoin
19 from os.path import join as pjoin
20
20
21 from IPython.genutils import get_home_dir, get_ipython_dir
21 from IPython.utils.genutils import get_home_dir, get_ipython_dir
22 from IPython.external.configobj import ConfigObj
22 from IPython.external.configobj import ConfigObj
23
23
24
24
25 class ConfigObjManager(object):
25 class ConfigObjManager(object):
26
26
27 def __init__(self, configObj, filename):
27 def __init__(self, configObj, filename):
28 self.current = configObj
28 self.current = configObj
29 self.current.indent_type = ' '
29 self.current.indent_type = ' '
30 self.filename = filename
30 self.filename = filename
31 # self.write_default_config_file()
31 # self.write_default_config_file()
32
32
33 def get_config_obj(self):
33 def get_config_obj(self):
34 return self.current
34 return self.current
35
35
36 def update_config_obj(self, newConfig):
36 def update_config_obj(self, newConfig):
37 self.current.merge(newConfig)
37 self.current.merge(newConfig)
38
38
39 def update_config_obj_from_file(self, filename):
39 def update_config_obj_from_file(self, filename):
40 newConfig = ConfigObj(filename, file_error=False)
40 newConfig = ConfigObj(filename, file_error=False)
41 self.current.merge(newConfig)
41 self.current.merge(newConfig)
42
42
43 def update_config_obj_from_default_file(self, ipythondir=None):
43 def update_config_obj_from_default_file(self, ipythondir=None):
44 fname = self.resolve_file_path(self.filename, ipythondir)
44 fname = self.resolve_file_path(self.filename, ipythondir)
45 self.update_config_obj_from_file(fname)
45 self.update_config_obj_from_file(fname)
46
46
47 def write_config_obj_to_file(self, filename):
47 def write_config_obj_to_file(self, filename):
48 f = open(filename, 'w')
48 f = open(filename, 'w')
49 self.current.write(f)
49 self.current.write(f)
50 f.close()
50 f.close()
51
51
52 def write_default_config_file(self):
52 def write_default_config_file(self):
53 ipdir = get_ipython_dir()
53 ipdir = get_ipython_dir()
54 fname = pjoin(ipdir, self.filename)
54 fname = pjoin(ipdir, self.filename)
55 if not os.path.isfile(fname):
55 if not os.path.isfile(fname):
56 print "Writing the configuration file to: " + fname
56 print "Writing the configuration file to: " + fname
57 self.write_config_obj_to_file(fname)
57 self.write_config_obj_to_file(fname)
58
58
59 def _import(self, key):
59 def _import(self, key):
60 package = '.'.join(key.split('.')[0:-1])
60 package = '.'.join(key.split('.')[0:-1])
61 obj = key.split('.')[-1]
61 obj = key.split('.')[-1]
62 execString = 'from %s import %s' % (package, obj)
62 execString = 'from %s import %s' % (package, obj)
63 exec execString
63 exec execString
64 exec 'temp = %s' % obj
64 exec 'temp = %s' % obj
65 return temp
65 return temp
66
66
67 def resolve_file_path(self, filename, ipythondir = None):
67 def resolve_file_path(self, filename, ipythondir = None):
68 """Resolve filenames into absolute paths.
68 """Resolve filenames into absolute paths.
69
69
70 This function looks in the following directories in order:
70 This function looks in the following directories in order:
71
71
72 1. In the current working directory or by absolute path with ~ expanded
72 1. In the current working directory or by absolute path with ~ expanded
73 2. In ipythondir if that is set
73 2. In ipythondir if that is set
74 3. In the IPYTHONDIR environment variable if it exists
74 3. In the IPYTHONDIR environment variable if it exists
75 4. In the ~/.ipython directory
75 4. In the ~/.ipython directory
76
76
77 Note: The IPYTHONDIR is also used by the trunk version of IPython so
77 Note: The IPYTHONDIR is also used by the trunk version of IPython so
78 changing it will also affect it was well.
78 changing it will also affect it was well.
79 """
79 """
80
80
81 # In cwd or by absolute path with ~ expanded
81 # In cwd or by absolute path with ~ expanded
82 trythis = os.path.expanduser(filename)
82 trythis = os.path.expanduser(filename)
83 if os.path.isfile(trythis):
83 if os.path.isfile(trythis):
84 return trythis
84 return trythis
85
85
86 # In ipythondir if it is set
86 # In ipythondir if it is set
87 if ipythondir is not None:
87 if ipythondir is not None:
88 trythis = pjoin(ipythondir, filename)
88 trythis = pjoin(ipythondir, filename)
89 if os.path.isfile(trythis):
89 if os.path.isfile(trythis):
90 return trythis
90 return trythis
91
91
92 trythis = pjoin(get_ipython_dir(), filename)
92 trythis = pjoin(get_ipython_dir(), filename)
93 if os.path.isfile(trythis):
93 if os.path.isfile(trythis):
94 return trythis
94 return trythis
95
95
96 return None
96 return None
97
97
98
98
99
99
100
100
101
101
102
102
@@ -1,111 +1,111 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Configuration loader
2 """Configuration loader
3 """
3 """
4
4
5 #*****************************************************************************
5 #*****************************************************************************
6 # Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
6 # Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
7 #
7 #
8 # Distributed under the terms of the BSD License. The full license is in
8 # Distributed under the terms of the BSD License. The full license is in
9 # the file COPYING, distributed as part of this software.
9 # the file COPYING, distributed as part of this software.
10 #*****************************************************************************
10 #*****************************************************************************
11
11
12 import exceptions
12 import exceptions
13 import os
13 import os
14 from pprint import pprint
14 from pprint import pprint
15
15
16 from IPython import ultraTB
16 from IPython import ultraTB
17 from IPython.ipstruct import Struct
17 from IPython.ipstruct import Struct
18 from IPython.genutils import *
18 from IPython.utils.genutils import *
19
19
20 class ConfigLoaderError(exceptions.Exception):
20 class ConfigLoaderError(exceptions.Exception):
21 """Exception for ConfigLoader class."""
21 """Exception for ConfigLoader class."""
22
22
23 def __init__(self,args=None):
23 def __init__(self,args=None):
24 self.args = args
24 self.args = args
25
25
26 class ConfigLoader:
26 class ConfigLoader:
27
27
28 """Configuration file loader capable of handling recursive inclusions and
28 """Configuration file loader capable of handling recursive inclusions and
29 with parametrized conflict resolution for multiply found keys."""
29 with parametrized conflict resolution for multiply found keys."""
30
30
31 def __init__(self,conflict=None,field_sep=None,reclimit=15):
31 def __init__(self,conflict=None,field_sep=None,reclimit=15):
32
32
33 """The reclimit parameter controls the number of recursive
33 """The reclimit parameter controls the number of recursive
34 configuration file inclusions. This way we can stop early on (before
34 configuration file inclusions. This way we can stop early on (before
35 python's own recursion limit is hit) if there is a circular
35 python's own recursion limit is hit) if there is a circular
36 inclusion.
36 inclusion.
37
37
38 - conflict: dictionary for conflict resolutions (see Struct.merge())
38 - conflict: dictionary for conflict resolutions (see Struct.merge())
39
39
40 """
40 """
41 self.conflict = conflict
41 self.conflict = conflict
42 self.field_sep = field_sep
42 self.field_sep = field_sep
43 self.reset(reclimit)
43 self.reset(reclimit)
44
44
45 def reset(self,reclimit=15):
45 def reset(self,reclimit=15):
46 self.reclimit = reclimit
46 self.reclimit = reclimit
47 self.recdepth = 0
47 self.recdepth = 0
48 self.included = []
48 self.included = []
49
49
50 def load(self,fname,convert=None,recurse_key='',incpath = '.',**kw):
50 def load(self,fname,convert=None,recurse_key='',incpath = '.',**kw):
51 """Load a configuration file, return the resulting Struct.
51 """Load a configuration file, return the resulting Struct.
52
52
53 Call: load_config(fname,convert=None,conflict=None,recurse_key='')
53 Call: load_config(fname,convert=None,conflict=None,recurse_key='')
54
54
55 - fname: file to load from.
55 - fname: file to load from.
56 - convert: dictionary of type conversions (see read_dict())
56 - convert: dictionary of type conversions (see read_dict())
57 - recurse_key: keyword in dictionary to trigger recursive file
57 - recurse_key: keyword in dictionary to trigger recursive file
58 inclusions.
58 inclusions.
59 """
59 """
60
60
61 if self.recdepth > self.reclimit:
61 if self.recdepth > self.reclimit:
62 raise ConfigLoaderError, 'maximum recursive inclusion of rcfiles '+\
62 raise ConfigLoaderError, 'maximum recursive inclusion of rcfiles '+\
63 'exceeded: ' + `self.recdepth` + \
63 'exceeded: ' + `self.recdepth` + \
64 '.\nMaybe you have a circular chain of inclusions?'
64 '.\nMaybe you have a circular chain of inclusions?'
65 self.recdepth += 1
65 self.recdepth += 1
66 fname = filefind(fname,incpath)
66 fname = filefind(fname,incpath)
67 data = Struct()
67 data = Struct()
68 # avoid including the same file more than once
68 # avoid including the same file more than once
69 if fname in self.included:
69 if fname in self.included:
70 return data
70 return data
71 Xinfo = ultraTB.AutoFormattedTB(color_scheme='NoColor')
71 Xinfo = ultraTB.AutoFormattedTB(color_scheme='NoColor')
72 if convert==None and recurse_key : convert = {qwflat:recurse_key}
72 if convert==None and recurse_key : convert = {qwflat:recurse_key}
73 # for production, change warn to 0:
73 # for production, change warn to 0:
74 data.merge(read_dict(fname,convert,fs=self.field_sep,strip=1,
74 data.merge(read_dict(fname,convert,fs=self.field_sep,strip=1,
75 warn=0,no_empty=0,**kw))
75 warn=0,no_empty=0,**kw))
76 # keep track of successfully loaded files
76 # keep track of successfully loaded files
77 self.included.append(fname)
77 self.included.append(fname)
78 if recurse_key in data:
78 if recurse_key in data:
79 for incfilename in data[recurse_key]:
79 for incfilename in data[recurse_key]:
80 found=0
80 found=0
81 try:
81 try:
82 incfile = filefind(incfilename,incpath)
82 incfile = filefind(incfilename,incpath)
83 except IOError:
83 except IOError:
84 if os.name in ['nt','dos']:
84 if os.name in ['nt','dos']:
85 try:
85 try:
86 # Try again with '.ini' extension
86 # Try again with '.ini' extension
87 incfilename += '.ini'
87 incfilename += '.ini'
88 incfile = filefind(incfilename,incpath)
88 incfile = filefind(incfilename,incpath)
89 except IOError:
89 except IOError:
90 found = 0
90 found = 0
91 else:
91 else:
92 found = 1
92 found = 1
93 else:
93 else:
94 found = 0
94 found = 0
95 else:
95 else:
96 found = 1
96 found = 1
97 if found:
97 if found:
98 try:
98 try:
99 data.merge(self.load(incfile,convert,recurse_key,
99 data.merge(self.load(incfile,convert,recurse_key,
100 incpath,**kw),
100 incpath,**kw),
101 self.conflict)
101 self.conflict)
102 except:
102 except:
103 Xinfo()
103 Xinfo()
104 warn('Problem loading included file: '+
104 warn('Problem loading included file: '+
105 `incfilename` + '. Ignoring it...')
105 `incfilename` + '. Ignoring it...')
106 else:
106 else:
107 warn('File `%s` not found. Included by %s' % (incfilename,fname))
107 warn('File `%s` not found. Included by %s' % (incfilename,fname))
108
108
109 return data
109 return data
110
110
111 # end ConfigLoader
111 # end ConfigLoader
@@ -1,639 +1,639 b''
1 """Word completion for IPython.
1 """Word completion for IPython.
2
2
3 This module is a fork of the rlcompleter module in the Python standard
3 This module is a fork of the rlcompleter module in the Python standard
4 library. The original enhancements made to rlcompleter have been sent
4 library. The original enhancements made to rlcompleter have been sent
5 upstream and were accepted as of Python 2.3, but we need a lot more
5 upstream and were accepted as of Python 2.3, but we need a lot more
6 functionality specific to IPython, so this module will continue to live as an
6 functionality specific to IPython, so this module will continue to live as an
7 IPython-specific utility.
7 IPython-specific utility.
8
8
9 Original rlcompleter documentation:
9 Original rlcompleter documentation:
10
10
11 This requires the latest extension to the readline module (the
11 This requires the latest extension to the readline module (the
12 completes keywords, built-ins and globals in __main__; when completing
12 completes keywords, built-ins and globals in __main__; when completing
13 NAME.NAME..., it evaluates (!) the expression up to the last dot and
13 NAME.NAME..., it evaluates (!) the expression up to the last dot and
14 completes its attributes.
14 completes its attributes.
15
15
16 It's very cool to do "import string" type "string.", hit the
16 It's very cool to do "import string" type "string.", hit the
17 completion key (twice), and see the list of names defined by the
17 completion key (twice), and see the list of names defined by the
18 string module!
18 string module!
19
19
20 Tip: to use the tab key as the completion key, call
20 Tip: to use the tab key as the completion key, call
21
21
22 readline.parse_and_bind("tab: complete")
22 readline.parse_and_bind("tab: complete")
23
23
24 Notes:
24 Notes:
25
25
26 - Exceptions raised by the completer function are *ignored* (and
26 - Exceptions raised by the completer function are *ignored* (and
27 generally cause the completion to fail). This is a feature -- since
27 generally cause the completion to fail). This is a feature -- since
28 readline sets the tty device in raw (or cbreak) mode, printing a
28 readline sets the tty device in raw (or cbreak) mode, printing a
29 traceback wouldn't work well without some complicated hoopla to save,
29 traceback wouldn't work well without some complicated hoopla to save,
30 reset and restore the tty state.
30 reset and restore the tty state.
31
31
32 - The evaluation of the NAME.NAME... form may cause arbitrary
32 - The evaluation of the NAME.NAME... form may cause arbitrary
33 application defined code to be executed if an object with a
33 application defined code to be executed if an object with a
34 __getattr__ hook is found. Since it is the responsibility of the
34 __getattr__ hook is found. Since it is the responsibility of the
35 application (or the user) to enable this feature, I consider this an
35 application (or the user) to enable this feature, I consider this an
36 acceptable risk. More complicated expressions (e.g. function calls or
36 acceptable risk. More complicated expressions (e.g. function calls or
37 indexing operations) are *not* evaluated.
37 indexing operations) are *not* evaluated.
38
38
39 - GNU readline is also used by the built-in functions input() and
39 - GNU readline is also used by the built-in functions input() and
40 raw_input(), and thus these also benefit/suffer from the completer
40 raw_input(), and thus these also benefit/suffer from the completer
41 features. Clearly an interactive application can benefit by
41 features. Clearly an interactive application can benefit by
42 specifying its own completer function and using raw_input() for all
42 specifying its own completer function and using raw_input() for all
43 its input.
43 its input.
44
44
45 - When the original stdin is not a tty device, GNU readline is never
45 - When the original stdin is not a tty device, GNU readline is never
46 used, and this module (and the readline module) are silently inactive.
46 used, and this module (and the readline module) are silently inactive.
47
47
48 """
48 """
49
49
50 #*****************************************************************************
50 #*****************************************************************************
51 #
51 #
52 # Since this file is essentially a minimally modified copy of the rlcompleter
52 # Since this file is essentially a minimally modified copy of the rlcompleter
53 # module which is part of the standard Python distribution, I assume that the
53 # module which is part of the standard Python distribution, I assume that the
54 # proper procedure is to maintain its copyright as belonging to the Python
54 # proper procedure is to maintain its copyright as belonging to the Python
55 # Software Foundation (in addition to my own, for all new code).
55 # Software Foundation (in addition to my own, for all new code).
56 #
56 #
57 # Copyright (C) 2001 Python Software Foundation, www.python.org
57 # Copyright (C) 2001 Python Software Foundation, www.python.org
58 # Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
58 # Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
59 #
59 #
60 # Distributed under the terms of the BSD License. The full license is in
60 # Distributed under the terms of the BSD License. The full license is in
61 # the file COPYING, distributed as part of this software.
61 # the file COPYING, distributed as part of this software.
62 #
62 #
63 #*****************************************************************************
63 #*****************************************************************************
64
64
65 import __builtin__
65 import __builtin__
66 import __main__
66 import __main__
67 import glob
67 import glob
68 import keyword
68 import keyword
69 import os
69 import os
70 import re
70 import re
71 import shlex
71 import shlex
72 import sys
72 import sys
73 import IPython.rlineimpl as readline
73 import IPython.rlineimpl as readline
74 import itertools
74 import itertools
75 from IPython.ipstruct import Struct
75 from IPython.ipstruct import Struct
76 from IPython import ipapi
76 from IPython import ipapi
77 from IPython.utils import generics
77 from IPython.utils import generics
78 import types
78 import types
79
79
80 # Python 2.4 offers sets as a builtin
80 # Python 2.4 offers sets as a builtin
81 try:
81 try:
82 set()
82 set()
83 except NameError:
83 except NameError:
84 from sets import Set as set
84 from sets import Set as set
85
85
86 from IPython.genutils import debugx, dir2
86 from IPython.utils.genutils import debugx, dir2
87
87
88 __all__ = ['Completer','IPCompleter']
88 __all__ = ['Completer','IPCompleter']
89
89
90 class Completer:
90 class Completer:
91 def __init__(self,namespace=None,global_namespace=None):
91 def __init__(self,namespace=None,global_namespace=None):
92 """Create a new completer for the command line.
92 """Create a new completer for the command line.
93
93
94 Completer([namespace,global_namespace]) -> completer instance.
94 Completer([namespace,global_namespace]) -> completer instance.
95
95
96 If unspecified, the default namespace where completions are performed
96 If unspecified, the default namespace where completions are performed
97 is __main__ (technically, __main__.__dict__). Namespaces should be
97 is __main__ (technically, __main__.__dict__). Namespaces should be
98 given as dictionaries.
98 given as dictionaries.
99
99
100 An optional second namespace can be given. This allows the completer
100 An optional second namespace can be given. This allows the completer
101 to handle cases where both the local and global scopes need to be
101 to handle cases where both the local and global scopes need to be
102 distinguished.
102 distinguished.
103
103
104 Completer instances should be used as the completion mechanism of
104 Completer instances should be used as the completion mechanism of
105 readline via the set_completer() call:
105 readline via the set_completer() call:
106
106
107 readline.set_completer(Completer(my_namespace).complete)
107 readline.set_completer(Completer(my_namespace).complete)
108 """
108 """
109
109
110 # Don't bind to namespace quite yet, but flag whether the user wants a
110 # Don't bind to namespace quite yet, but flag whether the user wants a
111 # specific namespace or to use __main__.__dict__. This will allow us
111 # specific namespace or to use __main__.__dict__. This will allow us
112 # to bind to __main__.__dict__ at completion time, not now.
112 # to bind to __main__.__dict__ at completion time, not now.
113 if namespace is None:
113 if namespace is None:
114 self.use_main_ns = 1
114 self.use_main_ns = 1
115 else:
115 else:
116 self.use_main_ns = 0
116 self.use_main_ns = 0
117 self.namespace = namespace
117 self.namespace = namespace
118
118
119 # The global namespace, if given, can be bound directly
119 # The global namespace, if given, can be bound directly
120 if global_namespace is None:
120 if global_namespace is None:
121 self.global_namespace = {}
121 self.global_namespace = {}
122 else:
122 else:
123 self.global_namespace = global_namespace
123 self.global_namespace = global_namespace
124
124
125 def complete(self, text, state):
125 def complete(self, text, state):
126 """Return the next possible completion for 'text'.
126 """Return the next possible completion for 'text'.
127
127
128 This is called successively with state == 0, 1, 2, ... until it
128 This is called successively with state == 0, 1, 2, ... until it
129 returns None. The completion should begin with 'text'.
129 returns None. The completion should begin with 'text'.
130
130
131 """
131 """
132 if self.use_main_ns:
132 if self.use_main_ns:
133 self.namespace = __main__.__dict__
133 self.namespace = __main__.__dict__
134
134
135 if state == 0:
135 if state == 0:
136 if "." in text:
136 if "." in text:
137 self.matches = self.attr_matches(text)
137 self.matches = self.attr_matches(text)
138 else:
138 else:
139 self.matches = self.global_matches(text)
139 self.matches = self.global_matches(text)
140 try:
140 try:
141 return self.matches[state]
141 return self.matches[state]
142 except IndexError:
142 except IndexError:
143 return None
143 return None
144
144
145 def global_matches(self, text):
145 def global_matches(self, text):
146 """Compute matches when text is a simple name.
146 """Compute matches when text is a simple name.
147
147
148 Return a list of all keywords, built-in functions and names currently
148 Return a list of all keywords, built-in functions and names currently
149 defined in self.namespace or self.global_namespace that match.
149 defined in self.namespace or self.global_namespace that match.
150
150
151 """
151 """
152 matches = []
152 matches = []
153 match_append = matches.append
153 match_append = matches.append
154 n = len(text)
154 n = len(text)
155 for lst in [keyword.kwlist,
155 for lst in [keyword.kwlist,
156 __builtin__.__dict__.keys(),
156 __builtin__.__dict__.keys(),
157 self.namespace.keys(),
157 self.namespace.keys(),
158 self.global_namespace.keys()]:
158 self.global_namespace.keys()]:
159 for word in lst:
159 for word in lst:
160 if word[:n] == text and word != "__builtins__":
160 if word[:n] == text and word != "__builtins__":
161 match_append(word)
161 match_append(word)
162 return matches
162 return matches
163
163
164 def attr_matches(self, text):
164 def attr_matches(self, text):
165 """Compute matches when text contains a dot.
165 """Compute matches when text contains a dot.
166
166
167 Assuming the text is of the form NAME.NAME....[NAME], and is
167 Assuming the text is of the form NAME.NAME....[NAME], and is
168 evaluatable in self.namespace or self.global_namespace, it will be
168 evaluatable in self.namespace or self.global_namespace, it will be
169 evaluated and its attributes (as revealed by dir()) are used as
169 evaluated and its attributes (as revealed by dir()) are used as
170 possible completions. (For class instances, class members are are
170 possible completions. (For class instances, class members are are
171 also considered.)
171 also considered.)
172
172
173 WARNING: this can still invoke arbitrary C code, if an object
173 WARNING: this can still invoke arbitrary C code, if an object
174 with a __getattr__ hook is evaluated.
174 with a __getattr__ hook is evaluated.
175
175
176 """
176 """
177 import re
177 import re
178
178
179 # Another option, seems to work great. Catches things like ''.<tab>
179 # Another option, seems to work great. Catches things like ''.<tab>
180 m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
180 m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
181
181
182 if not m:
182 if not m:
183 return []
183 return []
184
184
185 expr, attr = m.group(1, 3)
185 expr, attr = m.group(1, 3)
186 try:
186 try:
187 obj = eval(expr, self.namespace)
187 obj = eval(expr, self.namespace)
188 except:
188 except:
189 try:
189 try:
190 obj = eval(expr, self.global_namespace)
190 obj = eval(expr, self.global_namespace)
191 except:
191 except:
192 return []
192 return []
193
193
194 words = dir2(obj)
194 words = dir2(obj)
195
195
196 try:
196 try:
197 words = generics.complete_object(obj, words)
197 words = generics.complete_object(obj, words)
198 except ipapi.TryNext:
198 except ipapi.TryNext:
199 pass
199 pass
200 # Build match list to return
200 # Build match list to return
201 n = len(attr)
201 n = len(attr)
202 res = ["%s.%s" % (expr, w) for w in words if w[:n] == attr ]
202 res = ["%s.%s" % (expr, w) for w in words if w[:n] == attr ]
203 return res
203 return res
204
204
205 class IPCompleter(Completer):
205 class IPCompleter(Completer):
206 """Extension of the completer class with IPython-specific features"""
206 """Extension of the completer class with IPython-specific features"""
207
207
208 def __init__(self,shell,namespace=None,global_namespace=None,
208 def __init__(self,shell,namespace=None,global_namespace=None,
209 omit__names=0,alias_table=None):
209 omit__names=0,alias_table=None):
210 """IPCompleter() -> completer
210 """IPCompleter() -> completer
211
211
212 Return a completer object suitable for use by the readline library
212 Return a completer object suitable for use by the readline library
213 via readline.set_completer().
213 via readline.set_completer().
214
214
215 Inputs:
215 Inputs:
216
216
217 - shell: a pointer to the ipython shell itself. This is needed
217 - shell: a pointer to the ipython shell itself. This is needed
218 because this completer knows about magic functions, and those can
218 because this completer knows about magic functions, and those can
219 only be accessed via the ipython instance.
219 only be accessed via the ipython instance.
220
220
221 - namespace: an optional dict where completions are performed.
221 - namespace: an optional dict where completions are performed.
222
222
223 - global_namespace: secondary optional dict for completions, to
223 - global_namespace: secondary optional dict for completions, to
224 handle cases (such as IPython embedded inside functions) where
224 handle cases (such as IPython embedded inside functions) where
225 both Python scopes are visible.
225 both Python scopes are visible.
226
226
227 - The optional omit__names parameter sets the completer to omit the
227 - The optional omit__names parameter sets the completer to omit the
228 'magic' names (__magicname__) for python objects unless the text
228 'magic' names (__magicname__) for python objects unless the text
229 to be completed explicitly starts with one or more underscores.
229 to be completed explicitly starts with one or more underscores.
230
230
231 - If alias_table is supplied, it should be a dictionary of aliases
231 - If alias_table is supplied, it should be a dictionary of aliases
232 to complete. """
232 to complete. """
233
233
234 Completer.__init__(self,namespace,global_namespace)
234 Completer.__init__(self,namespace,global_namespace)
235 self.magic_prefix = shell.name+'.magic_'
235 self.magic_prefix = shell.name+'.magic_'
236 self.magic_escape = shell.ESC_MAGIC
236 self.magic_escape = shell.ESC_MAGIC
237 self.readline = readline
237 self.readline = readline
238 delims = self.readline.get_completer_delims()
238 delims = self.readline.get_completer_delims()
239 delims = delims.replace(self.magic_escape,'')
239 delims = delims.replace(self.magic_escape,'')
240 self.readline.set_completer_delims(delims)
240 self.readline.set_completer_delims(delims)
241 self.get_line_buffer = self.readline.get_line_buffer
241 self.get_line_buffer = self.readline.get_line_buffer
242 self.get_endidx = self.readline.get_endidx
242 self.get_endidx = self.readline.get_endidx
243 self.omit__names = omit__names
243 self.omit__names = omit__names
244 self.merge_completions = shell.rc.readline_merge_completions
244 self.merge_completions = shell.rc.readline_merge_completions
245 if alias_table is None:
245 if alias_table is None:
246 alias_table = {}
246 alias_table = {}
247 self.alias_table = alias_table
247 self.alias_table = alias_table
248 # Regexp to split filenames with spaces in them
248 # Regexp to split filenames with spaces in them
249 self.space_name_re = re.compile(r'([^\\] )')
249 self.space_name_re = re.compile(r'([^\\] )')
250 # Hold a local ref. to glob.glob for speed
250 # Hold a local ref. to glob.glob for speed
251 self.glob = glob.glob
251 self.glob = glob.glob
252
252
253 # Determine if we are running on 'dumb' terminals, like (X)Emacs
253 # Determine if we are running on 'dumb' terminals, like (X)Emacs
254 # buffers, to avoid completion problems.
254 # buffers, to avoid completion problems.
255 term = os.environ.get('TERM','xterm')
255 term = os.environ.get('TERM','xterm')
256 self.dumb_terminal = term in ['dumb','emacs']
256 self.dumb_terminal = term in ['dumb','emacs']
257
257
258 # Special handling of backslashes needed in win32 platforms
258 # Special handling of backslashes needed in win32 platforms
259 if sys.platform == "win32":
259 if sys.platform == "win32":
260 self.clean_glob = self._clean_glob_win32
260 self.clean_glob = self._clean_glob_win32
261 else:
261 else:
262 self.clean_glob = self._clean_glob
262 self.clean_glob = self._clean_glob
263 self.matchers = [self.python_matches,
263 self.matchers = [self.python_matches,
264 self.file_matches,
264 self.file_matches,
265 self.alias_matches,
265 self.alias_matches,
266 self.python_func_kw_matches]
266 self.python_func_kw_matches]
267
267
268
268
269 # Code contributed by Alex Schmolck, for ipython/emacs integration
269 # Code contributed by Alex Schmolck, for ipython/emacs integration
270 def all_completions(self, text):
270 def all_completions(self, text):
271 """Return all possible completions for the benefit of emacs."""
271 """Return all possible completions for the benefit of emacs."""
272
272
273 completions = []
273 completions = []
274 comp_append = completions.append
274 comp_append = completions.append
275 try:
275 try:
276 for i in xrange(sys.maxint):
276 for i in xrange(sys.maxint):
277 res = self.complete(text, i)
277 res = self.complete(text, i)
278
278
279 if not res: break
279 if not res: break
280
280
281 comp_append(res)
281 comp_append(res)
282 #XXX workaround for ``notDefined.<tab>``
282 #XXX workaround for ``notDefined.<tab>``
283 except NameError:
283 except NameError:
284 pass
284 pass
285 return completions
285 return completions
286 # /end Alex Schmolck code.
286 # /end Alex Schmolck code.
287
287
288 def _clean_glob(self,text):
288 def _clean_glob(self,text):
289 return self.glob("%s*" % text)
289 return self.glob("%s*" % text)
290
290
291 def _clean_glob_win32(self,text):
291 def _clean_glob_win32(self,text):
292 return [f.replace("\\","/")
292 return [f.replace("\\","/")
293 for f in self.glob("%s*" % text)]
293 for f in self.glob("%s*" % text)]
294
294
295 def file_matches(self, text):
295 def file_matches(self, text):
296 """Match filenames, expanding ~USER type strings.
296 """Match filenames, expanding ~USER type strings.
297
297
298 Most of the seemingly convoluted logic in this completer is an
298 Most of the seemingly convoluted logic in this completer is an
299 attempt to handle filenames with spaces in them. And yet it's not
299 attempt to handle filenames with spaces in them. And yet it's not
300 quite perfect, because Python's readline doesn't expose all of the
300 quite perfect, because Python's readline doesn't expose all of the
301 GNU readline details needed for this to be done correctly.
301 GNU readline details needed for this to be done correctly.
302
302
303 For a filename with a space in it, the printed completions will be
303 For a filename with a space in it, the printed completions will be
304 only the parts after what's already been typed (instead of the
304 only the parts after what's already been typed (instead of the
305 full completions, as is normally done). I don't think with the
305 full completions, as is normally done). I don't think with the
306 current (as of Python 2.3) Python readline it's possible to do
306 current (as of Python 2.3) Python readline it's possible to do
307 better."""
307 better."""
308
308
309 #print 'Completer->file_matches: <%s>' % text # dbg
309 #print 'Completer->file_matches: <%s>' % text # dbg
310
310
311 # chars that require escaping with backslash - i.e. chars
311 # chars that require escaping with backslash - i.e. chars
312 # that readline treats incorrectly as delimiters, but we
312 # that readline treats incorrectly as delimiters, but we
313 # don't want to treat as delimiters in filename matching
313 # don't want to treat as delimiters in filename matching
314 # when escaped with backslash
314 # when escaped with backslash
315
315
316 if sys.platform == 'win32':
316 if sys.platform == 'win32':
317 protectables = ' '
317 protectables = ' '
318 else:
318 else:
319 protectables = ' ()'
319 protectables = ' ()'
320
320
321 if text.startswith('!'):
321 if text.startswith('!'):
322 text = text[1:]
322 text = text[1:]
323 text_prefix = '!'
323 text_prefix = '!'
324 else:
324 else:
325 text_prefix = ''
325 text_prefix = ''
326
326
327 def protect_filename(s):
327 def protect_filename(s):
328 return "".join([(ch in protectables and '\\' + ch or ch)
328 return "".join([(ch in protectables and '\\' + ch or ch)
329 for ch in s])
329 for ch in s])
330
330
331 def single_dir_expand(matches):
331 def single_dir_expand(matches):
332 "Recursively expand match lists containing a single dir."
332 "Recursively expand match lists containing a single dir."
333
333
334 if len(matches) == 1 and os.path.isdir(matches[0]):
334 if len(matches) == 1 and os.path.isdir(matches[0]):
335 # Takes care of links to directories also. Use '/'
335 # Takes care of links to directories also. Use '/'
336 # explicitly, even under Windows, so that name completions
336 # explicitly, even under Windows, so that name completions
337 # don't end up escaped.
337 # don't end up escaped.
338 d = matches[0]
338 d = matches[0]
339 if d[-1] in ['/','\\']:
339 if d[-1] in ['/','\\']:
340 d = d[:-1]
340 d = d[:-1]
341
341
342 subdirs = os.listdir(d)
342 subdirs = os.listdir(d)
343 if subdirs:
343 if subdirs:
344 matches = [ (d + '/' + p) for p in subdirs]
344 matches = [ (d + '/' + p) for p in subdirs]
345 return single_dir_expand(matches)
345 return single_dir_expand(matches)
346 else:
346 else:
347 return matches
347 return matches
348 else:
348 else:
349 return matches
349 return matches
350
350
351 lbuf = self.lbuf
351 lbuf = self.lbuf
352 open_quotes = 0 # track strings with open quotes
352 open_quotes = 0 # track strings with open quotes
353 try:
353 try:
354 lsplit = shlex.split(lbuf)[-1]
354 lsplit = shlex.split(lbuf)[-1]
355 except ValueError:
355 except ValueError:
356 # typically an unmatched ", or backslash without escaped char.
356 # typically an unmatched ", or backslash without escaped char.
357 if lbuf.count('"')==1:
357 if lbuf.count('"')==1:
358 open_quotes = 1
358 open_quotes = 1
359 lsplit = lbuf.split('"')[-1]
359 lsplit = lbuf.split('"')[-1]
360 elif lbuf.count("'")==1:
360 elif lbuf.count("'")==1:
361 open_quotes = 1
361 open_quotes = 1
362 lsplit = lbuf.split("'")[-1]
362 lsplit = lbuf.split("'")[-1]
363 else:
363 else:
364 return []
364 return []
365 except IndexError:
365 except IndexError:
366 # tab pressed on empty line
366 # tab pressed on empty line
367 lsplit = ""
367 lsplit = ""
368
368
369 if lsplit != protect_filename(lsplit):
369 if lsplit != protect_filename(lsplit):
370 # if protectables are found, do matching on the whole escaped
370 # if protectables are found, do matching on the whole escaped
371 # name
371 # name
372 has_protectables = 1
372 has_protectables = 1
373 text0,text = text,lsplit
373 text0,text = text,lsplit
374 else:
374 else:
375 has_protectables = 0
375 has_protectables = 0
376 text = os.path.expanduser(text)
376 text = os.path.expanduser(text)
377
377
378 if text == "":
378 if text == "":
379 return [text_prefix + protect_filename(f) for f in self.glob("*")]
379 return [text_prefix + protect_filename(f) for f in self.glob("*")]
380
380
381 m0 = self.clean_glob(text.replace('\\',''))
381 m0 = self.clean_glob(text.replace('\\',''))
382 if has_protectables:
382 if has_protectables:
383 # If we had protectables, we need to revert our changes to the
383 # If we had protectables, we need to revert our changes to the
384 # beginning of filename so that we don't double-write the part
384 # beginning of filename so that we don't double-write the part
385 # of the filename we have so far
385 # of the filename we have so far
386 len_lsplit = len(lsplit)
386 len_lsplit = len(lsplit)
387 matches = [text_prefix + text0 +
387 matches = [text_prefix + text0 +
388 protect_filename(f[len_lsplit:]) for f in m0]
388 protect_filename(f[len_lsplit:]) for f in m0]
389 else:
389 else:
390 if open_quotes:
390 if open_quotes:
391 # if we have a string with an open quote, we don't need to
391 # if we have a string with an open quote, we don't need to
392 # protect the names at all (and we _shouldn't_, as it
392 # protect the names at all (and we _shouldn't_, as it
393 # would cause bugs when the filesystem call is made).
393 # would cause bugs when the filesystem call is made).
394 matches = m0
394 matches = m0
395 else:
395 else:
396 matches = [text_prefix +
396 matches = [text_prefix +
397 protect_filename(f) for f in m0]
397 protect_filename(f) for f in m0]
398
398
399 #print 'mm',matches # dbg
399 #print 'mm',matches # dbg
400 return single_dir_expand(matches)
400 return single_dir_expand(matches)
401
401
402 def alias_matches(self, text):
402 def alias_matches(self, text):
403 """Match internal system aliases"""
403 """Match internal system aliases"""
404 #print 'Completer->alias_matches:',text,'lb',self.lbuf # dbg
404 #print 'Completer->alias_matches:',text,'lb',self.lbuf # dbg
405
405
406 # if we are not in the first 'item', alias matching
406 # if we are not in the first 'item', alias matching
407 # doesn't make sense - unless we are starting with 'sudo' command.
407 # doesn't make sense - unless we are starting with 'sudo' command.
408 if ' ' in self.lbuf.lstrip() and not self.lbuf.lstrip().startswith('sudo'):
408 if ' ' in self.lbuf.lstrip() and not self.lbuf.lstrip().startswith('sudo'):
409 return []
409 return []
410 text = os.path.expanduser(text)
410 text = os.path.expanduser(text)
411 aliases = self.alias_table.keys()
411 aliases = self.alias_table.keys()
412 if text == "":
412 if text == "":
413 return aliases
413 return aliases
414 else:
414 else:
415 return [alias for alias in aliases if alias.startswith(text)]
415 return [alias for alias in aliases if alias.startswith(text)]
416
416
417 def python_matches(self,text):
417 def python_matches(self,text):
418 """Match attributes or global python names"""
418 """Match attributes or global python names"""
419
419
420 #print 'Completer->python_matches, txt=<%s>' % text # dbg
420 #print 'Completer->python_matches, txt=<%s>' % text # dbg
421 if "." in text:
421 if "." in text:
422 try:
422 try:
423 matches = self.attr_matches(text)
423 matches = self.attr_matches(text)
424 if text.endswith('.') and self.omit__names:
424 if text.endswith('.') and self.omit__names:
425 if self.omit__names == 1:
425 if self.omit__names == 1:
426 # true if txt is _not_ a __ name, false otherwise:
426 # true if txt is _not_ a __ name, false otherwise:
427 no__name = (lambda txt:
427 no__name = (lambda txt:
428 re.match(r'.*\.__.*?__',txt) is None)
428 re.match(r'.*\.__.*?__',txt) is None)
429 else:
429 else:
430 # true if txt is _not_ a _ name, false otherwise:
430 # true if txt is _not_ a _ name, false otherwise:
431 no__name = (lambda txt:
431 no__name = (lambda txt:
432 re.match(r'.*\._.*?',txt) is None)
432 re.match(r'.*\._.*?',txt) is None)
433 matches = filter(no__name, matches)
433 matches = filter(no__name, matches)
434 except NameError:
434 except NameError:
435 # catches <undefined attributes>.<tab>
435 # catches <undefined attributes>.<tab>
436 matches = []
436 matches = []
437 else:
437 else:
438 matches = self.global_matches(text)
438 matches = self.global_matches(text)
439 # this is so completion finds magics when automagic is on:
439 # this is so completion finds magics when automagic is on:
440 if (matches == [] and
440 if (matches == [] and
441 not text.startswith(os.sep) and
441 not text.startswith(os.sep) and
442 not ' ' in self.lbuf):
442 not ' ' in self.lbuf):
443 matches = self.attr_matches(self.magic_prefix+text)
443 matches = self.attr_matches(self.magic_prefix+text)
444 return matches
444 return matches
445
445
446 def _default_arguments(self, obj):
446 def _default_arguments(self, obj):
447 """Return the list of default arguments of obj if it is callable,
447 """Return the list of default arguments of obj if it is callable,
448 or empty list otherwise."""
448 or empty list otherwise."""
449
449
450 if not (inspect.isfunction(obj) or inspect.ismethod(obj)):
450 if not (inspect.isfunction(obj) or inspect.ismethod(obj)):
451 # for classes, check for __init__,__new__
451 # for classes, check for __init__,__new__
452 if inspect.isclass(obj):
452 if inspect.isclass(obj):
453 obj = (getattr(obj,'__init__',None) or
453 obj = (getattr(obj,'__init__',None) or
454 getattr(obj,'__new__',None))
454 getattr(obj,'__new__',None))
455 # for all others, check if they are __call__able
455 # for all others, check if they are __call__able
456 elif hasattr(obj, '__call__'):
456 elif hasattr(obj, '__call__'):
457 obj = obj.__call__
457 obj = obj.__call__
458 # XXX: is there a way to handle the builtins ?
458 # XXX: is there a way to handle the builtins ?
459 try:
459 try:
460 args,_,_1,defaults = inspect.getargspec(obj)
460 args,_,_1,defaults = inspect.getargspec(obj)
461 if defaults:
461 if defaults:
462 return args[-len(defaults):]
462 return args[-len(defaults):]
463 except TypeError: pass
463 except TypeError: pass
464 return []
464 return []
465
465
466 def python_func_kw_matches(self,text):
466 def python_func_kw_matches(self,text):
467 """Match named parameters (kwargs) of the last open function"""
467 """Match named parameters (kwargs) of the last open function"""
468
468
469 if "." in text: # a parameter cannot be dotted
469 if "." in text: # a parameter cannot be dotted
470 return []
470 return []
471 try: regexp = self.__funcParamsRegex
471 try: regexp = self.__funcParamsRegex
472 except AttributeError:
472 except AttributeError:
473 regexp = self.__funcParamsRegex = re.compile(r'''
473 regexp = self.__funcParamsRegex = re.compile(r'''
474 '.*?' | # single quoted strings or
474 '.*?' | # single quoted strings or
475 ".*?" | # double quoted strings or
475 ".*?" | # double quoted strings or
476 \w+ | # identifier
476 \w+ | # identifier
477 \S # other characters
477 \S # other characters
478 ''', re.VERBOSE | re.DOTALL)
478 ''', re.VERBOSE | re.DOTALL)
479 # 1. find the nearest identifier that comes before an unclosed
479 # 1. find the nearest identifier that comes before an unclosed
480 # parenthesis e.g. for "foo (1+bar(x), pa", the candidate is "foo"
480 # parenthesis e.g. for "foo (1+bar(x), pa", the candidate is "foo"
481 tokens = regexp.findall(self.get_line_buffer())
481 tokens = regexp.findall(self.get_line_buffer())
482 tokens.reverse()
482 tokens.reverse()
483 iterTokens = iter(tokens); openPar = 0
483 iterTokens = iter(tokens); openPar = 0
484 for token in iterTokens:
484 for token in iterTokens:
485 if token == ')':
485 if token == ')':
486 openPar -= 1
486 openPar -= 1
487 elif token == '(':
487 elif token == '(':
488 openPar += 1
488 openPar += 1
489 if openPar > 0:
489 if openPar > 0:
490 # found the last unclosed parenthesis
490 # found the last unclosed parenthesis
491 break
491 break
492 else:
492 else:
493 return []
493 return []
494 # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
494 # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
495 ids = []
495 ids = []
496 isId = re.compile(r'\w+$').match
496 isId = re.compile(r'\w+$').match
497 while True:
497 while True:
498 try:
498 try:
499 ids.append(iterTokens.next())
499 ids.append(iterTokens.next())
500 if not isId(ids[-1]):
500 if not isId(ids[-1]):
501 ids.pop(); break
501 ids.pop(); break
502 if not iterTokens.next() == '.':
502 if not iterTokens.next() == '.':
503 break
503 break
504 except StopIteration:
504 except StopIteration:
505 break
505 break
506 # lookup the candidate callable matches either using global_matches
506 # lookup the candidate callable matches either using global_matches
507 # or attr_matches for dotted names
507 # or attr_matches for dotted names
508 if len(ids) == 1:
508 if len(ids) == 1:
509 callableMatches = self.global_matches(ids[0])
509 callableMatches = self.global_matches(ids[0])
510 else:
510 else:
511 callableMatches = self.attr_matches('.'.join(ids[::-1]))
511 callableMatches = self.attr_matches('.'.join(ids[::-1]))
512 argMatches = []
512 argMatches = []
513 for callableMatch in callableMatches:
513 for callableMatch in callableMatches:
514 try: namedArgs = self._default_arguments(eval(callableMatch,
514 try: namedArgs = self._default_arguments(eval(callableMatch,
515 self.namespace))
515 self.namespace))
516 except: continue
516 except: continue
517 for namedArg in namedArgs:
517 for namedArg in namedArgs:
518 if namedArg.startswith(text):
518 if namedArg.startswith(text):
519 argMatches.append("%s=" %namedArg)
519 argMatches.append("%s=" %namedArg)
520 return argMatches
520 return argMatches
521
521
522 def dispatch_custom_completer(self,text):
522 def dispatch_custom_completer(self,text):
523 #print "Custom! '%s' %s" % (text, self.custom_completers) # dbg
523 #print "Custom! '%s' %s" % (text, self.custom_completers) # dbg
524 line = self.full_lbuf
524 line = self.full_lbuf
525 if not line.strip():
525 if not line.strip():
526 return None
526 return None
527
527
528 event = Struct()
528 event = Struct()
529 event.line = line
529 event.line = line
530 event.symbol = text
530 event.symbol = text
531 cmd = line.split(None,1)[0]
531 cmd = line.split(None,1)[0]
532 event.command = cmd
532 event.command = cmd
533 #print "\ncustom:{%s]\n" % event # dbg
533 #print "\ncustom:{%s]\n" % event # dbg
534
534
535 # for foo etc, try also to find completer for %foo
535 # for foo etc, try also to find completer for %foo
536 if not cmd.startswith(self.magic_escape):
536 if not cmd.startswith(self.magic_escape):
537 try_magic = self.custom_completers.s_matches(
537 try_magic = self.custom_completers.s_matches(
538 self.magic_escape + cmd)
538 self.magic_escape + cmd)
539 else:
539 else:
540 try_magic = []
540 try_magic = []
541
541
542
542
543 for c in itertools.chain(
543 for c in itertools.chain(
544 self.custom_completers.s_matches(cmd),
544 self.custom_completers.s_matches(cmd),
545 try_magic,
545 try_magic,
546 self.custom_completers.flat_matches(self.lbuf)):
546 self.custom_completers.flat_matches(self.lbuf)):
547 #print "try",c # dbg
547 #print "try",c # dbg
548 try:
548 try:
549 res = c(event)
549 res = c(event)
550 # first, try case sensitive match
550 # first, try case sensitive match
551 withcase = [r for r in res if r.startswith(text)]
551 withcase = [r for r in res if r.startswith(text)]
552 if withcase:
552 if withcase:
553 return withcase
553 return withcase
554 # if none, then case insensitive ones are ok too
554 # if none, then case insensitive ones are ok too
555 return [r for r in res if r.lower().startswith(text.lower())]
555 return [r for r in res if r.lower().startswith(text.lower())]
556 except ipapi.TryNext:
556 except ipapi.TryNext:
557 pass
557 pass
558
558
559 return None
559 return None
560
560
561 def complete(self, text, state,line_buffer=None):
561 def complete(self, text, state,line_buffer=None):
562 """Return the next possible completion for 'text'.
562 """Return the next possible completion for 'text'.
563
563
564 This is called successively with state == 0, 1, 2, ... until it
564 This is called successively with state == 0, 1, 2, ... until it
565 returns None. The completion should begin with 'text'.
565 returns None. The completion should begin with 'text'.
566
566
567 :Keywords:
567 :Keywords:
568 - line_buffer: string
568 - line_buffer: string
569 If not given, the completer attempts to obtain the current line buffer
569 If not given, the completer attempts to obtain the current line buffer
570 via readline. This keyword allows clients which are requesting for
570 via readline. This keyword allows clients which are requesting for
571 text completions in non-readline contexts to inform the completer of
571 text completions in non-readline contexts to inform the completer of
572 the entire text.
572 the entire text.
573 """
573 """
574
574
575 #print '\n*** COMPLETE: <%s> (%s)' % (text,state) # dbg
575 #print '\n*** COMPLETE: <%s> (%s)' % (text,state) # dbg
576
576
577 # if there is only a tab on a line with only whitespace, instead
577 # if there is only a tab on a line with only whitespace, instead
578 # of the mostly useless 'do you want to see all million
578 # of the mostly useless 'do you want to see all million
579 # completions' message, just do the right thing and give the user
579 # completions' message, just do the right thing and give the user
580 # his tab! Incidentally, this enables pasting of tabbed text from
580 # his tab! Incidentally, this enables pasting of tabbed text from
581 # an editor (as long as autoindent is off).
581 # an editor (as long as autoindent is off).
582
582
583 # It should be noted that at least pyreadline still shows
583 # It should be noted that at least pyreadline still shows
584 # file completions - is there a way around it?
584 # file completions - is there a way around it?
585
585
586 # don't apply this on 'dumb' terminals, such as emacs buffers, so we
586 # don't apply this on 'dumb' terminals, such as emacs buffers, so we
587 # don't interfere with their own tab-completion mechanism.
587 # don't interfere with their own tab-completion mechanism.
588 if line_buffer is None:
588 if line_buffer is None:
589 self.full_lbuf = self.get_line_buffer()
589 self.full_lbuf = self.get_line_buffer()
590 else:
590 else:
591 self.full_lbuf = line_buffer
591 self.full_lbuf = line_buffer
592
592
593 if not (self.dumb_terminal or self.full_lbuf.strip()):
593 if not (self.dumb_terminal or self.full_lbuf.strip()):
594 self.readline.insert_text('\t')
594 self.readline.insert_text('\t')
595 return None
595 return None
596
596
597 magic_escape = self.magic_escape
597 magic_escape = self.magic_escape
598 magic_prefix = self.magic_prefix
598 magic_prefix = self.magic_prefix
599
599
600 self.lbuf = self.full_lbuf[:self.get_endidx()]
600 self.lbuf = self.full_lbuf[:self.get_endidx()]
601
601
602 try:
602 try:
603 if text.startswith(magic_escape):
603 if text.startswith(magic_escape):
604 text = text.replace(magic_escape,magic_prefix)
604 text = text.replace(magic_escape,magic_prefix)
605 elif text.startswith('~'):
605 elif text.startswith('~'):
606 text = os.path.expanduser(text)
606 text = os.path.expanduser(text)
607 if state == 0:
607 if state == 0:
608 custom_res = self.dispatch_custom_completer(text)
608 custom_res = self.dispatch_custom_completer(text)
609 if custom_res is not None:
609 if custom_res is not None:
610 # did custom completers produce something?
610 # did custom completers produce something?
611 self.matches = custom_res
611 self.matches = custom_res
612 else:
612 else:
613 # Extend the list of completions with the results of each
613 # Extend the list of completions with the results of each
614 # matcher, so we return results to the user from all
614 # matcher, so we return results to the user from all
615 # namespaces.
615 # namespaces.
616 if self.merge_completions:
616 if self.merge_completions:
617 self.matches = []
617 self.matches = []
618 for matcher in self.matchers:
618 for matcher in self.matchers:
619 self.matches.extend(matcher(text))
619 self.matches.extend(matcher(text))
620 else:
620 else:
621 for matcher in self.matchers:
621 for matcher in self.matchers:
622 self.matches = matcher(text)
622 self.matches = matcher(text)
623 if self.matches:
623 if self.matches:
624 break
624 break
625 def uniq(alist):
625 def uniq(alist):
626 set = {}
626 set = {}
627 return [set.setdefault(e,e) for e in alist if e not in set]
627 return [set.setdefault(e,e) for e in alist if e not in set]
628 self.matches = uniq(self.matches)
628 self.matches = uniq(self.matches)
629 try:
629 try:
630 ret = self.matches[state].replace(magic_prefix,magic_escape)
630 ret = self.matches[state].replace(magic_prefix,magic_escape)
631 return ret
631 return ret
632 except IndexError:
632 except IndexError:
633 return None
633 return None
634 except:
634 except:
635 #from IPython.ultraTB import AutoFormattedTB; # dbg
635 #from IPython.ultraTB import AutoFormattedTB; # dbg
636 #tb=AutoFormattedTB('Verbose');tb() #dbg
636 #tb=AutoFormattedTB('Verbose');tb() #dbg
637
637
638 # If completion fails, don't annoy the user.
638 # If completion fails, don't annoy the user.
639 return None
639 return None
@@ -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.Itpl import itpl
30
30
31 from IPython.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,523 +1,523 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """
2 """
3 Pdb debugger class.
3 Pdb debugger class.
4
4
5 Modified from the standard pdb.Pdb class to avoid including readline, so that
5 Modified from the standard pdb.Pdb class to avoid including readline, so that
6 the command line completion of other programs which include this isn't
6 the command line completion of other programs which include this isn't
7 damaged.
7 damaged.
8
8
9 In the future, this class will be expanded with improvements over the standard
9 In the future, this class will be expanded with improvements over the standard
10 pdb.
10 pdb.
11
11
12 The code in this file is mainly lifted out of cmd.py in Python 2.2, with minor
12 The code in this file is mainly lifted out of cmd.py in Python 2.2, with minor
13 changes. Licensing should therefore be under the standard Python terms. For
13 changes. Licensing should therefore be under the standard Python terms. For
14 details on the PSF (Python Software Foundation) standard license, see:
14 details on the PSF (Python Software Foundation) standard license, see:
15
15
16 http://www.python.org/2.2.3/license.html"""
16 http://www.python.org/2.2.3/license.html"""
17
17
18 #*****************************************************************************
18 #*****************************************************************************
19 #
19 #
20 # This file is licensed under the PSF license.
20 # This file is licensed under the PSF license.
21 #
21 #
22 # Copyright (C) 2001 Python Software Foundation, www.python.org
22 # Copyright (C) 2001 Python Software Foundation, www.python.org
23 # Copyright (C) 2005-2006 Fernando Perez. <fperez@colorado.edu>
23 # Copyright (C) 2005-2006 Fernando Perez. <fperez@colorado.edu>
24 #
24 #
25 #
25 #
26 #*****************************************************************************
26 #*****************************************************************************
27
27
28 import bdb
28 import bdb
29 import cmd
29 import cmd
30 import linecache
30 import linecache
31 import os
31 import os
32 import sys
32 import sys
33
33
34 from IPython import PyColorize, ipapi
34 from IPython import PyColorize, ipapi
35 from IPython.utils import coloransi
35 from IPython.utils import coloransi
36 from IPython.genutils import Term
36 from IPython.utils.genutils import Term
37 from IPython.core.excolors import exception_colors
37 from IPython.core.excolors import exception_colors
38
38
39 # See if we can use pydb.
39 # See if we can use pydb.
40 has_pydb = False
40 has_pydb = False
41 prompt = 'ipdb> '
41 prompt = 'ipdb> '
42 #We have to check this directly from sys.argv, config struct not yet available
42 #We have to check this directly from sys.argv, config struct not yet available
43 if '-pydb' in sys.argv:
43 if '-pydb' in sys.argv:
44 try:
44 try:
45 import pydb
45 import pydb
46 if hasattr(pydb.pydb, "runl") and pydb.version>'1.17':
46 if hasattr(pydb.pydb, "runl") and pydb.version>'1.17':
47 # Version 1.17 is broken, and that's what ships with Ubuntu Edgy, so we
47 # Version 1.17 is broken, and that's what ships with Ubuntu Edgy, so we
48 # better protect against it.
48 # better protect against it.
49 has_pydb = True
49 has_pydb = True
50 except ImportError:
50 except ImportError:
51 print "Pydb (http://bashdb.sourceforge.net/pydb/) does not seem to be available"
51 print "Pydb (http://bashdb.sourceforge.net/pydb/) does not seem to be available"
52
52
53 if has_pydb:
53 if has_pydb:
54 from pydb import Pdb as OldPdb
54 from pydb import Pdb as OldPdb
55 #print "Using pydb for %run -d and post-mortem" #dbg
55 #print "Using pydb for %run -d and post-mortem" #dbg
56 prompt = 'ipydb> '
56 prompt = 'ipydb> '
57 else:
57 else:
58 from pdb import Pdb as OldPdb
58 from pdb import Pdb as OldPdb
59
59
60 # Allow the set_trace code to operate outside of an ipython instance, even if
60 # Allow the set_trace code to operate outside of an ipython instance, even if
61 # it does so with some limitations. The rest of this support is implemented in
61 # it does so with some limitations. The rest of this support is implemented in
62 # the Tracer constructor.
62 # the Tracer constructor.
63 def BdbQuit_excepthook(et,ev,tb):
63 def BdbQuit_excepthook(et,ev,tb):
64 if et==bdb.BdbQuit:
64 if et==bdb.BdbQuit:
65 print 'Exiting Debugger.'
65 print 'Exiting Debugger.'
66 else:
66 else:
67 BdbQuit_excepthook.excepthook_ori(et,ev,tb)
67 BdbQuit_excepthook.excepthook_ori(et,ev,tb)
68
68
69 def BdbQuit_IPython_excepthook(self,et,ev,tb):
69 def BdbQuit_IPython_excepthook(self,et,ev,tb):
70 print 'Exiting Debugger.'
70 print 'Exiting Debugger.'
71
71
72 class Tracer(object):
72 class Tracer(object):
73 """Class for local debugging, similar to pdb.set_trace.
73 """Class for local debugging, similar to pdb.set_trace.
74
74
75 Instances of this class, when called, behave like pdb.set_trace, but
75 Instances of this class, when called, behave like pdb.set_trace, but
76 providing IPython's enhanced capabilities.
76 providing IPython's enhanced capabilities.
77
77
78 This is implemented as a class which must be initialized in your own code
78 This is implemented as a class which must be initialized in your own code
79 and not as a standalone function because we need to detect at runtime
79 and not as a standalone function because we need to detect at runtime
80 whether IPython is already active or not. That detection is done in the
80 whether IPython is already active or not. That detection is done in the
81 constructor, ensuring that this code plays nicely with a running IPython,
81 constructor, ensuring that this code plays nicely with a running IPython,
82 while functioning acceptably (though with limitations) if outside of it.
82 while functioning acceptably (though with limitations) if outside of it.
83 """
83 """
84
84
85 def __init__(self,colors=None):
85 def __init__(self,colors=None):
86 """Create a local debugger instance.
86 """Create a local debugger instance.
87
87
88 :Parameters:
88 :Parameters:
89
89
90 - `colors` (None): a string containing the name of the color scheme to
90 - `colors` (None): a string containing the name of the color scheme to
91 use, it must be one of IPython's valid color schemes. If not given, the
91 use, it must be one of IPython's valid color schemes. If not given, the
92 function will default to the current IPython scheme when running inside
92 function will default to the current IPython scheme when running inside
93 IPython, and to 'NoColor' otherwise.
93 IPython, and to 'NoColor' otherwise.
94
94
95 Usage example:
95 Usage example:
96
96
97 from IPython.core.debugger import Tracer; debug_here = Tracer()
97 from IPython.core.debugger import Tracer; debug_here = Tracer()
98
98
99 ... later in your code
99 ... later in your code
100 debug_here() # -> will open up the debugger at that point.
100 debug_here() # -> will open up the debugger at that point.
101
101
102 Once the debugger activates, you can use all of its regular commands to
102 Once the debugger activates, you can use all of its regular commands to
103 step through code, set breakpoints, etc. See the pdb documentation
103 step through code, set breakpoints, etc. See the pdb documentation
104 from the Python standard library for usage details.
104 from the Python standard library for usage details.
105 """
105 """
106
106
107 global __IPYTHON__
107 global __IPYTHON__
108 try:
108 try:
109 __IPYTHON__
109 __IPYTHON__
110 except NameError:
110 except NameError:
111 # Outside of ipython, we set our own exception hook manually
111 # Outside of ipython, we set our own exception hook manually
112 __IPYTHON__ = ipapi.get(True,False)
112 __IPYTHON__ = ipapi.get(True,False)
113 BdbQuit_excepthook.excepthook_ori = sys.excepthook
113 BdbQuit_excepthook.excepthook_ori = sys.excepthook
114 sys.excepthook = BdbQuit_excepthook
114 sys.excepthook = BdbQuit_excepthook
115 def_colors = 'NoColor'
115 def_colors = 'NoColor'
116 try:
116 try:
117 # Limited tab completion support
117 # Limited tab completion support
118 import readline
118 import readline
119 readline.parse_and_bind('tab: complete')
119 readline.parse_and_bind('tab: complete')
120 except ImportError:
120 except ImportError:
121 pass
121 pass
122 else:
122 else:
123 # In ipython, we use its custom exception handler mechanism
123 # In ipython, we use its custom exception handler mechanism
124 ip = ipapi.get()
124 ip = ipapi.get()
125 def_colors = ip.options.colors
125 def_colors = ip.options.colors
126 ip.set_custom_exc((bdb.BdbQuit,),BdbQuit_IPython_excepthook)
126 ip.set_custom_exc((bdb.BdbQuit,),BdbQuit_IPython_excepthook)
127
127
128 if colors is None:
128 if colors is None:
129 colors = def_colors
129 colors = def_colors
130 self.debugger = Pdb(colors)
130 self.debugger = Pdb(colors)
131
131
132 def __call__(self):
132 def __call__(self):
133 """Starts an interactive debugger at the point where called.
133 """Starts an interactive debugger at the point where called.
134
134
135 This is similar to the pdb.set_trace() function from the std lib, but
135 This is similar to the pdb.set_trace() function from the std lib, but
136 using IPython's enhanced debugger."""
136 using IPython's enhanced debugger."""
137
137
138 self.debugger.set_trace(sys._getframe().f_back)
138 self.debugger.set_trace(sys._getframe().f_back)
139
139
140 def decorate_fn_with_doc(new_fn, old_fn, additional_text=""):
140 def decorate_fn_with_doc(new_fn, old_fn, additional_text=""):
141 """Make new_fn have old_fn's doc string. This is particularly useful
141 """Make new_fn have old_fn's doc string. This is particularly useful
142 for the do_... commands that hook into the help system.
142 for the do_... commands that hook into the help system.
143 Adapted from from a comp.lang.python posting
143 Adapted from from a comp.lang.python posting
144 by Duncan Booth."""
144 by Duncan Booth."""
145 def wrapper(*args, **kw):
145 def wrapper(*args, **kw):
146 return new_fn(*args, **kw)
146 return new_fn(*args, **kw)
147 if old_fn.__doc__:
147 if old_fn.__doc__:
148 wrapper.__doc__ = old_fn.__doc__ + additional_text
148 wrapper.__doc__ = old_fn.__doc__ + additional_text
149 return wrapper
149 return wrapper
150
150
151 def _file_lines(fname):
151 def _file_lines(fname):
152 """Return the contents of a named file as a list of lines.
152 """Return the contents of a named file as a list of lines.
153
153
154 This function never raises an IOError exception: if the file can't be
154 This function never raises an IOError exception: if the file can't be
155 read, it simply returns an empty list."""
155 read, it simply returns an empty list."""
156
156
157 try:
157 try:
158 outfile = open(fname)
158 outfile = open(fname)
159 except IOError:
159 except IOError:
160 return []
160 return []
161 else:
161 else:
162 out = outfile.readlines()
162 out = outfile.readlines()
163 outfile.close()
163 outfile.close()
164 return out
164 return out
165
165
166 class Pdb(OldPdb):
166 class Pdb(OldPdb):
167 """Modified Pdb class, does not load readline."""
167 """Modified Pdb class, does not load readline."""
168
168
169 if sys.version[:3] >= '2.5' or has_pydb:
169 if sys.version[:3] >= '2.5' or has_pydb:
170 def __init__(self,color_scheme='NoColor',completekey=None,
170 def __init__(self,color_scheme='NoColor',completekey=None,
171 stdin=None, stdout=None):
171 stdin=None, stdout=None):
172
172
173 # Parent constructor:
173 # Parent constructor:
174 if has_pydb and completekey is None:
174 if has_pydb and completekey is None:
175 OldPdb.__init__(self,stdin=stdin,stdout=Term.cout)
175 OldPdb.__init__(self,stdin=stdin,stdout=Term.cout)
176 else:
176 else:
177 OldPdb.__init__(self,completekey,stdin,stdout)
177 OldPdb.__init__(self,completekey,stdin,stdout)
178
178
179 self.prompt = prompt # The default prompt is '(Pdb)'
179 self.prompt = prompt # The default prompt is '(Pdb)'
180
180
181 # IPython changes...
181 # IPython changes...
182 self.is_pydb = has_pydb
182 self.is_pydb = has_pydb
183
183
184 if self.is_pydb:
184 if self.is_pydb:
185
185
186 # iplib.py's ipalias seems to want pdb's checkline
186 # iplib.py's ipalias seems to want pdb's checkline
187 # which located in pydb.fn
187 # which located in pydb.fn
188 import pydb.fns
188 import pydb.fns
189 self.checkline = lambda filename, lineno: \
189 self.checkline = lambda filename, lineno: \
190 pydb.fns.checkline(self, filename, lineno)
190 pydb.fns.checkline(self, filename, lineno)
191
191
192 self.curframe = None
192 self.curframe = None
193 self.do_restart = self.new_do_restart
193 self.do_restart = self.new_do_restart
194
194
195 self.old_all_completions = __IPYTHON__.Completer.all_completions
195 self.old_all_completions = __IPYTHON__.Completer.all_completions
196 __IPYTHON__.Completer.all_completions=self.all_completions
196 __IPYTHON__.Completer.all_completions=self.all_completions
197
197
198 self.do_list = decorate_fn_with_doc(self.list_command_pydb,
198 self.do_list = decorate_fn_with_doc(self.list_command_pydb,
199 OldPdb.do_list)
199 OldPdb.do_list)
200 self.do_l = self.do_list
200 self.do_l = self.do_list
201 self.do_frame = decorate_fn_with_doc(self.new_do_frame,
201 self.do_frame = decorate_fn_with_doc(self.new_do_frame,
202 OldPdb.do_frame)
202 OldPdb.do_frame)
203
203
204 self.aliases = {}
204 self.aliases = {}
205
205
206 # Create color table: we copy the default one from the traceback
206 # Create color table: we copy the default one from the traceback
207 # module and add a few attributes needed for debugging
207 # module and add a few attributes needed for debugging
208 self.color_scheme_table = exception_colors()
208 self.color_scheme_table = exception_colors()
209
209
210 # shorthands
210 # shorthands
211 C = coloransi.TermColors
211 C = coloransi.TermColors
212 cst = self.color_scheme_table
212 cst = self.color_scheme_table
213
213
214 cst['NoColor'].colors.breakpoint_enabled = C.NoColor
214 cst['NoColor'].colors.breakpoint_enabled = C.NoColor
215 cst['NoColor'].colors.breakpoint_disabled = C.NoColor
215 cst['NoColor'].colors.breakpoint_disabled = C.NoColor
216
216
217 cst['Linux'].colors.breakpoint_enabled = C.LightRed
217 cst['Linux'].colors.breakpoint_enabled = C.LightRed
218 cst['Linux'].colors.breakpoint_disabled = C.Red
218 cst['Linux'].colors.breakpoint_disabled = C.Red
219
219
220 cst['LightBG'].colors.breakpoint_enabled = C.LightRed
220 cst['LightBG'].colors.breakpoint_enabled = C.LightRed
221 cst['LightBG'].colors.breakpoint_disabled = C.Red
221 cst['LightBG'].colors.breakpoint_disabled = C.Red
222
222
223 self.set_colors(color_scheme)
223 self.set_colors(color_scheme)
224
224
225 # Add a python parser so we can syntax highlight source while
225 # Add a python parser so we can syntax highlight source while
226 # debugging.
226 # debugging.
227 self.parser = PyColorize.Parser()
227 self.parser = PyColorize.Parser()
228
228
229
229
230 else:
230 else:
231 # Ugly hack: for Python 2.3-2.4, we can't call the parent constructor,
231 # Ugly hack: for Python 2.3-2.4, we can't call the parent constructor,
232 # because it binds readline and breaks tab-completion. This means we
232 # because it binds readline and breaks tab-completion. This means we
233 # have to COPY the constructor here.
233 # have to COPY the constructor here.
234 def __init__(self,color_scheme='NoColor'):
234 def __init__(self,color_scheme='NoColor'):
235 bdb.Bdb.__init__(self)
235 bdb.Bdb.__init__(self)
236 cmd.Cmd.__init__(self,completekey=None) # don't load readline
236 cmd.Cmd.__init__(self,completekey=None) # don't load readline
237 self.prompt = 'ipdb> ' # The default prompt is '(Pdb)'
237 self.prompt = 'ipdb> ' # The default prompt is '(Pdb)'
238 self.aliases = {}
238 self.aliases = {}
239
239
240 # These two lines are part of the py2.4 constructor, let's put them
240 # These two lines are part of the py2.4 constructor, let's put them
241 # unconditionally here as they won't cause any problems in 2.3.
241 # unconditionally here as they won't cause any problems in 2.3.
242 self.mainpyfile = ''
242 self.mainpyfile = ''
243 self._wait_for_mainpyfile = 0
243 self._wait_for_mainpyfile = 0
244
244
245 # Read $HOME/.pdbrc and ./.pdbrc
245 # Read $HOME/.pdbrc and ./.pdbrc
246 try:
246 try:
247 self.rcLines = _file_lines(os.path.join(os.environ['HOME'],
247 self.rcLines = _file_lines(os.path.join(os.environ['HOME'],
248 ".pdbrc"))
248 ".pdbrc"))
249 except KeyError:
249 except KeyError:
250 self.rcLines = []
250 self.rcLines = []
251 self.rcLines.extend(_file_lines(".pdbrc"))
251 self.rcLines.extend(_file_lines(".pdbrc"))
252
252
253 # Create color table: we copy the default one from the traceback
253 # Create color table: we copy the default one from the traceback
254 # module and add a few attributes needed for debugging
254 # module and add a few attributes needed for debugging
255 self.color_scheme_table = exception_colors()
255 self.color_scheme_table = exception_colors()
256
256
257 # shorthands
257 # shorthands
258 C = coloransi.TermColors
258 C = coloransi.TermColors
259 cst = self.color_scheme_table
259 cst = self.color_scheme_table
260
260
261 cst['NoColor'].colors.breakpoint_enabled = C.NoColor
261 cst['NoColor'].colors.breakpoint_enabled = C.NoColor
262 cst['NoColor'].colors.breakpoint_disabled = C.NoColor
262 cst['NoColor'].colors.breakpoint_disabled = C.NoColor
263
263
264 cst['Linux'].colors.breakpoint_enabled = C.LightRed
264 cst['Linux'].colors.breakpoint_enabled = C.LightRed
265 cst['Linux'].colors.breakpoint_disabled = C.Red
265 cst['Linux'].colors.breakpoint_disabled = C.Red
266
266
267 cst['LightBG'].colors.breakpoint_enabled = C.LightRed
267 cst['LightBG'].colors.breakpoint_enabled = C.LightRed
268 cst['LightBG'].colors.breakpoint_disabled = C.Red
268 cst['LightBG'].colors.breakpoint_disabled = C.Red
269
269
270 self.set_colors(color_scheme)
270 self.set_colors(color_scheme)
271
271
272 # Add a python parser so we can syntax highlight source while
272 # Add a python parser so we can syntax highlight source while
273 # debugging.
273 # debugging.
274 self.parser = PyColorize.Parser()
274 self.parser = PyColorize.Parser()
275
275
276 def set_colors(self, scheme):
276 def set_colors(self, scheme):
277 """Shorthand access to the color table scheme selector method."""
277 """Shorthand access to the color table scheme selector method."""
278 self.color_scheme_table.set_active_scheme(scheme)
278 self.color_scheme_table.set_active_scheme(scheme)
279
279
280 def interaction(self, frame, traceback):
280 def interaction(self, frame, traceback):
281 __IPYTHON__.set_completer_frame(frame)
281 __IPYTHON__.set_completer_frame(frame)
282 OldPdb.interaction(self, frame, traceback)
282 OldPdb.interaction(self, frame, traceback)
283
283
284 def new_do_up(self, arg):
284 def new_do_up(self, arg):
285 OldPdb.do_up(self, arg)
285 OldPdb.do_up(self, arg)
286 __IPYTHON__.set_completer_frame(self.curframe)
286 __IPYTHON__.set_completer_frame(self.curframe)
287 do_u = do_up = decorate_fn_with_doc(new_do_up, OldPdb.do_up)
287 do_u = do_up = decorate_fn_with_doc(new_do_up, OldPdb.do_up)
288
288
289 def new_do_down(self, arg):
289 def new_do_down(self, arg):
290 OldPdb.do_down(self, arg)
290 OldPdb.do_down(self, arg)
291 __IPYTHON__.set_completer_frame(self.curframe)
291 __IPYTHON__.set_completer_frame(self.curframe)
292
292
293 do_d = do_down = decorate_fn_with_doc(new_do_down, OldPdb.do_down)
293 do_d = do_down = decorate_fn_with_doc(new_do_down, OldPdb.do_down)
294
294
295 def new_do_frame(self, arg):
295 def new_do_frame(self, arg):
296 OldPdb.do_frame(self, arg)
296 OldPdb.do_frame(self, arg)
297 __IPYTHON__.set_completer_frame(self.curframe)
297 __IPYTHON__.set_completer_frame(self.curframe)
298
298
299 def new_do_quit(self, arg):
299 def new_do_quit(self, arg):
300
300
301 if hasattr(self, 'old_all_completions'):
301 if hasattr(self, 'old_all_completions'):
302 __IPYTHON__.Completer.all_completions=self.old_all_completions
302 __IPYTHON__.Completer.all_completions=self.old_all_completions
303
303
304
304
305 return OldPdb.do_quit(self, arg)
305 return OldPdb.do_quit(self, arg)
306
306
307 do_q = do_quit = decorate_fn_with_doc(new_do_quit, OldPdb.do_quit)
307 do_q = do_quit = decorate_fn_with_doc(new_do_quit, OldPdb.do_quit)
308
308
309 def new_do_restart(self, arg):
309 def new_do_restart(self, arg):
310 """Restart command. In the context of ipython this is exactly the same
310 """Restart command. In the context of ipython this is exactly the same
311 thing as 'quit'."""
311 thing as 'quit'."""
312 self.msg("Restart doesn't make sense here. Using 'quit' instead.")
312 self.msg("Restart doesn't make sense here. Using 'quit' instead.")
313 return self.do_quit(arg)
313 return self.do_quit(arg)
314
314
315 def postloop(self):
315 def postloop(self):
316 __IPYTHON__.set_completer_frame(None)
316 __IPYTHON__.set_completer_frame(None)
317
317
318 def print_stack_trace(self):
318 def print_stack_trace(self):
319 try:
319 try:
320 for frame_lineno in self.stack:
320 for frame_lineno in self.stack:
321 self.print_stack_entry(frame_lineno, context = 5)
321 self.print_stack_entry(frame_lineno, context = 5)
322 except KeyboardInterrupt:
322 except KeyboardInterrupt:
323 pass
323 pass
324
324
325 def print_stack_entry(self,frame_lineno,prompt_prefix='\n-> ',
325 def print_stack_entry(self,frame_lineno,prompt_prefix='\n-> ',
326 context = 3):
326 context = 3):
327 #frame, lineno = frame_lineno
327 #frame, lineno = frame_lineno
328 print >>Term.cout, self.format_stack_entry(frame_lineno, '', context)
328 print >>Term.cout, self.format_stack_entry(frame_lineno, '', context)
329
329
330 # vds: >>
330 # vds: >>
331 frame, lineno = frame_lineno
331 frame, lineno = frame_lineno
332 filename = frame.f_code.co_filename
332 filename = frame.f_code.co_filename
333 __IPYTHON__.hooks.synchronize_with_editor(filename, lineno, 0)
333 __IPYTHON__.hooks.synchronize_with_editor(filename, lineno, 0)
334 # vds: <<
334 # vds: <<
335
335
336 def format_stack_entry(self, frame_lineno, lprefix=': ', context = 3):
336 def format_stack_entry(self, frame_lineno, lprefix=': ', context = 3):
337 import linecache, repr
337 import linecache, repr
338
338
339 ret = []
339 ret = []
340
340
341 Colors = self.color_scheme_table.active_colors
341 Colors = self.color_scheme_table.active_colors
342 ColorsNormal = Colors.Normal
342 ColorsNormal = Colors.Normal
343 tpl_link = '%s%%s%s' % (Colors.filenameEm, ColorsNormal)
343 tpl_link = '%s%%s%s' % (Colors.filenameEm, ColorsNormal)
344 tpl_call = '%s%%s%s%%s%s' % (Colors.vName, Colors.valEm, ColorsNormal)
344 tpl_call = '%s%%s%s%%s%s' % (Colors.vName, Colors.valEm, ColorsNormal)
345 tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
345 tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
346 tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line,
346 tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line,
347 ColorsNormal)
347 ColorsNormal)
348
348
349 frame, lineno = frame_lineno
349 frame, lineno = frame_lineno
350
350
351 return_value = ''
351 return_value = ''
352 if '__return__' in frame.f_locals:
352 if '__return__' in frame.f_locals:
353 rv = frame.f_locals['__return__']
353 rv = frame.f_locals['__return__']
354 #return_value += '->'
354 #return_value += '->'
355 return_value += repr.repr(rv) + '\n'
355 return_value += repr.repr(rv) + '\n'
356 ret.append(return_value)
356 ret.append(return_value)
357
357
358 #s = filename + '(' + `lineno` + ')'
358 #s = filename + '(' + `lineno` + ')'
359 filename = self.canonic(frame.f_code.co_filename)
359 filename = self.canonic(frame.f_code.co_filename)
360 link = tpl_link % filename
360 link = tpl_link % filename
361
361
362 if frame.f_code.co_name:
362 if frame.f_code.co_name:
363 func = frame.f_code.co_name
363 func = frame.f_code.co_name
364 else:
364 else:
365 func = "<lambda>"
365 func = "<lambda>"
366
366
367 call = ''
367 call = ''
368 if func != '?':
368 if func != '?':
369 if '__args__' in frame.f_locals:
369 if '__args__' in frame.f_locals:
370 args = repr.repr(frame.f_locals['__args__'])
370 args = repr.repr(frame.f_locals['__args__'])
371 else:
371 else:
372 args = '()'
372 args = '()'
373 call = tpl_call % (func, args)
373 call = tpl_call % (func, args)
374
374
375 # The level info should be generated in the same format pdb uses, to
375 # The level info should be generated in the same format pdb uses, to
376 # avoid breaking the pdbtrack functionality of python-mode in *emacs.
376 # avoid breaking the pdbtrack functionality of python-mode in *emacs.
377 if frame is self.curframe:
377 if frame is self.curframe:
378 ret.append('> ')
378 ret.append('> ')
379 else:
379 else:
380 ret.append(' ')
380 ret.append(' ')
381 ret.append('%s(%s)%s\n' % (link,lineno,call))
381 ret.append('%s(%s)%s\n' % (link,lineno,call))
382
382
383 start = lineno - 1 - context//2
383 start = lineno - 1 - context//2
384 lines = linecache.getlines(filename)
384 lines = linecache.getlines(filename)
385 start = max(start, 0)
385 start = max(start, 0)
386 start = min(start, len(lines) - context)
386 start = min(start, len(lines) - context)
387 lines = lines[start : start + context]
387 lines = lines[start : start + context]
388
388
389 for i,line in enumerate(lines):
389 for i,line in enumerate(lines):
390 show_arrow = (start + 1 + i == lineno)
390 show_arrow = (start + 1 + i == lineno)
391 linetpl = (frame is self.curframe or show_arrow) \
391 linetpl = (frame is self.curframe or show_arrow) \
392 and tpl_line_em \
392 and tpl_line_em \
393 or tpl_line
393 or tpl_line
394 ret.append(self.__format_line(linetpl, filename,
394 ret.append(self.__format_line(linetpl, filename,
395 start + 1 + i, line,
395 start + 1 + i, line,
396 arrow = show_arrow) )
396 arrow = show_arrow) )
397
397
398 return ''.join(ret)
398 return ''.join(ret)
399
399
400 def __format_line(self, tpl_line, filename, lineno, line, arrow = False):
400 def __format_line(self, tpl_line, filename, lineno, line, arrow = False):
401 bp_mark = ""
401 bp_mark = ""
402 bp_mark_color = ""
402 bp_mark_color = ""
403
403
404 scheme = self.color_scheme_table.active_scheme_name
404 scheme = self.color_scheme_table.active_scheme_name
405 new_line, err = self.parser.format2(line, 'str', scheme)
405 new_line, err = self.parser.format2(line, 'str', scheme)
406 if not err: line = new_line
406 if not err: line = new_line
407
407
408 bp = None
408 bp = None
409 if lineno in self.get_file_breaks(filename):
409 if lineno in self.get_file_breaks(filename):
410 bps = self.get_breaks(filename, lineno)
410 bps = self.get_breaks(filename, lineno)
411 bp = bps[-1]
411 bp = bps[-1]
412
412
413 if bp:
413 if bp:
414 Colors = self.color_scheme_table.active_colors
414 Colors = self.color_scheme_table.active_colors
415 bp_mark = str(bp.number)
415 bp_mark = str(bp.number)
416 bp_mark_color = Colors.breakpoint_enabled
416 bp_mark_color = Colors.breakpoint_enabled
417 if not bp.enabled:
417 if not bp.enabled:
418 bp_mark_color = Colors.breakpoint_disabled
418 bp_mark_color = Colors.breakpoint_disabled
419
419
420 numbers_width = 7
420 numbers_width = 7
421 if arrow:
421 if arrow:
422 # This is the line with the error
422 # This is the line with the error
423 pad = numbers_width - len(str(lineno)) - len(bp_mark)
423 pad = numbers_width - len(str(lineno)) - len(bp_mark)
424 if pad >= 3:
424 if pad >= 3:
425 marker = '-'*(pad-3) + '-> '
425 marker = '-'*(pad-3) + '-> '
426 elif pad == 2:
426 elif pad == 2:
427 marker = '> '
427 marker = '> '
428 elif pad == 1:
428 elif pad == 1:
429 marker = '>'
429 marker = '>'
430 else:
430 else:
431 marker = ''
431 marker = ''
432 num = '%s%s' % (marker, str(lineno))
432 num = '%s%s' % (marker, str(lineno))
433 line = tpl_line % (bp_mark_color + bp_mark, num, line)
433 line = tpl_line % (bp_mark_color + bp_mark, num, line)
434 else:
434 else:
435 num = '%*s' % (numbers_width - len(bp_mark), str(lineno))
435 num = '%*s' % (numbers_width - len(bp_mark), str(lineno))
436 line = tpl_line % (bp_mark_color + bp_mark, num, line)
436 line = tpl_line % (bp_mark_color + bp_mark, num, line)
437
437
438 return line
438 return line
439
439
440 def list_command_pydb(self, arg):
440 def list_command_pydb(self, arg):
441 """List command to use if we have a newer pydb installed"""
441 """List command to use if we have a newer pydb installed"""
442 filename, first, last = OldPdb.parse_list_cmd(self, arg)
442 filename, first, last = OldPdb.parse_list_cmd(self, arg)
443 if filename is not None:
443 if filename is not None:
444 self.print_list_lines(filename, first, last)
444 self.print_list_lines(filename, first, last)
445
445
446 def print_list_lines(self, filename, first, last):
446 def print_list_lines(self, filename, first, last):
447 """The printing (as opposed to the parsing part of a 'list'
447 """The printing (as opposed to the parsing part of a 'list'
448 command."""
448 command."""
449 try:
449 try:
450 Colors = self.color_scheme_table.active_colors
450 Colors = self.color_scheme_table.active_colors
451 ColorsNormal = Colors.Normal
451 ColorsNormal = Colors.Normal
452 tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
452 tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
453 tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line, ColorsNormal)
453 tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line, ColorsNormal)
454 src = []
454 src = []
455 for lineno in range(first, last+1):
455 for lineno in range(first, last+1):
456 line = linecache.getline(filename, lineno)
456 line = linecache.getline(filename, lineno)
457 if not line:
457 if not line:
458 break
458 break
459
459
460 if lineno == self.curframe.f_lineno:
460 if lineno == self.curframe.f_lineno:
461 line = self.__format_line(tpl_line_em, filename, lineno, line, arrow = True)
461 line = self.__format_line(tpl_line_em, filename, lineno, line, arrow = True)
462 else:
462 else:
463 line = self.__format_line(tpl_line, filename, lineno, line, arrow = False)
463 line = self.__format_line(tpl_line, filename, lineno, line, arrow = False)
464
464
465 src.append(line)
465 src.append(line)
466 self.lineno = lineno
466 self.lineno = lineno
467
467
468 print >>Term.cout, ''.join(src)
468 print >>Term.cout, ''.join(src)
469
469
470 except KeyboardInterrupt:
470 except KeyboardInterrupt:
471 pass
471 pass
472
472
473 def do_list(self, arg):
473 def do_list(self, arg):
474 self.lastcmd = 'list'
474 self.lastcmd = 'list'
475 last = None
475 last = None
476 if arg:
476 if arg:
477 try:
477 try:
478 x = eval(arg, {}, {})
478 x = eval(arg, {}, {})
479 if type(x) == type(()):
479 if type(x) == type(()):
480 first, last = x
480 first, last = x
481 first = int(first)
481 first = int(first)
482 last = int(last)
482 last = int(last)
483 if last < first:
483 if last < first:
484 # Assume it's a count
484 # Assume it's a count
485 last = first + last
485 last = first + last
486 else:
486 else:
487 first = max(1, int(x) - 5)
487 first = max(1, int(x) - 5)
488 except:
488 except:
489 print '*** Error in argument:', `arg`
489 print '*** Error in argument:', `arg`
490 return
490 return
491 elif self.lineno is None:
491 elif self.lineno is None:
492 first = max(1, self.curframe.f_lineno - 5)
492 first = max(1, self.curframe.f_lineno - 5)
493 else:
493 else:
494 first = self.lineno + 1
494 first = self.lineno + 1
495 if last is None:
495 if last is None:
496 last = first + 10
496 last = first + 10
497 self.print_list_lines(self.curframe.f_code.co_filename, first, last)
497 self.print_list_lines(self.curframe.f_code.co_filename, first, last)
498
498
499 # vds: >>
499 # vds: >>
500 lineno = first
500 lineno = first
501 filename = self.curframe.f_code.co_filename
501 filename = self.curframe.f_code.co_filename
502 __IPYTHON__.hooks.synchronize_with_editor(filename, lineno, 0)
502 __IPYTHON__.hooks.synchronize_with_editor(filename, lineno, 0)
503 # vds: <<
503 # vds: <<
504
504
505 do_l = do_list
505 do_l = do_list
506
506
507 def do_pdef(self, arg):
507 def do_pdef(self, arg):
508 """The debugger interface to magic_pdef"""
508 """The debugger interface to magic_pdef"""
509 namespaces = [('Locals', self.curframe.f_locals),
509 namespaces = [('Locals', self.curframe.f_locals),
510 ('Globals', self.curframe.f_globals)]
510 ('Globals', self.curframe.f_globals)]
511 __IPYTHON__.magic_pdef(arg, namespaces=namespaces)
511 __IPYTHON__.magic_pdef(arg, namespaces=namespaces)
512
512
513 def do_pdoc(self, arg):
513 def do_pdoc(self, arg):
514 """The debugger interface to magic_pdoc"""
514 """The debugger interface to magic_pdoc"""
515 namespaces = [('Locals', self.curframe.f_locals),
515 namespaces = [('Locals', self.curframe.f_locals),
516 ('Globals', self.curframe.f_globals)]
516 ('Globals', self.curframe.f_globals)]
517 __IPYTHON__.magic_pdoc(arg, namespaces=namespaces)
517 __IPYTHON__.magic_pdoc(arg, namespaces=namespaces)
518
518
519 def do_pinfo(self, arg):
519 def do_pinfo(self, arg):
520 """The debugger equivalant of ?obj"""
520 """The debugger equivalant of ?obj"""
521 namespaces = [('Locals', self.curframe.f_locals),
521 namespaces = [('Locals', self.curframe.f_locals),
522 ('Globals', self.curframe.f_globals)]
522 ('Globals', self.curframe.f_globals)]
523 __IPYTHON__.magic_pinfo("pinfo %s" % arg, namespaces=namespaces)
523 __IPYTHON__.magic_pinfo("pinfo %s" % arg, namespaces=namespaces)
@@ -1,229 +1,229 b''
1 #!/usr/bin/env python
1 #!/usr/bin/env python
2
2
3 r""" mglob - enhanced file list expansion module
3 r""" mglob - enhanced file list expansion module
4
4
5 Use as stand-alone utility (for xargs, `backticks` etc.),
5 Use as stand-alone utility (for xargs, `backticks` etc.),
6 or a globbing library for own python programs. Globbing the sys.argv is something
6 or a globbing library for own python programs. Globbing the sys.argv is something
7 that almost every Windows script has to perform manually, and this module is here
7 that almost every Windows script has to perform manually, and this module is here
8 to help with that task. Also Unix users will benefit from enhanced modes
8 to help with that task. Also Unix users will benefit from enhanced modes
9 such as recursion, exclusion, directory omission...
9 such as recursion, exclusion, directory omission...
10
10
11 Unlike glob.glob, directories are not included in the glob unless specified
11 Unlike glob.glob, directories are not included in the glob unless specified
12 with 'dir:'
12 with 'dir:'
13
13
14 'expand' is the function to use in python programs. Typical use
14 'expand' is the function to use in python programs. Typical use
15 to expand argv (esp. in windows)::
15 to expand argv (esp. in windows)::
16
16
17 try:
17 try:
18 import mglob
18 import mglob
19 files = mglob.expand(sys.argv[1:])
19 files = mglob.expand(sys.argv[1:])
20 except ImportError:
20 except ImportError:
21 print "mglob not found; try 'easy_install mglob' for extra features"
21 print "mglob not found; try 'easy_install mglob' for extra features"
22 files = sys.argv[1:]
22 files = sys.argv[1:]
23
23
24 Note that for unix, shell expands *normal* wildcards (*.cpp, etc.) in argv.
24 Note that for unix, shell expands *normal* wildcards (*.cpp, etc.) in argv.
25 Therefore, you might want to use quotes with normal wildcards to prevent this
25 Therefore, you might want to use quotes with normal wildcards to prevent this
26 expansion, in order for mglob to see the wildcards and get the wanted behaviour.
26 expansion, in order for mglob to see the wildcards and get the wanted behaviour.
27 Not quoting the wildcards is harmless and typically has equivalent results, though.
27 Not quoting the wildcards is harmless and typically has equivalent results, though.
28
28
29 Author: Ville Vainio <vivainio@gmail.com>
29 Author: Ville Vainio <vivainio@gmail.com>
30 License: MIT Open Source license
30 License: MIT Open Source license
31
31
32 """
32 """
33
33
34 #Assigned in variable for "usage" printing convenience"
34 #Assigned in variable for "usage" printing convenience"
35
35
36 globsyntax = """\
36 globsyntax = """\
37 This program allows specifying filenames with "mglob" mechanism.
37 This program allows specifying filenames with "mglob" mechanism.
38 Supported syntax in globs (wilcard matching patterns)::
38 Supported syntax in globs (wilcard matching patterns)::
39
39
40 *.cpp ?ellowo*
40 *.cpp ?ellowo*
41 - obvious. Differs from normal glob in that dirs are not included.
41 - obvious. Differs from normal glob in that dirs are not included.
42 Unix users might want to write this as: "*.cpp" "?ellowo*"
42 Unix users might want to write this as: "*.cpp" "?ellowo*"
43 rec:/usr/share=*.txt,*.doc
43 rec:/usr/share=*.txt,*.doc
44 - get all *.txt and *.doc under /usr/share,
44 - get all *.txt and *.doc under /usr/share,
45 recursively
45 recursively
46 rec:/usr/share
46 rec:/usr/share
47 - All files under /usr/share, recursively
47 - All files under /usr/share, recursively
48 rec:*.py
48 rec:*.py
49 - All .py files under current working dir, recursively
49 - All .py files under current working dir, recursively
50 foo
50 foo
51 - File or dir foo
51 - File or dir foo
52 !*.bak readme*
52 !*.bak readme*
53 - readme*, exclude files ending with .bak
53 - readme*, exclude files ending with .bak
54 !.svn/ !.hg/ !*_Data/ rec:.
54 !.svn/ !.hg/ !*_Data/ rec:.
55 - Skip .svn, .hg, foo_Data dirs (and their subdirs) in recurse.
55 - Skip .svn, .hg, foo_Data dirs (and their subdirs) in recurse.
56 Trailing / is the key, \ does not work! Use !.*/ for all hidden.
56 Trailing / is the key, \ does not work! Use !.*/ for all hidden.
57 dir:foo
57 dir:foo
58 - the directory foo if it exists (not files in foo)
58 - the directory foo if it exists (not files in foo)
59 dir:*
59 dir:*
60 - all directories in current folder
60 - all directories in current folder
61 foo.py bar.* !h* rec:*.py
61 foo.py bar.* !h* rec:*.py
62 - Obvious. !h* exclusion only applies for rec:*.py.
62 - Obvious. !h* exclusion only applies for rec:*.py.
63 foo.py is *not* included twice.
63 foo.py is *not* included twice.
64 @filelist.txt
64 @filelist.txt
65 - All files listed in 'filelist.txt' file, on separate lines.
65 - All files listed in 'filelist.txt' file, on separate lines.
66 "cont:class \wak:" rec:*.py
66 "cont:class \wak:" rec:*.py
67 - Match files containing regexp. Applies to subsequent files.
67 - Match files containing regexp. Applies to subsequent files.
68 note quotes because of whitespace.
68 note quotes because of whitespace.
69 """
69 """
70
70
71
71
72 __version__ = "0.2"
72 __version__ = "0.2"
73
73
74
74
75 import os,glob,fnmatch,sys,re
75 import os,glob,fnmatch,sys,re
76
76
77 def expand(flist,exp_dirs = False):
77 def expand(flist,exp_dirs = False):
78 """ Expand the glob(s) in flist.
78 """ Expand the glob(s) in flist.
79
79
80 flist may be either a whitespace-separated list of globs/files
80 flist may be either a whitespace-separated list of globs/files
81 or an array of globs/files.
81 or an array of globs/files.
82
82
83 if exp_dirs is true, directory names in glob are expanded to the files
83 if exp_dirs is true, directory names in glob are expanded to the files
84 contained in them - otherwise, directory names are returned as is.
84 contained in them - otherwise, directory names are returned as is.
85
85
86 """
86 """
87 if isinstance(flist, basestring):
87 if isinstance(flist, basestring):
88 import shlex
88 import shlex
89 flist = shlex.split(flist)
89 flist = shlex.split(flist)
90 done_set = set()
90 done_set = set()
91 denied_set = set()
91 denied_set = set()
92 cont_set = set()
92 cont_set = set()
93 cur_rejected_dirs = set()
93 cur_rejected_dirs = set()
94
94
95 def recfind(p, pats = ["*"]):
95 def recfind(p, pats = ["*"]):
96 denied_dirs = [os.path.dirname(d) for d in denied_set if d.endswith("/")]
96 denied_dirs = [os.path.dirname(d) for d in denied_set if d.endswith("/")]
97 for (dp,dnames,fnames) in os.walk(p):
97 for (dp,dnames,fnames) in os.walk(p):
98 # see if we should ignore the whole directory
98 # see if we should ignore the whole directory
99 dp_norm = dp.replace("\\","/") + "/"
99 dp_norm = dp.replace("\\","/") + "/"
100 deny = False
100 deny = False
101 # do not traverse under already rejected dirs
101 # do not traverse under already rejected dirs
102 for d in cur_rejected_dirs:
102 for d in cur_rejected_dirs:
103 if dp.startswith(d):
103 if dp.startswith(d):
104 deny = True
104 deny = True
105 break
105 break
106 if deny:
106 if deny:
107 continue
107 continue
108
108
109
109
110 #print "dp",dp
110 #print "dp",dp
111 bname = os.path.basename(dp)
111 bname = os.path.basename(dp)
112 for deny_pat in denied_dirs:
112 for deny_pat in denied_dirs:
113 if fnmatch.fnmatch( bname, deny_pat):
113 if fnmatch.fnmatch( bname, deny_pat):
114 deny = True
114 deny = True
115 cur_rejected_dirs.add(dp)
115 cur_rejected_dirs.add(dp)
116 break
116 break
117 if deny:
117 if deny:
118 continue
118 continue
119
119
120
120
121 for f in fnames:
121 for f in fnames:
122 matched = False
122 matched = False
123 for p in pats:
123 for p in pats:
124 if fnmatch.fnmatch(f,p):
124 if fnmatch.fnmatch(f,p):
125 matched = True
125 matched = True
126 break
126 break
127 if matched:
127 if matched:
128 yield os.path.join(dp,f)
128 yield os.path.join(dp,f)
129
129
130 def once_filter(seq):
130 def once_filter(seq):
131 for it in seq:
131 for it in seq:
132 p = os.path.abspath(it)
132 p = os.path.abspath(it)
133 if p in done_set:
133 if p in done_set:
134 continue
134 continue
135 done_set.add(p)
135 done_set.add(p)
136 deny = False
136 deny = False
137 for deny_pat in denied_set:
137 for deny_pat in denied_set:
138 if fnmatch.fnmatch(os.path.basename(p), deny_pat):
138 if fnmatch.fnmatch(os.path.basename(p), deny_pat):
139 deny = True
139 deny = True
140 break
140 break
141 if cont_set:
141 if cont_set:
142 try:
142 try:
143 cont = open(p).read()
143 cont = open(p).read()
144 except IOError:
144 except IOError:
145 # deny
145 # deny
146 continue
146 continue
147 for pat in cont_set:
147 for pat in cont_set:
148 if not re.search(pat,cont, re.IGNORECASE):
148 if not re.search(pat,cont, re.IGNORECASE):
149 deny = True
149 deny = True
150 break
150 break
151
151
152 if not deny:
152 if not deny:
153 yield it
153 yield it
154 return
154 return
155
155
156 res = []
156 res = []
157
157
158 for ent in flist:
158 for ent in flist:
159 ent = os.path.expanduser(os.path.expandvars(ent))
159 ent = os.path.expanduser(os.path.expandvars(ent))
160 if ent.lower().startswith('rec:'):
160 if ent.lower().startswith('rec:'):
161 fields = ent[4:].split('=')
161 fields = ent[4:].split('=')
162 if len(fields) == 2:
162 if len(fields) == 2:
163 pth, patlist = fields
163 pth, patlist = fields
164 elif len(fields) == 1:
164 elif len(fields) == 1:
165 if os.path.isdir(fields[0]):
165 if os.path.isdir(fields[0]):
166 # single arg is dir
166 # single arg is dir
167 pth, patlist = fields[0], '*'
167 pth, patlist = fields[0], '*'
168 else:
168 else:
169 # single arg is pattern
169 # single arg is pattern
170 pth, patlist = '.', fields[0]
170 pth, patlist = '.', fields[0]
171
171
172 elif len(fields) == 0:
172 elif len(fields) == 0:
173 pth, pathlist = '.','*'
173 pth, pathlist = '.','*'
174
174
175 pats = patlist.split(',')
175 pats = patlist.split(',')
176 res.extend(once_filter(recfind(pth, pats)))
176 res.extend(once_filter(recfind(pth, pats)))
177 # filelist
177 # filelist
178 elif ent.startswith('@') and os.path.isfile(ent[1:]):
178 elif ent.startswith('@') and os.path.isfile(ent[1:]):
179 res.extend(once_filter(open(ent[1:]).read().splitlines()))
179 res.extend(once_filter(open(ent[1:]).read().splitlines()))
180 # exclusion
180 # exclusion
181 elif ent.startswith('!'):
181 elif ent.startswith('!'):
182 denied_set.add(ent[1:])
182 denied_set.add(ent[1:])
183 # glob only dirs
183 # glob only dirs
184 elif ent.lower().startswith('dir:'):
184 elif ent.lower().startswith('dir:'):
185 res.extend(once_filter(filter(os.path.isdir,glob.glob(ent[4:]))))
185 res.extend(once_filter(filter(os.path.isdir,glob.glob(ent[4:]))))
186 elif ent.lower().startswith('cont:'):
186 elif ent.lower().startswith('cont:'):
187 cont_set.add(ent[5:])
187 cont_set.add(ent[5:])
188 # get all files in the specified dir
188 # get all files in the specified dir
189 elif os.path.isdir(ent) and exp_dirs:
189 elif os.path.isdir(ent) and exp_dirs:
190 res.extend(once_filter(filter(os.path.isfile,glob.glob(ent + os.sep+"*"))))
190 res.extend(once_filter(filter(os.path.isfile,glob.glob(ent + os.sep+"*"))))
191
191
192 # glob only files
192 # glob only files
193
193
194 elif '*' in ent or '?' in ent:
194 elif '*' in ent or '?' in ent:
195 res.extend(once_filter(filter(os.path.isfile,glob.glob(ent))))
195 res.extend(once_filter(filter(os.path.isfile,glob.glob(ent))))
196
196
197 else:
197 else:
198 res.extend(once_filter([ent]))
198 res.extend(once_filter([ent]))
199 return res
199 return res
200
200
201
201
202 def test():
202 def test():
203 assert (
203 assert (
204 expand("*.py ~/.ipython/*.py rec:/usr/share/doc-base") ==
204 expand("*.py ~/.ipython/*.py rec:/usr/share/doc-base") ==
205 expand( ['*.py', '~/.ipython/*.py', 'rec:/usr/share/doc-base'] )
205 expand( ['*.py', '~/.ipython/*.py', 'rec:/usr/share/doc-base'] )
206 )
206 )
207
207
208 def main():
208 def main():
209 if len(sys.argv) < 2:
209 if len(sys.argv) < 2:
210 print globsyntax
210 print globsyntax
211 return
211 return
212
212
213 print "\n".join(expand(sys.argv[1:])),
213 print "\n".join(expand(sys.argv[1:])),
214
214
215 def mglob_f(self, arg):
215 def mglob_f(self, arg):
216 from IPython.genutils import SList
216 from IPython.utils.genutils import SList
217 if arg.strip():
217 if arg.strip():
218 return SList(expand(arg))
218 return SList(expand(arg))
219 print "Please specify pattern!"
219 print "Please specify pattern!"
220 print globsyntax
220 print globsyntax
221
221
222 def init_ipython(ip):
222 def init_ipython(ip):
223 """ register %mglob for IPython """
223 """ register %mglob for IPython """
224 mglob_f.__doc__ = globsyntax
224 mglob_f.__doc__ = globsyntax
225 ip.expose_magic("mglob",mglob_f)
225 ip.expose_magic("mglob",mglob_f)
226
226
227 # test()
227 # test()
228 if __name__ == "__main__":
228 if __name__ == "__main__":
229 main()
229 main()
@@ -1,285 +1,285 b''
1 """
1 """
2 Frontend class that uses IPython0 to prefilter the inputs.
2 Frontend class that uses IPython0 to prefilter the inputs.
3
3
4 Using the IPython0 mechanism gives us access to the magics.
4 Using the IPython0 mechanism gives us access to the magics.
5
5
6 This is a transitory class, used here to do the transition between
6 This is a transitory class, used here to do the transition between
7 ipython0 and ipython1. This class is meant to be short-lived as more
7 ipython0 and ipython1. This class is meant to be short-lived as more
8 functionnality is abstracted out of ipython0 in reusable functions and
8 functionnality is abstracted out of ipython0 in reusable functions and
9 is added on the interpreter. This class can be a used to guide this
9 is added on the interpreter. This class can be a used to guide this
10 refactoring.
10 refactoring.
11 """
11 """
12 __docformat__ = "restructuredtext en"
12 __docformat__ = "restructuredtext en"
13
13
14 #-------------------------------------------------------------------------------
14 #-------------------------------------------------------------------------------
15 # Copyright (C) 2008 The IPython Development Team
15 # Copyright (C) 2008 The IPython Development Team
16 #
16 #
17 # Distributed under the terms of the BSD License. The full license is in
17 # Distributed under the terms of the BSD License. The full license is in
18 # the file COPYING, distributed as part of this software.
18 # the file COPYING, distributed as part of this software.
19 #-------------------------------------------------------------------------------
19 #-------------------------------------------------------------------------------
20
20
21 #-------------------------------------------------------------------------------
21 #-------------------------------------------------------------------------------
22 # Imports
22 # Imports
23 #-------------------------------------------------------------------------------
23 #-------------------------------------------------------------------------------
24 import sys
24 import sys
25 import pydoc
25 import pydoc
26 import os
26 import os
27 import re
27 import re
28 import __builtin__
28 import __builtin__
29
29
30 from IPython.ipmaker import make_IPython
30 from IPython.ipmaker import make_IPython
31 from IPython.ipapi import IPApi
31 from IPython.ipapi import IPApi
32 from IPython.kernel.core.redirector_output_trap import RedirectorOutputTrap
32 from IPython.kernel.core.redirector_output_trap import RedirectorOutputTrap
33
33
34 from IPython.kernel.core.sync_traceback_trap import SyncTracebackTrap
34 from IPython.kernel.core.sync_traceback_trap import SyncTracebackTrap
35
35
36 from IPython.genutils import Term
36 from IPython.utils.genutils import Term
37
37
38 from linefrontendbase import LineFrontEndBase, common_prefix
38 from linefrontendbase import LineFrontEndBase, common_prefix
39
39
40
40
41 def mk_system_call(system_call_function, command):
41 def mk_system_call(system_call_function, command):
42 """ given a os.system replacement, and a leading string command,
42 """ given a os.system replacement, and a leading string command,
43 returns a function that will execute the command with the given
43 returns a function that will execute the command with the given
44 argument string.
44 argument string.
45 """
45 """
46 def my_system_call(args):
46 def my_system_call(args):
47 system_call_function("%s %s" % (command, args))
47 system_call_function("%s %s" % (command, args))
48
48
49 my_system_call.__doc__ = "Calls %s" % command
49 my_system_call.__doc__ = "Calls %s" % command
50 return my_system_call
50 return my_system_call
51
51
52 #-------------------------------------------------------------------------------
52 #-------------------------------------------------------------------------------
53 # Frontend class using ipython0 to do the prefiltering.
53 # Frontend class using ipython0 to do the prefiltering.
54 #-------------------------------------------------------------------------------
54 #-------------------------------------------------------------------------------
55 class PrefilterFrontEnd(LineFrontEndBase):
55 class PrefilterFrontEnd(LineFrontEndBase):
56 """ Class that uses ipython0 to do prefilter the input, do the
56 """ Class that uses ipython0 to do prefilter the input, do the
57 completion and the magics.
57 completion and the magics.
58
58
59 The core trick is to use an ipython0 instance to prefilter the
59 The core trick is to use an ipython0 instance to prefilter the
60 input, and share the namespace between the interpreter instance used
60 input, and share the namespace between the interpreter instance used
61 to execute the statements and the ipython0 used for code
61 to execute the statements and the ipython0 used for code
62 completion...
62 completion...
63 """
63 """
64
64
65 debug = False
65 debug = False
66
66
67 def __init__(self, ipython0=None, argv=None, *args, **kwargs):
67 def __init__(self, ipython0=None, argv=None, *args, **kwargs):
68 """ Parameters:
68 """ Parameters:
69 -----------
69 -----------
70
70
71 ipython0: an optional ipython0 instance to use for command
71 ipython0: an optional ipython0 instance to use for command
72 prefiltering and completion.
72 prefiltering and completion.
73
73
74 argv : list, optional
74 argv : list, optional
75 Used as the instance's argv value. If not given, [] is used.
75 Used as the instance's argv value. If not given, [] is used.
76 """
76 """
77 if argv is None:
77 if argv is None:
78 argv = []
78 argv = []
79 # This is a hack to avoid the IPython exception hook to trigger
79 # This is a hack to avoid the IPython exception hook to trigger
80 # on exceptions (https://bugs.launchpad.net/bugs/337105)
80 # on exceptions (https://bugs.launchpad.net/bugs/337105)
81 # XXX: This is horrible: module-leve monkey patching -> side
81 # XXX: This is horrible: module-leve monkey patching -> side
82 # effects.
82 # effects.
83 from IPython import iplib
83 from IPython import iplib
84 iplib.InteractiveShell.isthreaded = True
84 iplib.InteractiveShell.isthreaded = True
85
85
86 LineFrontEndBase.__init__(self, *args, **kwargs)
86 LineFrontEndBase.__init__(self, *args, **kwargs)
87 self.shell.output_trap = RedirectorOutputTrap(
87 self.shell.output_trap = RedirectorOutputTrap(
88 out_callback=self.write,
88 out_callback=self.write,
89 err_callback=self.write,
89 err_callback=self.write,
90 )
90 )
91 self.shell.traceback_trap = SyncTracebackTrap(
91 self.shell.traceback_trap = SyncTracebackTrap(
92 formatters=self.shell.traceback_trap.formatters,
92 formatters=self.shell.traceback_trap.formatters,
93 )
93 )
94
94
95 # Start the ipython0 instance:
95 # Start the ipython0 instance:
96 self.save_output_hooks()
96 self.save_output_hooks()
97 if ipython0 is None:
97 if ipython0 is None:
98 # Instanciate an IPython0 interpreter to be able to use the
98 # Instanciate an IPython0 interpreter to be able to use the
99 # prefiltering.
99 # prefiltering.
100 # Suppress all key input, to avoid waiting
100 # Suppress all key input, to avoid waiting
101 def my_rawinput(x=None):
101 def my_rawinput(x=None):
102 return '\n'
102 return '\n'
103 old_rawinput = __builtin__.raw_input
103 old_rawinput = __builtin__.raw_input
104 __builtin__.raw_input = my_rawinput
104 __builtin__.raw_input = my_rawinput
105 # XXX: argv=[] is a bit bold.
105 # XXX: argv=[] is a bit bold.
106 ipython0 = make_IPython(argv=argv,
106 ipython0 = make_IPython(argv=argv,
107 user_ns=self.shell.user_ns,
107 user_ns=self.shell.user_ns,
108 user_global_ns=self.shell.user_global_ns)
108 user_global_ns=self.shell.user_global_ns)
109 __builtin__.raw_input = old_rawinput
109 __builtin__.raw_input = old_rawinput
110 self.ipython0 = ipython0
110 self.ipython0 = ipython0
111 # Set the pager:
111 # Set the pager:
112 self.ipython0.set_hook('show_in_pager',
112 self.ipython0.set_hook('show_in_pager',
113 lambda s, string: self.write("\n" + string))
113 lambda s, string: self.write("\n" + string))
114 self.ipython0.write = self.write
114 self.ipython0.write = self.write
115 self._ip = _ip = IPApi(self.ipython0)
115 self._ip = _ip = IPApi(self.ipython0)
116 # Make sure the raw system call doesn't get called, as we don't
116 # Make sure the raw system call doesn't get called, as we don't
117 # have a stdin accessible.
117 # have a stdin accessible.
118 self._ip.system = self.system_call
118 self._ip.system = self.system_call
119 # XXX: Muck around with magics so that they work better
119 # XXX: Muck around with magics so that they work better
120 # in our environment
120 # in our environment
121 if not sys.platform.startswith('win'):
121 if not sys.platform.startswith('win'):
122 self.ipython0.magic_ls = mk_system_call(self.system_call,
122 self.ipython0.magic_ls = mk_system_call(self.system_call,
123 'ls -CF')
123 'ls -CF')
124 # And now clean up the mess created by ipython0
124 # And now clean up the mess created by ipython0
125 self.release_output()
125 self.release_output()
126
126
127
127
128 if not 'banner' in kwargs and self.banner is None:
128 if not 'banner' in kwargs and self.banner is None:
129 self.banner = self.ipython0.BANNER
129 self.banner = self.ipython0.BANNER
130
130
131 # FIXME: __init__ and start should be two different steps
131 # FIXME: __init__ and start should be two different steps
132 self.start()
132 self.start()
133
133
134 #--------------------------------------------------------------------------
134 #--------------------------------------------------------------------------
135 # FrontEndBase interface
135 # FrontEndBase interface
136 #--------------------------------------------------------------------------
136 #--------------------------------------------------------------------------
137
137
138 def show_traceback(self):
138 def show_traceback(self):
139 """ Use ipython0 to capture the last traceback and display it.
139 """ Use ipython0 to capture the last traceback and display it.
140 """
140 """
141 # Don't do the capture; the except_hook has already done some
141 # Don't do the capture; the except_hook has already done some
142 # modifications to the IO streams, if we store them, we'll be
142 # modifications to the IO streams, if we store them, we'll be
143 # storing the wrong ones.
143 # storing the wrong ones.
144 #self.capture_output()
144 #self.capture_output()
145 self.ipython0.showtraceback(tb_offset=-1)
145 self.ipython0.showtraceback(tb_offset=-1)
146 self.release_output()
146 self.release_output()
147
147
148
148
149 def execute(self, python_string, raw_string=None):
149 def execute(self, python_string, raw_string=None):
150 if self.debug:
150 if self.debug:
151 print 'Executing Python code:', repr(python_string)
151 print 'Executing Python code:', repr(python_string)
152 self.capture_output()
152 self.capture_output()
153 LineFrontEndBase.execute(self, python_string,
153 LineFrontEndBase.execute(self, python_string,
154 raw_string=raw_string)
154 raw_string=raw_string)
155 self.release_output()
155 self.release_output()
156
156
157
157
158 def save_output_hooks(self):
158 def save_output_hooks(self):
159 """ Store all the output hooks we can think of, to be able to
159 """ Store all the output hooks we can think of, to be able to
160 restore them.
160 restore them.
161
161
162 We need to do this early, as starting the ipython0 instance will
162 We need to do this early, as starting the ipython0 instance will
163 screw ouput hooks.
163 screw ouput hooks.
164 """
164 """
165 self.__old_cout_write = Term.cout.write
165 self.__old_cout_write = Term.cout.write
166 self.__old_cerr_write = Term.cerr.write
166 self.__old_cerr_write = Term.cerr.write
167 self.__old_stdout = sys.stdout
167 self.__old_stdout = sys.stdout
168 self.__old_stderr= sys.stderr
168 self.__old_stderr= sys.stderr
169 self.__old_help_output = pydoc.help.output
169 self.__old_help_output = pydoc.help.output
170 self.__old_display_hook = sys.displayhook
170 self.__old_display_hook = sys.displayhook
171
171
172
172
173 def capture_output(self):
173 def capture_output(self):
174 """ Capture all the output mechanisms we can think of.
174 """ Capture all the output mechanisms we can think of.
175 """
175 """
176 self.save_output_hooks()
176 self.save_output_hooks()
177 Term.cout.write = self.write
177 Term.cout.write = self.write
178 Term.cerr.write = self.write
178 Term.cerr.write = self.write
179 sys.stdout = Term.cout
179 sys.stdout = Term.cout
180 sys.stderr = Term.cerr
180 sys.stderr = Term.cerr
181 pydoc.help.output = self.shell.output_trap.out
181 pydoc.help.output = self.shell.output_trap.out
182
182
183
183
184 def release_output(self):
184 def release_output(self):
185 """ Release all the different captures we have made.
185 """ Release all the different captures we have made.
186 """
186 """
187 Term.cout.write = self.__old_cout_write
187 Term.cout.write = self.__old_cout_write
188 Term.cerr.write = self.__old_cerr_write
188 Term.cerr.write = self.__old_cerr_write
189 sys.stdout = self.__old_stdout
189 sys.stdout = self.__old_stdout
190 sys.stderr = self.__old_stderr
190 sys.stderr = self.__old_stderr
191 pydoc.help.output = self.__old_help_output
191 pydoc.help.output = self.__old_help_output
192 sys.displayhook = self.__old_display_hook
192 sys.displayhook = self.__old_display_hook
193
193
194
194
195 def complete(self, line):
195 def complete(self, line):
196 # FIXME: This should be factored out in the linefrontendbase
196 # FIXME: This should be factored out in the linefrontendbase
197 # method.
197 # method.
198 word = self._get_completion_text(line)
198 word = self._get_completion_text(line)
199 completions = self.ipython0.complete(word)
199 completions = self.ipython0.complete(word)
200 # FIXME: The proper sort should be done in the complete method.
200 # FIXME: The proper sort should be done in the complete method.
201 key = lambda x: x.replace('_', '')
201 key = lambda x: x.replace('_', '')
202 completions.sort(key=key)
202 completions.sort(key=key)
203 if completions:
203 if completions:
204 prefix = common_prefix(completions)
204 prefix = common_prefix(completions)
205 line = line[:-len(word)] + prefix
205 line = line[:-len(word)] + prefix
206 return line, completions
206 return line, completions
207
207
208
208
209 #--------------------------------------------------------------------------
209 #--------------------------------------------------------------------------
210 # LineFrontEndBase interface
210 # LineFrontEndBase interface
211 #--------------------------------------------------------------------------
211 #--------------------------------------------------------------------------
212
212
213 def prefilter_input(self, input_string):
213 def prefilter_input(self, input_string):
214 """ Using IPython0 to prefilter the commands to turn them
214 """ Using IPython0 to prefilter the commands to turn them
215 in executable statements that are valid Python strings.
215 in executable statements that are valid Python strings.
216 """
216 """
217 input_string = LineFrontEndBase.prefilter_input(self, input_string)
217 input_string = LineFrontEndBase.prefilter_input(self, input_string)
218 filtered_lines = []
218 filtered_lines = []
219 # The IPython0 prefilters sometime produce output. We need to
219 # The IPython0 prefilters sometime produce output. We need to
220 # capture it.
220 # capture it.
221 self.capture_output()
221 self.capture_output()
222 self.last_result = dict(number=self.prompt_number)
222 self.last_result = dict(number=self.prompt_number)
223
223
224 ## try:
224 ## try:
225 ## for line in input_string.split('\n'):
225 ## for line in input_string.split('\n'):
226 ## filtered_lines.append(
226 ## filtered_lines.append(
227 ## self.ipython0.prefilter(line, False).rstrip())
227 ## self.ipython0.prefilter(line, False).rstrip())
228 ## except:
228 ## except:
229 ## # XXX: probably not the right thing to do.
229 ## # XXX: probably not the right thing to do.
230 ## self.ipython0.showsyntaxerror()
230 ## self.ipython0.showsyntaxerror()
231 ## self.after_execute()
231 ## self.after_execute()
232 ## finally:
232 ## finally:
233 ## self.release_output()
233 ## self.release_output()
234
234
235
235
236 try:
236 try:
237 try:
237 try:
238 for line in input_string.split('\n'):
238 for line in input_string.split('\n'):
239 filtered_lines.append(
239 filtered_lines.append(
240 self.ipython0.prefilter(line, False).rstrip())
240 self.ipython0.prefilter(line, False).rstrip())
241 except:
241 except:
242 # XXX: probably not the right thing to do.
242 # XXX: probably not the right thing to do.
243 self.ipython0.showsyntaxerror()
243 self.ipython0.showsyntaxerror()
244 self.after_execute()
244 self.after_execute()
245 finally:
245 finally:
246 self.release_output()
246 self.release_output()
247
247
248
248
249
249
250 # Clean up the trailing whitespace, to avoid indentation errors
250 # Clean up the trailing whitespace, to avoid indentation errors
251 filtered_string = '\n'.join(filtered_lines)
251 filtered_string = '\n'.join(filtered_lines)
252 return filtered_string
252 return filtered_string
253
253
254
254
255 #--------------------------------------------------------------------------
255 #--------------------------------------------------------------------------
256 # PrefilterFrontEnd interface
256 # PrefilterFrontEnd interface
257 #--------------------------------------------------------------------------
257 #--------------------------------------------------------------------------
258
258
259 def system_call(self, command_string):
259 def system_call(self, command_string):
260 """ Allows for frontend to define their own system call, to be
260 """ Allows for frontend to define their own system call, to be
261 able capture output and redirect input.
261 able capture output and redirect input.
262 """
262 """
263 return os.system(command_string)
263 return os.system(command_string)
264
264
265
265
266 def do_exit(self):
266 def do_exit(self):
267 """ Exit the shell, cleanup and save the history.
267 """ Exit the shell, cleanup and save the history.
268 """
268 """
269 self.ipython0.atexit_operations()
269 self.ipython0.atexit_operations()
270
270
271
271
272 def _get_completion_text(self, line):
272 def _get_completion_text(self, line):
273 """ Returns the text to be completed by breaking the line at specified
273 """ Returns the text to be completed by breaking the line at specified
274 delimiters.
274 delimiters.
275 """
275 """
276 # Break at: spaces, '=', all parentheses (except if balanced).
276 # Break at: spaces, '=', all parentheses (except if balanced).
277 # FIXME2: In the future, we need to make the implementation similar to
277 # FIXME2: In the future, we need to make the implementation similar to
278 # that in the 'pyreadline' module (modes/basemode.py) where we break at
278 # that in the 'pyreadline' module (modes/basemode.py) where we break at
279 # each delimiter and try to complete the residual line, until we get a
279 # each delimiter and try to complete the residual line, until we get a
280 # successful list of completions.
280 # successful list of completions.
281 expression = '\s|=|,|:|\((?!.*\))|\[(?!.*\])|\{(?!.*\})'
281 expression = '\s|=|,|:|\((?!.*\))|\[(?!.*\])|\{(?!.*\})'
282 complete_sep = re.compile(expression)
282 complete_sep = re.compile(expression)
283 text = complete_sep.split(line)[-1]
283 text = complete_sep.split(line)[-1]
284 return text
284 return text
285
285
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 NO CONTENT: modified file
NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
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 NO CONTENT: modified file
NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
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 NO CONTENT: modified file
NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
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 NO CONTENT: modified file
NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
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 NO CONTENT: modified file
NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
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 NO CONTENT: modified file
NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
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 NO CONTENT: modified file
NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
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 NO CONTENT: modified file
NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
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 NO CONTENT: modified file
NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
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 NO CONTENT: modified file
NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
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 NO CONTENT: modified file
NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
1 NO CONTENT: file renamed from IPython/genutils.py to IPython/utils/genutils.py
NO CONTENT: file renamed from IPython/genutils.py to IPython/utils/genutils.py
1 NO CONTENT: file renamed from IPython/tests/test_genutils.py to IPython/utils/tests/test_genutils.py
NO CONTENT: file renamed from IPython/tests/test_genutils.py to IPython/utils/tests/test_genutils.py
The requested commit or file is too big and content was truncated. Show full diff
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 NO CONTENT: modified file
NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
1 NO CONTENT: modified file
NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
General Comments 0
You need to be logged in to leave comments. Login now