##// END OF EJS Templates
time(it) magic: reorganize time formatting code...
Jan Schulz -
Show More
@@ -1,1116 +1,1115 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Implementation of execution-related magic functions.
2 """Implementation of execution-related magic functions.
3 """
3 """
4 #-----------------------------------------------------------------------------
4 #-----------------------------------------------------------------------------
5 # Copyright (c) 2012 The IPython Development Team.
5 # Copyright (c) 2012 The IPython Development Team.
6 #
6 #
7 # Distributed under the terms of the Modified BSD License.
7 # Distributed under the terms of the Modified BSD License.
8 #
8 #
9 # The full license is in the file COPYING.txt, distributed with this software.
9 # The full license is in the file COPYING.txt, distributed with this software.
10 #-----------------------------------------------------------------------------
10 #-----------------------------------------------------------------------------
11
11
12 #-----------------------------------------------------------------------------
12 #-----------------------------------------------------------------------------
13 # Imports
13 # Imports
14 #-----------------------------------------------------------------------------
14 #-----------------------------------------------------------------------------
15
15
16 # Stdlib
16 # Stdlib
17 import __builtin__ as builtin_mod
17 import __builtin__ as builtin_mod
18 import ast
18 import ast
19 import bdb
19 import bdb
20 import os
20 import os
21 import sys
21 import sys
22 import time
22 import time
23 from StringIO import StringIO
23 from StringIO import StringIO
24
24
25 # cProfile was added in Python2.5
25 # cProfile was added in Python2.5
26 try:
26 try:
27 import cProfile as profile
27 import cProfile as profile
28 import pstats
28 import pstats
29 except ImportError:
29 except ImportError:
30 # profile isn't bundled by default in Debian for license reasons
30 # profile isn't bundled by default in Debian for license reasons
31 try:
31 try:
32 import profile, pstats
32 import profile, pstats
33 except ImportError:
33 except ImportError:
34 profile = pstats = None
34 profile = pstats = None
35
35
36 # Our own packages
36 # Our own packages
37 from IPython.core import debugger, oinspect
37 from IPython.core import debugger, oinspect
38 from IPython.core import magic_arguments
38 from IPython.core import magic_arguments
39 from IPython.core import page
39 from IPython.core import page
40 from IPython.core.error import UsageError
40 from IPython.core.error import UsageError
41 from IPython.core.macro import Macro
41 from IPython.core.macro import Macro
42 from IPython.core.magic import (Magics, magics_class, line_magic, cell_magic,
42 from IPython.core.magic import (Magics, magics_class, line_magic, cell_magic,
43 line_cell_magic, on_off, needs_local_scope)
43 line_cell_magic, on_off, needs_local_scope)
44 from IPython.testing.skipdoctest import skip_doctest
44 from IPython.testing.skipdoctest import skip_doctest
45 from IPython.utils import py3compat
45 from IPython.utils import py3compat
46 from IPython.utils.contexts import preserve_keys
46 from IPython.utils.contexts import preserve_keys
47 from IPython.utils.io import capture_output
47 from IPython.utils.io import capture_output
48 from IPython.utils.ipstruct import Struct
48 from IPython.utils.ipstruct import Struct
49 from IPython.utils.module_paths import find_mod
49 from IPython.utils.module_paths import find_mod
50 from IPython.utils.path import get_py_filename, unquote_filename, shellglob
50 from IPython.utils.path import get_py_filename, unquote_filename, shellglob
51 from IPython.utils.timing import clock, clock2
51 from IPython.utils.timing import clock, clock2
52 from IPython.utils.warn import warn, error
52 from IPython.utils.warn import warn, error
53
53
54
54
55 #-----------------------------------------------------------------------------
55 #-----------------------------------------------------------------------------
56 # Magic implementation classes
56 # Magic implementation classes
57 #-----------------------------------------------------------------------------
57 #-----------------------------------------------------------------------------
58
58
59 @magics_class
59 @magics_class
60 class ExecutionMagics(Magics):
60 class ExecutionMagics(Magics):
61 """Magics related to code execution, debugging, profiling, etc.
61 """Magics related to code execution, debugging, profiling, etc.
62
62
63 """
63 """
64
64
65 def __init__(self, shell):
65 def __init__(self, shell):
66 super(ExecutionMagics, self).__init__(shell)
66 super(ExecutionMagics, self).__init__(shell)
67 if profile is None:
67 if profile is None:
68 self.prun = self.profile_missing_notice
68 self.prun = self.profile_missing_notice
69 # Default execution function used to actually run user code.
69 # Default execution function used to actually run user code.
70 self.default_runner = None
70 self.default_runner = None
71
71
72 def profile_missing_notice(self, *args, **kwargs):
72 def profile_missing_notice(self, *args, **kwargs):
73 error("""\
73 error("""\
74 The profile module could not be found. It has been removed from the standard
74 The profile module could not be found. It has been removed from the standard
75 python packages because of its non-free license. To use profiling, install the
75 python packages because of its non-free license. To use profiling, install the
76 python-profiler package from non-free.""")
76 python-profiler package from non-free.""")
77
77
78 @skip_doctest
78 @skip_doctest
79 @line_cell_magic
79 @line_cell_magic
80 def prun(self, parameter_s='', cell=None, user_mode=True,
80 def prun(self, parameter_s='', cell=None, user_mode=True,
81 opts=None,arg_lst=None,prog_ns=None):
81 opts=None,arg_lst=None,prog_ns=None):
82
82
83 """Run a statement through the python code profiler.
83 """Run a statement through the python code profiler.
84
84
85 Usage, in line mode:
85 Usage, in line mode:
86 %prun [options] statement
86 %prun [options] statement
87
87
88 Usage, in cell mode:
88 Usage, in cell mode:
89 %%prun [options] [statement]
89 %%prun [options] [statement]
90 code...
90 code...
91 code...
91 code...
92
92
93 In cell mode, the additional code lines are appended to the (possibly
93 In cell mode, the additional code lines are appended to the (possibly
94 empty) statement in the first line. Cell mode allows you to easily
94 empty) statement in the first line. Cell mode allows you to easily
95 profile multiline blocks without having to put them in a separate
95 profile multiline blocks without having to put them in a separate
96 function.
96 function.
97
97
98 The given statement (which doesn't require quote marks) is run via the
98 The given statement (which doesn't require quote marks) is run via the
99 python profiler in a manner similar to the profile.run() function.
99 python profiler in a manner similar to the profile.run() function.
100 Namespaces are internally managed to work correctly; profile.run
100 Namespaces are internally managed to work correctly; profile.run
101 cannot be used in IPython because it makes certain assumptions about
101 cannot be used in IPython because it makes certain assumptions about
102 namespaces which do not hold under IPython.
102 namespaces which do not hold under IPython.
103
103
104 Options:
104 Options:
105
105
106 -l <limit>: you can place restrictions on what or how much of the
106 -l <limit>: you can place restrictions on what or how much of the
107 profile gets printed. The limit value can be:
107 profile gets printed. The limit value can be:
108
108
109 * A string: only information for function names containing this string
109 * A string: only information for function names containing this string
110 is printed.
110 is printed.
111
111
112 * An integer: only these many lines are printed.
112 * An integer: only these many lines are printed.
113
113
114 * A float (between 0 and 1): this fraction of the report is printed
114 * A float (between 0 and 1): this fraction of the report is printed
115 (for example, use a limit of 0.4 to see the topmost 40% only).
115 (for example, use a limit of 0.4 to see the topmost 40% only).
116
116
117 You can combine several limits with repeated use of the option. For
117 You can combine several limits with repeated use of the option. For
118 example, '-l __init__ -l 5' will print only the topmost 5 lines of
118 example, '-l __init__ -l 5' will print only the topmost 5 lines of
119 information about class constructors.
119 information about class constructors.
120
120
121 -r: return the pstats.Stats object generated by the profiling. This
121 -r: return the pstats.Stats object generated by the profiling. This
122 object has all the information about the profile in it, and you can
122 object has all the information about the profile in it, and you can
123 later use it for further analysis or in other functions.
123 later use it for further analysis or in other functions.
124
124
125 -s <key>: sort profile by given key. You can provide more than one key
125 -s <key>: sort profile by given key. You can provide more than one key
126 by using the option several times: '-s key1 -s key2 -s key3...'. The
126 by using the option several times: '-s key1 -s key2 -s key3...'. The
127 default sorting key is 'time'.
127 default sorting key is 'time'.
128
128
129 The following is copied verbatim from the profile documentation
129 The following is copied verbatim from the profile documentation
130 referenced below:
130 referenced below:
131
131
132 When more than one key is provided, additional keys are used as
132 When more than one key is provided, additional keys are used as
133 secondary criteria when the there is equality in all keys selected
133 secondary criteria when the there is equality in all keys selected
134 before them.
134 before them.
135
135
136 Abbreviations can be used for any key names, as long as the
136 Abbreviations can be used for any key names, as long as the
137 abbreviation is unambiguous. The following are the keys currently
137 abbreviation is unambiguous. The following are the keys currently
138 defined:
138 defined:
139
139
140 Valid Arg Meaning
140 Valid Arg Meaning
141 "calls" call count
141 "calls" call count
142 "cumulative" cumulative time
142 "cumulative" cumulative time
143 "file" file name
143 "file" file name
144 "module" file name
144 "module" file name
145 "pcalls" primitive call count
145 "pcalls" primitive call count
146 "line" line number
146 "line" line number
147 "name" function name
147 "name" function name
148 "nfl" name/file/line
148 "nfl" name/file/line
149 "stdname" standard name
149 "stdname" standard name
150 "time" internal time
150 "time" internal time
151
151
152 Note that all sorts on statistics are in descending order (placing
152 Note that all sorts on statistics are in descending order (placing
153 most time consuming items first), where as name, file, and line number
153 most time consuming items first), where as name, file, and line number
154 searches are in ascending order (i.e., alphabetical). The subtle
154 searches are in ascending order (i.e., alphabetical). The subtle
155 distinction between "nfl" and "stdname" is that the standard name is a
155 distinction between "nfl" and "stdname" is that the standard name is a
156 sort of the name as printed, which means that the embedded line
156 sort of the name as printed, which means that the embedded line
157 numbers get compared in an odd way. For example, lines 3, 20, and 40
157 numbers get compared in an odd way. For example, lines 3, 20, and 40
158 would (if the file names were the same) appear in the string order
158 would (if the file names were the same) appear in the string order
159 "20" "3" and "40". In contrast, "nfl" does a numeric compare of the
159 "20" "3" and "40". In contrast, "nfl" does a numeric compare of the
160 line numbers. In fact, sort_stats("nfl") is the same as
160 line numbers. In fact, sort_stats("nfl") is the same as
161 sort_stats("name", "file", "line").
161 sort_stats("name", "file", "line").
162
162
163 -T <filename>: save profile results as shown on screen to a text
163 -T <filename>: save profile results as shown on screen to a text
164 file. The profile is still shown on screen.
164 file. The profile is still shown on screen.
165
165
166 -D <filename>: save (via dump_stats) profile statistics to given
166 -D <filename>: save (via dump_stats) profile statistics to given
167 filename. This data is in a format understood by the pstats module, and
167 filename. This data is in a format understood by the pstats module, and
168 is generated by a call to the dump_stats() method of profile
168 is generated by a call to the dump_stats() method of profile
169 objects. The profile is still shown on screen.
169 objects. The profile is still shown on screen.
170
170
171 -q: suppress output to the pager. Best used with -T and/or -D above.
171 -q: suppress output to the pager. Best used with -T and/or -D above.
172
172
173 If you want to run complete programs under the profiler's control, use
173 If you want to run complete programs under the profiler's control, use
174 '%run -p [prof_opts] filename.py [args to program]' where prof_opts
174 '%run -p [prof_opts] filename.py [args to program]' where prof_opts
175 contains profiler specific options as described here.
175 contains profiler specific options as described here.
176
176
177 You can read the complete documentation for the profile module with::
177 You can read the complete documentation for the profile module with::
178
178
179 In [1]: import profile; profile.help()
179 In [1]: import profile; profile.help()
180 """
180 """
181
181
182 opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
182 opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
183
183
184 if user_mode: # regular user call
184 if user_mode: # regular user call
185 opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:q',
185 opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:q',
186 list_all=True, posix=False)
186 list_all=True, posix=False)
187 namespace = self.shell.user_ns
187 namespace = self.shell.user_ns
188 if cell is not None:
188 if cell is not None:
189 arg_str += '\n' + cell
189 arg_str += '\n' + cell
190 else: # called to run a program by %run -p
190 else: # called to run a program by %run -p
191 try:
191 try:
192 filename = get_py_filename(arg_lst[0])
192 filename = get_py_filename(arg_lst[0])
193 except IOError as e:
193 except IOError as e:
194 try:
194 try:
195 msg = str(e)
195 msg = str(e)
196 except UnicodeError:
196 except UnicodeError:
197 msg = e.message
197 msg = e.message
198 error(msg)
198 error(msg)
199 return
199 return
200
200
201 arg_str = 'execfile(filename,prog_ns)'
201 arg_str = 'execfile(filename,prog_ns)'
202 namespace = {
202 namespace = {
203 'execfile': self.shell.safe_execfile,
203 'execfile': self.shell.safe_execfile,
204 'prog_ns': prog_ns,
204 'prog_ns': prog_ns,
205 'filename': filename
205 'filename': filename
206 }
206 }
207
207
208 opts.merge(opts_def)
208 opts.merge(opts_def)
209
209
210 prof = profile.Profile()
210 prof = profile.Profile()
211 try:
211 try:
212 prof = prof.runctx(arg_str,namespace,namespace)
212 prof = prof.runctx(arg_str,namespace,namespace)
213 sys_exit = ''
213 sys_exit = ''
214 except SystemExit:
214 except SystemExit:
215 sys_exit = """*** SystemExit exception caught in code being profiled."""
215 sys_exit = """*** SystemExit exception caught in code being profiled."""
216
216
217 stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
217 stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
218
218
219 lims = opts.l
219 lims = opts.l
220 if lims:
220 if lims:
221 lims = [] # rebuild lims with ints/floats/strings
221 lims = [] # rebuild lims with ints/floats/strings
222 for lim in opts.l:
222 for lim in opts.l:
223 try:
223 try:
224 lims.append(int(lim))
224 lims.append(int(lim))
225 except ValueError:
225 except ValueError:
226 try:
226 try:
227 lims.append(float(lim))
227 lims.append(float(lim))
228 except ValueError:
228 except ValueError:
229 lims.append(lim)
229 lims.append(lim)
230
230
231 # Trap output.
231 # Trap output.
232 stdout_trap = StringIO()
232 stdout_trap = StringIO()
233 stats_stream = stats.stream
233 stats_stream = stats.stream
234 try:
234 try:
235 stats.stream = stdout_trap
235 stats.stream = stdout_trap
236 stats.print_stats(*lims)
236 stats.print_stats(*lims)
237 finally:
237 finally:
238 stats.stream = stats_stream
238 stats.stream = stats_stream
239
239
240 output = stdout_trap.getvalue()
240 output = stdout_trap.getvalue()
241 output = output.rstrip()
241 output = output.rstrip()
242
242
243 if 'q' not in opts:
243 if 'q' not in opts:
244 page.page(output)
244 page.page(output)
245 print sys_exit,
245 print sys_exit,
246
246
247 dump_file = opts.D[0]
247 dump_file = opts.D[0]
248 text_file = opts.T[0]
248 text_file = opts.T[0]
249 if dump_file:
249 if dump_file:
250 dump_file = unquote_filename(dump_file)
250 dump_file = unquote_filename(dump_file)
251 prof.dump_stats(dump_file)
251 prof.dump_stats(dump_file)
252 print '\n*** Profile stats marshalled to file',\
252 print '\n*** Profile stats marshalled to file',\
253 repr(dump_file)+'.',sys_exit
253 repr(dump_file)+'.',sys_exit
254 if text_file:
254 if text_file:
255 text_file = unquote_filename(text_file)
255 text_file = unquote_filename(text_file)
256 pfile = open(text_file,'w')
256 pfile = open(text_file,'w')
257 pfile.write(output)
257 pfile.write(output)
258 pfile.close()
258 pfile.close()
259 print '\n*** Profile printout saved to text file',\
259 print '\n*** Profile printout saved to text file',\
260 repr(text_file)+'.',sys_exit
260 repr(text_file)+'.',sys_exit
261
261
262 if 'r' in opts:
262 if 'r' in opts:
263 return stats
263 return stats
264 else:
264 else:
265 return None
265 return None
266
266
267 @line_magic
267 @line_magic
268 def pdb(self, parameter_s=''):
268 def pdb(self, parameter_s=''):
269 """Control the automatic calling of the pdb interactive debugger.
269 """Control the automatic calling of the pdb interactive debugger.
270
270
271 Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
271 Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
272 argument it works as a toggle.
272 argument it works as a toggle.
273
273
274 When an exception is triggered, IPython can optionally call the
274 When an exception is triggered, IPython can optionally call the
275 interactive pdb debugger after the traceback printout. %pdb toggles
275 interactive pdb debugger after the traceback printout. %pdb toggles
276 this feature on and off.
276 this feature on and off.
277
277
278 The initial state of this feature is set in your configuration
278 The initial state of this feature is set in your configuration
279 file (the option is ``InteractiveShell.pdb``).
279 file (the option is ``InteractiveShell.pdb``).
280
280
281 If you want to just activate the debugger AFTER an exception has fired,
281 If you want to just activate the debugger AFTER an exception has fired,
282 without having to type '%pdb on' and rerunning your code, you can use
282 without having to type '%pdb on' and rerunning your code, you can use
283 the %debug magic."""
283 the %debug magic."""
284
284
285 par = parameter_s.strip().lower()
285 par = parameter_s.strip().lower()
286
286
287 if par:
287 if par:
288 try:
288 try:
289 new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
289 new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
290 except KeyError:
290 except KeyError:
291 print ('Incorrect argument. Use on/1, off/0, '
291 print ('Incorrect argument. Use on/1, off/0, '
292 'or nothing for a toggle.')
292 'or nothing for a toggle.')
293 return
293 return
294 else:
294 else:
295 # toggle
295 # toggle
296 new_pdb = not self.shell.call_pdb
296 new_pdb = not self.shell.call_pdb
297
297
298 # set on the shell
298 # set on the shell
299 self.shell.call_pdb = new_pdb
299 self.shell.call_pdb = new_pdb
300 print 'Automatic pdb calling has been turned',on_off(new_pdb)
300 print 'Automatic pdb calling has been turned',on_off(new_pdb)
301
301
302 @line_magic
302 @line_magic
303 def debug(self, parameter_s=''):
303 def debug(self, parameter_s=''):
304 """Activate the interactive debugger in post-mortem mode.
304 """Activate the interactive debugger in post-mortem mode.
305
305
306 If an exception has just occurred, this lets you inspect its stack
306 If an exception has just occurred, this lets you inspect its stack
307 frames interactively. Note that this will always work only on the last
307 frames interactively. Note that this will always work only on the last
308 traceback that occurred, so you must call this quickly after an
308 traceback that occurred, so you must call this quickly after an
309 exception that you wish to inspect has fired, because if another one
309 exception that you wish to inspect has fired, because if another one
310 occurs, it clobbers the previous one.
310 occurs, it clobbers the previous one.
311
311
312 If you want IPython to automatically do this on every exception, see
312 If you want IPython to automatically do this on every exception, see
313 the %pdb magic for more details.
313 the %pdb magic for more details.
314 """
314 """
315 self.shell.debugger(force=True)
315 self.shell.debugger(force=True)
316
316
317 @line_magic
317 @line_magic
318 def tb(self, s):
318 def tb(self, s):
319 """Print the last traceback with the currently active exception mode.
319 """Print the last traceback with the currently active exception mode.
320
320
321 See %xmode for changing exception reporting modes."""
321 See %xmode for changing exception reporting modes."""
322 self.shell.showtraceback()
322 self.shell.showtraceback()
323
323
324 @skip_doctest
324 @skip_doctest
325 @line_magic
325 @line_magic
326 def run(self, parameter_s='', runner=None,
326 def run(self, parameter_s='', runner=None,
327 file_finder=get_py_filename):
327 file_finder=get_py_filename):
328 """Run the named file inside IPython as a program.
328 """Run the named file inside IPython as a program.
329
329
330 Usage:\\
330 Usage:\\
331 %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options] -G] file [args]
331 %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options] -G] file [args]
332
332
333 Parameters after the filename are passed as command-line arguments to
333 Parameters after the filename are passed as command-line arguments to
334 the program (put in sys.argv). Then, control returns to IPython's
334 the program (put in sys.argv). Then, control returns to IPython's
335 prompt.
335 prompt.
336
336
337 This is similar to running at a system prompt:\\
337 This is similar to running at a system prompt:\\
338 $ python file args\\
338 $ python file args\\
339 but with the advantage of giving you IPython's tracebacks, and of
339 but with the advantage of giving you IPython's tracebacks, and of
340 loading all variables into your interactive namespace for further use
340 loading all variables into your interactive namespace for further use
341 (unless -p is used, see below).
341 (unless -p is used, see below).
342
342
343 The file is executed in a namespace initially consisting only of
343 The file is executed in a namespace initially consisting only of
344 __name__=='__main__' and sys.argv constructed as indicated. It thus
344 __name__=='__main__' and sys.argv constructed as indicated. It thus
345 sees its environment as if it were being run as a stand-alone program
345 sees its environment as if it were being run as a stand-alone program
346 (except for sharing global objects such as previously imported
346 (except for sharing global objects such as previously imported
347 modules). But after execution, the IPython interactive namespace gets
347 modules). But after execution, the IPython interactive namespace gets
348 updated with all variables defined in the program (except for __name__
348 updated with all variables defined in the program (except for __name__
349 and sys.argv). This allows for very convenient loading of code for
349 and sys.argv). This allows for very convenient loading of code for
350 interactive work, while giving each program a 'clean sheet' to run in.
350 interactive work, while giving each program a 'clean sheet' to run in.
351
351
352 Arguments are expanded using shell-like glob match. Patterns
352 Arguments are expanded using shell-like glob match. Patterns
353 '*', '?', '[seq]' and '[!seq]' can be used. Additionally,
353 '*', '?', '[seq]' and '[!seq]' can be used. Additionally,
354 tilde '~' will be expanded into user's home directory. Unlike
354 tilde '~' will be expanded into user's home directory. Unlike
355 real shells, quotation does not suppress expansions. Use
355 real shells, quotation does not suppress expansions. Use
356 *two* back slashes (e.g., '\\\\*') to suppress expansions.
356 *two* back slashes (e.g., '\\\\*') to suppress expansions.
357 To completely disable these expansions, you can use -G flag.
357 To completely disable these expansions, you can use -G flag.
358
358
359 Options:
359 Options:
360
360
361 -n: __name__ is NOT set to '__main__', but to the running file's name
361 -n: __name__ is NOT set to '__main__', but to the running file's name
362 without extension (as python does under import). This allows running
362 without extension (as python does under import). This allows running
363 scripts and reloading the definitions in them without calling code
363 scripts and reloading the definitions in them without calling code
364 protected by an ' if __name__ == "__main__" ' clause.
364 protected by an ' if __name__ == "__main__" ' clause.
365
365
366 -i: run the file in IPython's namespace instead of an empty one. This
366 -i: run the file in IPython's namespace instead of an empty one. This
367 is useful if you are experimenting with code written in a text editor
367 is useful if you are experimenting with code written in a text editor
368 which depends on variables defined interactively.
368 which depends on variables defined interactively.
369
369
370 -e: ignore sys.exit() calls or SystemExit exceptions in the script
370 -e: ignore sys.exit() calls or SystemExit exceptions in the script
371 being run. This is particularly useful if IPython is being used to
371 being run. This is particularly useful if IPython is being used to
372 run unittests, which always exit with a sys.exit() call. In such
372 run unittests, which always exit with a sys.exit() call. In such
373 cases you are interested in the output of the test results, not in
373 cases you are interested in the output of the test results, not in
374 seeing a traceback of the unittest module.
374 seeing a traceback of the unittest module.
375
375
376 -t: print timing information at the end of the run. IPython will give
376 -t: print timing information at the end of the run. IPython will give
377 you an estimated CPU time consumption for your script, which under
377 you an estimated CPU time consumption for your script, which under
378 Unix uses the resource module to avoid the wraparound problems of
378 Unix uses the resource module to avoid the wraparound problems of
379 time.clock(). Under Unix, an estimate of time spent on system tasks
379 time.clock(). Under Unix, an estimate of time spent on system tasks
380 is also given (for Windows platforms this is reported as 0.0).
380 is also given (for Windows platforms this is reported as 0.0).
381
381
382 If -t is given, an additional -N<N> option can be given, where <N>
382 If -t is given, an additional -N<N> option can be given, where <N>
383 must be an integer indicating how many times you want the script to
383 must be an integer indicating how many times you want the script to
384 run. The final timing report will include total and per run results.
384 run. The final timing report will include total and per run results.
385
385
386 For example (testing the script uniq_stable.py)::
386 For example (testing the script uniq_stable.py)::
387
387
388 In [1]: run -t uniq_stable
388 In [1]: run -t uniq_stable
389
389
390 IPython CPU timings (estimated):\\
390 IPython CPU timings (estimated):\\
391 User : 0.19597 s.\\
391 User : 0.19597 s.\\
392 System: 0.0 s.\\
392 System: 0.0 s.\\
393
393
394 In [2]: run -t -N5 uniq_stable
394 In [2]: run -t -N5 uniq_stable
395
395
396 IPython CPU timings (estimated):\\
396 IPython CPU timings (estimated):\\
397 Total runs performed: 5\\
397 Total runs performed: 5\\
398 Times : Total Per run\\
398 Times : Total Per run\\
399 User : 0.910862 s, 0.1821724 s.\\
399 User : 0.910862 s, 0.1821724 s.\\
400 System: 0.0 s, 0.0 s.
400 System: 0.0 s, 0.0 s.
401
401
402 -d: run your program under the control of pdb, the Python debugger.
402 -d: run your program under the control of pdb, the Python debugger.
403 This allows you to execute your program step by step, watch variables,
403 This allows you to execute your program step by step, watch variables,
404 etc. Internally, what IPython does is similar to calling:
404 etc. Internally, what IPython does is similar to calling:
405
405
406 pdb.run('execfile("YOURFILENAME")')
406 pdb.run('execfile("YOURFILENAME")')
407
407
408 with a breakpoint set on line 1 of your file. You can change the line
408 with a breakpoint set on line 1 of your file. You can change the line
409 number for this automatic breakpoint to be <N> by using the -bN option
409 number for this automatic breakpoint to be <N> by using the -bN option
410 (where N must be an integer). For example::
410 (where N must be an integer). For example::
411
411
412 %run -d -b40 myscript
412 %run -d -b40 myscript
413
413
414 will set the first breakpoint at line 40 in myscript.py. Note that
414 will set the first breakpoint at line 40 in myscript.py. Note that
415 the first breakpoint must be set on a line which actually does
415 the first breakpoint must be set on a line which actually does
416 something (not a comment or docstring) for it to stop execution.
416 something (not a comment or docstring) for it to stop execution.
417
417
418 Or you can specify a breakpoint in a different file::
418 Or you can specify a breakpoint in a different file::
419
419
420 %run -d -b myotherfile.py:20 myscript
420 %run -d -b myotherfile.py:20 myscript
421
421
422 When the pdb debugger starts, you will see a (Pdb) prompt. You must
422 When the pdb debugger starts, you will see a (Pdb) prompt. You must
423 first enter 'c' (without quotes) to start execution up to the first
423 first enter 'c' (without quotes) to start execution up to the first
424 breakpoint.
424 breakpoint.
425
425
426 Entering 'help' gives information about the use of the debugger. You
426 Entering 'help' gives information about the use of the debugger. You
427 can easily see pdb's full documentation with "import pdb;pdb.help()"
427 can easily see pdb's full documentation with "import pdb;pdb.help()"
428 at a prompt.
428 at a prompt.
429
429
430 -p: run program under the control of the Python profiler module (which
430 -p: run program under the control of the Python profiler module (which
431 prints a detailed report of execution times, function calls, etc).
431 prints a detailed report of execution times, function calls, etc).
432
432
433 You can pass other options after -p which affect the behavior of the
433 You can pass other options after -p which affect the behavior of the
434 profiler itself. See the docs for %prun for details.
434 profiler itself. See the docs for %prun for details.
435
435
436 In this mode, the program's variables do NOT propagate back to the
436 In this mode, the program's variables do NOT propagate back to the
437 IPython interactive namespace (because they remain in the namespace
437 IPython interactive namespace (because they remain in the namespace
438 where the profiler executes them).
438 where the profiler executes them).
439
439
440 Internally this triggers a call to %prun, see its documentation for
440 Internally this triggers a call to %prun, see its documentation for
441 details on the options available specifically for profiling.
441 details on the options available specifically for profiling.
442
442
443 There is one special usage for which the text above doesn't apply:
443 There is one special usage for which the text above doesn't apply:
444 if the filename ends with .ipy, the file is run as ipython script,
444 if the filename ends with .ipy, the file is run as ipython script,
445 just as if the commands were written on IPython prompt.
445 just as if the commands were written on IPython prompt.
446
446
447 -m: specify module name to load instead of script path. Similar to
447 -m: specify module name to load instead of script path. Similar to
448 the -m option for the python interpreter. Use this option last if you
448 the -m option for the python interpreter. Use this option last if you
449 want to combine with other %run options. Unlike the python interpreter
449 want to combine with other %run options. Unlike the python interpreter
450 only source modules are allowed no .pyc or .pyo files.
450 only source modules are allowed no .pyc or .pyo files.
451 For example::
451 For example::
452
452
453 %run -m example
453 %run -m example
454
454
455 will run the example module.
455 will run the example module.
456
456
457 -G: disable shell-like glob expansion of arguments.
457 -G: disable shell-like glob expansion of arguments.
458
458
459 """
459 """
460
460
461 # get arguments and set sys.argv for program to be run.
461 # get arguments and set sys.argv for program to be run.
462 opts, arg_lst = self.parse_options(parameter_s,
462 opts, arg_lst = self.parse_options(parameter_s,
463 'nidtN:b:pD:l:rs:T:em:G',
463 'nidtN:b:pD:l:rs:T:em:G',
464 mode='list', list_all=1)
464 mode='list', list_all=1)
465 if "m" in opts:
465 if "m" in opts:
466 modulename = opts["m"][0]
466 modulename = opts["m"][0]
467 modpath = find_mod(modulename)
467 modpath = find_mod(modulename)
468 if modpath is None:
468 if modpath is None:
469 warn('%r is not a valid modulename on sys.path'%modulename)
469 warn('%r is not a valid modulename on sys.path'%modulename)
470 return
470 return
471 arg_lst = [modpath] + arg_lst
471 arg_lst = [modpath] + arg_lst
472 try:
472 try:
473 filename = file_finder(arg_lst[0])
473 filename = file_finder(arg_lst[0])
474 except IndexError:
474 except IndexError:
475 warn('you must provide at least a filename.')
475 warn('you must provide at least a filename.')
476 print '\n%run:\n', oinspect.getdoc(self.run)
476 print '\n%run:\n', oinspect.getdoc(self.run)
477 return
477 return
478 except IOError as e:
478 except IOError as e:
479 try:
479 try:
480 msg = str(e)
480 msg = str(e)
481 except UnicodeError:
481 except UnicodeError:
482 msg = e.message
482 msg = e.message
483 error(msg)
483 error(msg)
484 return
484 return
485
485
486 if filename.lower().endswith('.ipy'):
486 if filename.lower().endswith('.ipy'):
487 with preserve_keys(self.shell.user_ns, '__file__'):
487 with preserve_keys(self.shell.user_ns, '__file__'):
488 self.shell.user_ns['__file__'] = filename
488 self.shell.user_ns['__file__'] = filename
489 self.shell.safe_execfile_ipy(filename)
489 self.shell.safe_execfile_ipy(filename)
490 return
490 return
491
491
492 # Control the response to exit() calls made by the script being run
492 # Control the response to exit() calls made by the script being run
493 exit_ignore = 'e' in opts
493 exit_ignore = 'e' in opts
494
494
495 # Make sure that the running script gets a proper sys.argv as if it
495 # Make sure that the running script gets a proper sys.argv as if it
496 # were run from a system shell.
496 # were run from a system shell.
497 save_argv = sys.argv # save it for later restoring
497 save_argv = sys.argv # save it for later restoring
498
498
499 if 'G' in opts:
499 if 'G' in opts:
500 args = arg_lst[1:]
500 args = arg_lst[1:]
501 else:
501 else:
502 # tilde and glob expansion
502 # tilde and glob expansion
503 args = shellglob(map(os.path.expanduser, arg_lst[1:]))
503 args = shellglob(map(os.path.expanduser, arg_lst[1:]))
504
504
505 sys.argv = [filename] + args # put in the proper filename
505 sys.argv = [filename] + args # put in the proper filename
506 # protect sys.argv from potential unicode strings on Python 2:
506 # protect sys.argv from potential unicode strings on Python 2:
507 if not py3compat.PY3:
507 if not py3compat.PY3:
508 sys.argv = [ py3compat.cast_bytes(a) for a in sys.argv ]
508 sys.argv = [ py3compat.cast_bytes(a) for a in sys.argv ]
509
509
510 if 'i' in opts:
510 if 'i' in opts:
511 # Run in user's interactive namespace
511 # Run in user's interactive namespace
512 prog_ns = self.shell.user_ns
512 prog_ns = self.shell.user_ns
513 __name__save = self.shell.user_ns['__name__']
513 __name__save = self.shell.user_ns['__name__']
514 prog_ns['__name__'] = '__main__'
514 prog_ns['__name__'] = '__main__'
515 main_mod = self.shell.new_main_mod(prog_ns)
515 main_mod = self.shell.new_main_mod(prog_ns)
516 else:
516 else:
517 # Run in a fresh, empty namespace
517 # Run in a fresh, empty namespace
518 if 'n' in opts:
518 if 'n' in opts:
519 name = os.path.splitext(os.path.basename(filename))[0]
519 name = os.path.splitext(os.path.basename(filename))[0]
520 else:
520 else:
521 name = '__main__'
521 name = '__main__'
522
522
523 main_mod = self.shell.new_main_mod()
523 main_mod = self.shell.new_main_mod()
524 prog_ns = main_mod.__dict__
524 prog_ns = main_mod.__dict__
525 prog_ns['__name__'] = name
525 prog_ns['__name__'] = name
526
526
527 # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
527 # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
528 # set the __file__ global in the script's namespace
528 # set the __file__ global in the script's namespace
529 prog_ns['__file__'] = filename
529 prog_ns['__file__'] = filename
530
530
531 # pickle fix. See interactiveshell for an explanation. But we need to
531 # pickle fix. See interactiveshell for an explanation. But we need to
532 # make sure that, if we overwrite __main__, we replace it at the end
532 # make sure that, if we overwrite __main__, we replace it at the end
533 main_mod_name = prog_ns['__name__']
533 main_mod_name = prog_ns['__name__']
534
534
535 if main_mod_name == '__main__':
535 if main_mod_name == '__main__':
536 restore_main = sys.modules['__main__']
536 restore_main = sys.modules['__main__']
537 else:
537 else:
538 restore_main = False
538 restore_main = False
539
539
540 # This needs to be undone at the end to prevent holding references to
540 # This needs to be undone at the end to prevent holding references to
541 # every single object ever created.
541 # every single object ever created.
542 sys.modules[main_mod_name] = main_mod
542 sys.modules[main_mod_name] = main_mod
543
543
544 try:
544 try:
545 stats = None
545 stats = None
546 with self.shell.readline_no_record:
546 with self.shell.readline_no_record:
547 if 'p' in opts:
547 if 'p' in opts:
548 stats = self.prun('', None, False, opts, arg_lst, prog_ns)
548 stats = self.prun('', None, False, opts, arg_lst, prog_ns)
549 else:
549 else:
550 if 'd' in opts:
550 if 'd' in opts:
551 deb = debugger.Pdb(self.shell.colors)
551 deb = debugger.Pdb(self.shell.colors)
552 # reset Breakpoint state, which is moronically kept
552 # reset Breakpoint state, which is moronically kept
553 # in a class
553 # in a class
554 bdb.Breakpoint.next = 1
554 bdb.Breakpoint.next = 1
555 bdb.Breakpoint.bplist = {}
555 bdb.Breakpoint.bplist = {}
556 bdb.Breakpoint.bpbynumber = [None]
556 bdb.Breakpoint.bpbynumber = [None]
557 # Set an initial breakpoint to stop execution
557 # Set an initial breakpoint to stop execution
558 maxtries = 10
558 maxtries = 10
559 bp_file, bp_line = parse_breakpoint(opts.get('b', ['1'])[0], filename)
559 bp_file, bp_line = parse_breakpoint(opts.get('b', ['1'])[0], filename)
560 checkline = deb.checkline(bp_file, bp_line)
560 checkline = deb.checkline(bp_file, bp_line)
561 if not checkline:
561 if not checkline:
562 for bp in range(bp_line + 1, bp_line + maxtries + 1):
562 for bp in range(bp_line + 1, bp_line + maxtries + 1):
563 if deb.checkline(bp_file, bp):
563 if deb.checkline(bp_file, bp):
564 break
564 break
565 else:
565 else:
566 msg = ("\nI failed to find a valid line to set "
566 msg = ("\nI failed to find a valid line to set "
567 "a breakpoint\n"
567 "a breakpoint\n"
568 "after trying up to line: %s.\n"
568 "after trying up to line: %s.\n"
569 "Please set a valid breakpoint manually "
569 "Please set a valid breakpoint manually "
570 "with the -b option." % bp)
570 "with the -b option." % bp)
571 error(msg)
571 error(msg)
572 return
572 return
573 # if we find a good linenumber, set the breakpoint
573 # if we find a good linenumber, set the breakpoint
574 deb.do_break('%s:%s' % (bp_file, bp_line))
574 deb.do_break('%s:%s' % (bp_file, bp_line))
575
575
576 # Mimic Pdb._runscript(...)
576 # Mimic Pdb._runscript(...)
577 deb._wait_for_mainpyfile = True
577 deb._wait_for_mainpyfile = True
578 deb.mainpyfile = deb.canonic(filename)
578 deb.mainpyfile = deb.canonic(filename)
579
579
580 # Start file run
580 # Start file run
581 print "NOTE: Enter 'c' at the",
581 print "NOTE: Enter 'c' at the",
582 print "%s prompt to start your script." % deb.prompt
582 print "%s prompt to start your script." % deb.prompt
583 ns = {'execfile': py3compat.execfile, 'prog_ns': prog_ns}
583 ns = {'execfile': py3compat.execfile, 'prog_ns': prog_ns}
584 try:
584 try:
585 #save filename so it can be used by methods on the deb object
585 #save filename so it can be used by methods on the deb object
586 deb._exec_filename = filename
586 deb._exec_filename = filename
587 deb.run('execfile("%s", prog_ns)' % filename, ns)
587 deb.run('execfile("%s", prog_ns)' % filename, ns)
588
588
589 except:
589 except:
590 etype, value, tb = sys.exc_info()
590 etype, value, tb = sys.exc_info()
591 # Skip three frames in the traceback: the %run one,
591 # Skip three frames in the traceback: the %run one,
592 # one inside bdb.py, and the command-line typed by the
592 # one inside bdb.py, and the command-line typed by the
593 # user (run by exec in pdb itself).
593 # user (run by exec in pdb itself).
594 self.shell.InteractiveTB(etype, value, tb, tb_offset=3)
594 self.shell.InteractiveTB(etype, value, tb, tb_offset=3)
595 else:
595 else:
596 if runner is None:
596 if runner is None:
597 runner = self.default_runner
597 runner = self.default_runner
598 if runner is None:
598 if runner is None:
599 runner = self.shell.safe_execfile
599 runner = self.shell.safe_execfile
600 if 't' in opts:
600 if 't' in opts:
601 # timed execution
601 # timed execution
602 try:
602 try:
603 nruns = int(opts['N'][0])
603 nruns = int(opts['N'][0])
604 if nruns < 1:
604 if nruns < 1:
605 error('Number of runs must be >=1')
605 error('Number of runs must be >=1')
606 return
606 return
607 except (KeyError):
607 except (KeyError):
608 nruns = 1
608 nruns = 1
609 twall0 = time.time()
609 twall0 = time.time()
610 if nruns == 1:
610 if nruns == 1:
611 t0 = clock2()
611 t0 = clock2()
612 runner(filename, prog_ns, prog_ns,
612 runner(filename, prog_ns, prog_ns,
613 exit_ignore=exit_ignore)
613 exit_ignore=exit_ignore)
614 t1 = clock2()
614 t1 = clock2()
615 t_usr = t1[0] - t0[0]
615 t_usr = t1[0] - t0[0]
616 t_sys = t1[1] - t0[1]
616 t_sys = t1[1] - t0[1]
617 print "\nIPython CPU timings (estimated):"
617 print "\nIPython CPU timings (estimated):"
618 print " User : %10.2f s." % t_usr
618 print " User : %10.2f s." % t_usr
619 print " System : %10.2f s." % t_sys
619 print " System : %10.2f s." % t_sys
620 else:
620 else:
621 runs = range(nruns)
621 runs = range(nruns)
622 t0 = clock2()
622 t0 = clock2()
623 for nr in runs:
623 for nr in runs:
624 runner(filename, prog_ns, prog_ns,
624 runner(filename, prog_ns, prog_ns,
625 exit_ignore=exit_ignore)
625 exit_ignore=exit_ignore)
626 t1 = clock2()
626 t1 = clock2()
627 t_usr = t1[0] - t0[0]
627 t_usr = t1[0] - t0[0]
628 t_sys = t1[1] - t0[1]
628 t_sys = t1[1] - t0[1]
629 print "\nIPython CPU timings (estimated):"
629 print "\nIPython CPU timings (estimated):"
630 print "Total runs performed:", nruns
630 print "Total runs performed:", nruns
631 print " Times : %10.2f %10.2f" % ('Total', 'Per run')
631 print " Times : %10.2f %10.2f" % ('Total', 'Per run')
632 print " User : %10.2f s, %10.2f s." % (t_usr, t_usr / nruns)
632 print " User : %10.2f s, %10.2f s." % (t_usr, t_usr / nruns)
633 print " System : %10.2f s, %10.2f s." % (t_sys, t_sys / nruns)
633 print " System : %10.2f s, %10.2f s." % (t_sys, t_sys / nruns)
634 twall1 = time.time()
634 twall1 = time.time()
635 print "Wall time: %10.2f s." % (twall1 - twall0)
635 print "Wall time: %10.2f s." % (twall1 - twall0)
636
636
637 else:
637 else:
638 # regular execution
638 # regular execution
639 runner(filename, prog_ns, prog_ns, exit_ignore=exit_ignore)
639 runner(filename, prog_ns, prog_ns, exit_ignore=exit_ignore)
640
640
641 if 'i' in opts:
641 if 'i' in opts:
642 self.shell.user_ns['__name__'] = __name__save
642 self.shell.user_ns['__name__'] = __name__save
643 else:
643 else:
644 # The shell MUST hold a reference to prog_ns so after %run
644 # The shell MUST hold a reference to prog_ns so after %run
645 # exits, the python deletion mechanism doesn't zero it out
645 # exits, the python deletion mechanism doesn't zero it out
646 # (leaving dangling references).
646 # (leaving dangling references).
647 self.shell.cache_main_mod(prog_ns, filename)
647 self.shell.cache_main_mod(prog_ns, filename)
648 # update IPython interactive namespace
648 # update IPython interactive namespace
649
649
650 # Some forms of read errors on the file may mean the
650 # Some forms of read errors on the file may mean the
651 # __name__ key was never set; using pop we don't have to
651 # __name__ key was never set; using pop we don't have to
652 # worry about a possible KeyError.
652 # worry about a possible KeyError.
653 prog_ns.pop('__name__', None)
653 prog_ns.pop('__name__', None)
654
654
655 with preserve_keys(self.shell.user_ns, '__file__'):
655 with preserve_keys(self.shell.user_ns, '__file__'):
656 self.shell.user_ns.update(prog_ns)
656 self.shell.user_ns.update(prog_ns)
657 finally:
657 finally:
658 # It's a bit of a mystery why, but __builtins__ can change from
658 # It's a bit of a mystery why, but __builtins__ can change from
659 # being a module to becoming a dict missing some key data after
659 # being a module to becoming a dict missing some key data after
660 # %run. As best I can see, this is NOT something IPython is doing
660 # %run. As best I can see, this is NOT something IPython is doing
661 # at all, and similar problems have been reported before:
661 # at all, and similar problems have been reported before:
662 # http://coding.derkeiler.com/Archive/Python/comp.lang.python/2004-10/0188.html
662 # http://coding.derkeiler.com/Archive/Python/comp.lang.python/2004-10/0188.html
663 # Since this seems to be done by the interpreter itself, the best
663 # Since this seems to be done by the interpreter itself, the best
664 # we can do is to at least restore __builtins__ for the user on
664 # we can do is to at least restore __builtins__ for the user on
665 # exit.
665 # exit.
666 self.shell.user_ns['__builtins__'] = builtin_mod
666 self.shell.user_ns['__builtins__'] = builtin_mod
667
667
668 # Ensure key global structures are restored
668 # Ensure key global structures are restored
669 sys.argv = save_argv
669 sys.argv = save_argv
670 if restore_main:
670 if restore_main:
671 sys.modules['__main__'] = restore_main
671 sys.modules['__main__'] = restore_main
672 else:
672 else:
673 # Remove from sys.modules the reference to main_mod we'd
673 # Remove from sys.modules the reference to main_mod we'd
674 # added. Otherwise it will trap references to objects
674 # added. Otherwise it will trap references to objects
675 # contained therein.
675 # contained therein.
676 del sys.modules[main_mod_name]
676 del sys.modules[main_mod_name]
677
677
678 return stats
678 return stats
679
679
680 @skip_doctest
680 @skip_doctest
681 @line_cell_magic
681 @line_cell_magic
682 def timeit(self, line='', cell=None):
682 def timeit(self, line='', cell=None):
683 """Time execution of a Python statement or expression
683 """Time execution of a Python statement or expression
684
684
685 Usage, in line mode:
685 Usage, in line mode:
686 %timeit [-n<N> -r<R> [-t|-c]] statement
686 %timeit [-n<N> -r<R> [-t|-c]] statement
687 or in cell mode:
687 or in cell mode:
688 %%timeit [-n<N> -r<R> [-t|-c]] setup_code
688 %%timeit [-n<N> -r<R> [-t|-c]] setup_code
689 code
689 code
690 code...
690 code...
691
691
692 Time execution of a Python statement or expression using the timeit
692 Time execution of a Python statement or expression using the timeit
693 module. This function can be used both as a line and cell magic:
693 module. This function can be used both as a line and cell magic:
694
694
695 - In line mode you can time a single-line statement (though multiple
695 - In line mode you can time a single-line statement (though multiple
696 ones can be chained with using semicolons).
696 ones can be chained with using semicolons).
697
697
698 - In cell mode, the statement in the first line is used as setup code
698 - In cell mode, the statement in the first line is used as setup code
699 (executed but not timed) and the body of the cell is timed. The cell
699 (executed but not timed) and the body of the cell is timed. The cell
700 body has access to any variables created in the setup code.
700 body has access to any variables created in the setup code.
701
701
702 Options:
702 Options:
703 -n<N>: execute the given statement <N> times in a loop. If this value
703 -n<N>: execute the given statement <N> times in a loop. If this value
704 is not given, a fitting value is chosen.
704 is not given, a fitting value is chosen.
705
705
706 -r<R>: repeat the loop iteration <R> times and take the best result.
706 -r<R>: repeat the loop iteration <R> times and take the best result.
707 Default: 3
707 Default: 3
708
708
709 -t: use time.time to measure the time, which is the default on Unix.
709 -t: use time.time to measure the time, which is the default on Unix.
710 This function measures wall time.
710 This function measures wall time.
711
711
712 -c: use time.clock to measure the time, which is the default on
712 -c: use time.clock to measure the time, which is the default on
713 Windows and measures wall time. On Unix, resource.getrusage is used
713 Windows and measures wall time. On Unix, resource.getrusage is used
714 instead and returns the CPU user time.
714 instead and returns the CPU user time.
715
715
716 -p<P>: use a precision of <P> digits to display the timing result.
716 -p<P>: use a precision of <P> digits to display the timing result.
717 Default: 3
717 Default: 3
718
718
719
719
720 Examples
720 Examples
721 --------
721 --------
722 ::
722 ::
723
723
724 In [1]: %timeit pass
724 In [1]: %timeit pass
725 10000000 loops, best of 3: 53.3 ns per loop
725 10000000 loops, best of 3: 53.3 ns per loop
726
726
727 In [2]: u = None
727 In [2]: u = None
728
728
729 In [3]: %timeit u is None
729 In [3]: %timeit u is None
730 10000000 loops, best of 3: 184 ns per loop
730 10000000 loops, best of 3: 184 ns per loop
731
731
732 In [4]: %timeit -r 4 u == None
732 In [4]: %timeit -r 4 u == None
733 1000000 loops, best of 4: 242 ns per loop
733 1000000 loops, best of 4: 242 ns per loop
734
734
735 In [5]: import time
735 In [5]: import time
736
736
737 In [6]: %timeit -n1 time.sleep(2)
737 In [6]: %timeit -n1 time.sleep(2)
738 1 loops, best of 3: 2 s per loop
738 1 loops, best of 3: 2 s per loop
739
739
740
740
741 The times reported by %timeit will be slightly higher than those
741 The times reported by %timeit will be slightly higher than those
742 reported by the timeit.py script when variables are accessed. This is
742 reported by the timeit.py script when variables are accessed. This is
743 due to the fact that %timeit executes the statement in the namespace
743 due to the fact that %timeit executes the statement in the namespace
744 of the shell, compared with timeit.py, which uses a single setup
744 of the shell, compared with timeit.py, which uses a single setup
745 statement to import function or create variables. Generally, the bias
745 statement to import function or create variables. Generally, the bias
746 does not matter as long as results from timeit.py are not mixed with
746 does not matter as long as results from timeit.py are not mixed with
747 those from %timeit."""
747 those from %timeit."""
748
748
749 import timeit
749 import timeit
750
750
751 opts, stmt = self.parse_options(line,'n:r:tcp:',
751 opts, stmt = self.parse_options(line,'n:r:tcp:',
752 posix=False, strict=False)
752 posix=False, strict=False)
753 if stmt == "" and cell is None:
753 if stmt == "" and cell is None:
754 return
754 return
755 timefunc = timeit.default_timer
755 timefunc = timeit.default_timer
756 number = int(getattr(opts, "n", 0))
756 number = int(getattr(opts, "n", 0))
757 repeat = int(getattr(opts, "r", timeit.default_repeat))
757 repeat = int(getattr(opts, "r", timeit.default_repeat))
758 precision = int(getattr(opts, "p", 3))
758 precision = int(getattr(opts, "p", 3))
759 if hasattr(opts, "t"):
759 if hasattr(opts, "t"):
760 timefunc = time.time
760 timefunc = time.time
761 if hasattr(opts, "c"):
761 if hasattr(opts, "c"):
762 timefunc = clock
762 timefunc = clock
763
763
764 timer = timeit.Timer(timer=timefunc)
764 timer = timeit.Timer(timer=timefunc)
765 # this code has tight coupling to the inner workings of timeit.Timer,
765 # this code has tight coupling to the inner workings of timeit.Timer,
766 # but is there a better way to achieve that the code stmt has access
766 # but is there a better way to achieve that the code stmt has access
767 # to the shell namespace?
767 # to the shell namespace?
768 transform = self.shell.input_splitter.transform_cell
768 transform = self.shell.input_splitter.transform_cell
769
769
770 if cell is None:
770 if cell is None:
771 # called as line magic
771 # called as line magic
772 ast_setup = ast.parse("pass")
772 ast_setup = ast.parse("pass")
773 ast_stmt = ast.parse(transform(stmt))
773 ast_stmt = ast.parse(transform(stmt))
774 else:
774 else:
775 ast_setup = ast.parse(transform(stmt))
775 ast_setup = ast.parse(transform(stmt))
776 ast_stmt = ast.parse(transform(cell))
776 ast_stmt = ast.parse(transform(cell))
777
777
778 ast_setup = self.shell.transform_ast(ast_setup)
778 ast_setup = self.shell.transform_ast(ast_setup)
779 ast_stmt = self.shell.transform_ast(ast_stmt)
779 ast_stmt = self.shell.transform_ast(ast_stmt)
780
780
781 # This codestring is taken from timeit.template - we fill it in as an
781 # This codestring is taken from timeit.template - we fill it in as an
782 # AST, so that we can apply our AST transformations to the user code
782 # AST, so that we can apply our AST transformations to the user code
783 # without affecting the timing code.
783 # without affecting the timing code.
784 timeit_ast_template = ast.parse('def inner(_it, _timer):\n'
784 timeit_ast_template = ast.parse('def inner(_it, _timer):\n'
785 ' setup\n'
785 ' setup\n'
786 ' _t0 = _timer()\n'
786 ' _t0 = _timer()\n'
787 ' for _i in _it:\n'
787 ' for _i in _it:\n'
788 ' stmt\n'
788 ' stmt\n'
789 ' _t1 = _timer()\n'
789 ' _t1 = _timer()\n'
790 ' return _t1 - _t0\n')
790 ' return _t1 - _t0\n')
791
791
792 class TimeitTemplateFiller(ast.NodeTransformer):
792 class TimeitTemplateFiller(ast.NodeTransformer):
793 "This is quite tightly tied to the template definition above."
793 "This is quite tightly tied to the template definition above."
794 def visit_FunctionDef(self, node):
794 def visit_FunctionDef(self, node):
795 "Fill in the setup statement"
795 "Fill in the setup statement"
796 self.generic_visit(node)
796 self.generic_visit(node)
797 if node.name == "inner":
797 if node.name == "inner":
798 node.body[:1] = ast_setup.body
798 node.body[:1] = ast_setup.body
799
799
800 return node
800 return node
801
801
802 def visit_For(self, node):
802 def visit_For(self, node):
803 "Fill in the statement to be timed"
803 "Fill in the statement to be timed"
804 if getattr(getattr(node.body[0], 'value', None), 'id', None) == 'stmt':
804 if getattr(getattr(node.body[0], 'value', None), 'id', None) == 'stmt':
805 node.body = ast_stmt.body
805 node.body = ast_stmt.body
806 return node
806 return node
807
807
808 timeit_ast = TimeitTemplateFiller().visit(timeit_ast_template)
808 timeit_ast = TimeitTemplateFiller().visit(timeit_ast_template)
809 timeit_ast = ast.fix_missing_locations(timeit_ast)
809 timeit_ast = ast.fix_missing_locations(timeit_ast)
810
810
811 # Track compilation time so it can be reported if too long
811 # Track compilation time so it can be reported if too long
812 # Minimum time above which compilation time will be reported
812 # Minimum time above which compilation time will be reported
813 tc_min = 0.1
813 tc_min = 0.1
814
814
815 t0 = clock()
815 t0 = clock()
816 code = compile(timeit_ast, "<magic-timeit>", "exec")
816 code = compile(timeit_ast, "<magic-timeit>", "exec")
817 tc = clock()-t0
817 tc = clock()-t0
818
818
819 ns = {}
819 ns = {}
820 exec code in self.shell.user_ns, ns
820 exec code in self.shell.user_ns, ns
821 timer.inner = ns["inner"]
821 timer.inner = ns["inner"]
822
822
823 if number == 0:
823 if number == 0:
824 # determine number so that 0.2 <= total time < 2.0
824 # determine number so that 0.2 <= total time < 2.0
825 number = 1
825 number = 1
826 for i in range(1, 10):
826 for i in range(1, 10):
827 if timer.timeit(number) >= 0.2:
827 if timer.timeit(number) >= 0.2:
828 break
828 break
829 number *= 10
829 number *= 10
830
830
831 best = min(timer.repeat(repeat, number)) / number
831 best = min(timer.repeat(repeat, number)) / number
832
832
833 print u"%d loops, best of %d: %s per loop" % (number, repeat,
833 print u"%d loops, best of %d: %s per loop" % (number, repeat,
834 _format_time(best, precision))
834 _format_time(best, precision))
835 if tc > tc_min:
835 if tc > tc_min:
836 print "Compiler time: %.2f s" % tc
836 print "Compiler time: %.2f s" % tc
837
837
838 @skip_doctest
838 @skip_doctest
839 @needs_local_scope
839 @needs_local_scope
840 @line_cell_magic
840 @line_cell_magic
841 def time(self,line='', cell=None, local_ns=None):
841 def time(self,line='', cell=None, local_ns=None):
842 """Time execution of a Python statement or expression.
842 """Time execution of a Python statement or expression.
843
843
844 The CPU and wall clock times are printed, and the value of the
844 The CPU and wall clock times are printed, and the value of the
845 expression (if any) is returned. Note that under Win32, system time
845 expression (if any) is returned. Note that under Win32, system time
846 is always reported as 0, since it can not be measured.
846 is always reported as 0, since it can not be measured.
847
847
848 This function can be used both as a line and cell magic:
848 This function can be used both as a line and cell magic:
849
849
850 - In line mode you can time a single-line statement (though multiple
850 - In line mode you can time a single-line statement (though multiple
851 ones can be chained with using semicolons).
851 ones can be chained with using semicolons).
852
852
853 - In cell mode, you can time the cell body (a directly
853 - In cell mode, you can time the cell body (a directly
854 following statement raises an error).
854 following statement raises an error).
855
855
856 This function provides very basic timing functionality. Use the timeit
856 This function provides very basic timing functionality. Use the timeit
857 magic for more controll over the measurement.
857 magic for more controll over the measurement.
858
858
859 Examples
859 Examples
860 --------
860 --------
861 ::
861 ::
862
862
863 In [1]: %time 2**128
863 In [1]: %time 2**128
864 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
864 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
865 Wall time: 0.00
865 Wall time: 0.00
866 Out[1]: 340282366920938463463374607431768211456L
866 Out[1]: 340282366920938463463374607431768211456L
867
867
868 In [2]: n = 1000000
868 In [2]: n = 1000000
869
869
870 In [3]: %time sum(range(n))
870 In [3]: %time sum(range(n))
871 CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
871 CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
872 Wall time: 1.37
872 Wall time: 1.37
873 Out[3]: 499999500000L
873 Out[3]: 499999500000L
874
874
875 In [4]: %time print 'hello world'
875 In [4]: %time print 'hello world'
876 hello world
876 hello world
877 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
877 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
878 Wall time: 0.00
878 Wall time: 0.00
879
879
880 Note that the time needed by Python to compile the given expression
880 Note that the time needed by Python to compile the given expression
881 will be reported if it is more than 0.1s. In this example, the
881 will be reported if it is more than 0.1s. In this example, the
882 actual exponentiation is done by Python at compilation time, so while
882 actual exponentiation is done by Python at compilation time, so while
883 the expression can take a noticeable amount of time to compute, that
883 the expression can take a noticeable amount of time to compute, that
884 time is purely due to the compilation:
884 time is purely due to the compilation:
885
885
886 In [5]: %time 3**9999;
886 In [5]: %time 3**9999;
887 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
887 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
888 Wall time: 0.00 s
888 Wall time: 0.00 s
889
889
890 In [6]: %time 3**999999;
890 In [6]: %time 3**999999;
891 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
891 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
892 Wall time: 0.00 s
892 Wall time: 0.00 s
893 Compiler : 0.78 s
893 Compiler : 0.78 s
894 """
894 """
895
895
896 # fail immediately if the given expression can't be compiled
896 # fail immediately if the given expression can't be compiled
897
897
898 if line and cell:
898 if line and cell:
899 raise UsageError("Can't use statement directly after '%%time'!")
899 raise UsageError("Can't use statement directly after '%%time'!")
900
900
901 if cell:
901 if cell:
902 expr = self.shell.prefilter(cell,False)
902 expr = self.shell.prefilter(cell,False)
903 else:
903 else:
904 expr = self.shell.prefilter(line,False)
904 expr = self.shell.prefilter(line,False)
905
905
906 # Minimum time above which parse time will be reported
906 # Minimum time above which parse time will be reported
907 tp_min = 0.1
907 tp_min = 0.1
908
908
909 t0 = clock()
909 t0 = clock()
910 expr_ast = ast.parse(expr)
910 expr_ast = ast.parse(expr)
911 tp = clock()-t0
911 tp = clock()-t0
912
912
913 # Apply AST transformations
913 # Apply AST transformations
914 expr_ast = self.shell.transform_ast(expr_ast)
914 expr_ast = self.shell.transform_ast(expr_ast)
915
915
916 # Minimum time above which compilation time will be reported
916 # Minimum time above which compilation time will be reported
917 tc_min = 0.1
917 tc_min = 0.1
918
918
919 if len(expr_ast.body)==1 and isinstance(expr_ast.body[0], ast.Expr):
919 if len(expr_ast.body)==1 and isinstance(expr_ast.body[0], ast.Expr):
920 mode = 'eval'
920 mode = 'eval'
921 source = '<timed eval>'
921 source = '<timed eval>'
922 expr_ast = ast.Expression(expr_ast.body[0].value)
922 expr_ast = ast.Expression(expr_ast.body[0].value)
923 else:
923 else:
924 mode = 'exec'
924 mode = 'exec'
925 source = '<timed exec>'
925 source = '<timed exec>'
926 t0 = clock()
926 t0 = clock()
927 code = compile(expr_ast, source, mode)
927 code = compile(expr_ast, source, mode)
928 tc = clock()-t0
928 tc = clock()-t0
929
929
930 # skew measurement as little as possible
930 # skew measurement as little as possible
931 glob = self.shell.user_ns
931 glob = self.shell.user_ns
932 wtime = time.time
932 wtime = time.time
933 # time execution
933 # time execution
934 wall_st = wtime()
934 wall_st = wtime()
935 if mode=='eval':
935 if mode=='eval':
936 st = clock2()
936 st = clock2()
937 out = eval(code, glob, local_ns)
937 out = eval(code, glob, local_ns)
938 end = clock2()
938 end = clock2()
939 else:
939 else:
940 st = clock2()
940 st = clock2()
941 exec code in glob, local_ns
941 exec code in glob, local_ns
942 end = clock2()
942 end = clock2()
943 out = None
943 out = None
944 wall_end = wtime()
944 wall_end = wtime()
945 # Compute actual times and report
945 # Compute actual times and report
946 wall_time = wall_end-wall_st
946 wall_time = wall_end-wall_st
947 cpu_user = end[0]-st[0]
947 cpu_user = end[0]-st[0]
948 cpu_sys = end[1]-st[1]
948 cpu_sys = end[1]-st[1]
949 cpu_tot = cpu_user+cpu_sys
949 cpu_tot = cpu_user+cpu_sys
950 print "CPU times: user %s, sys: %s, total: %s" % \
950 print "CPU times: user %s, sys: %s, total: %s" % \
951 (_format_time(cpu_user),_format_time(cpu_sys),_format_time(cpu_tot))
951 (_format_time(cpu_user),_format_time(cpu_sys),_format_time(cpu_tot))
952 print "Wall time: %s" % _format_time(wall_time)
952 print "Wall time: %s" % _format_time(wall_time)
953 if tc > tc_min:
953 if tc > tc_min:
954 print "Compiler : %s" % _format_time(tc)
954 print "Compiler : %s" % _format_time(tc)
955 if tp > tp_min:
955 if tp > tp_min:
956 print "Parser : %s" % _format_time(tp)
956 print "Parser : %s" % _format_time(tp)
957 return out
957 return out
958
958
959 @skip_doctest
959 @skip_doctest
960 @line_magic
960 @line_magic
961 def macro(self, parameter_s=''):
961 def macro(self, parameter_s=''):
962 """Define a macro for future re-execution. It accepts ranges of history,
962 """Define a macro for future re-execution. It accepts ranges of history,
963 filenames or string objects.
963 filenames or string objects.
964
964
965 Usage:\\
965 Usage:\\
966 %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
966 %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
967
967
968 Options:
968 Options:
969
969
970 -r: use 'raw' input. By default, the 'processed' history is used,
970 -r: use 'raw' input. By default, the 'processed' history is used,
971 so that magics are loaded in their transformed version to valid
971 so that magics are loaded in their transformed version to valid
972 Python. If this option is given, the raw input as typed as the
972 Python. If this option is given, the raw input as typed as the
973 command line is used instead.
973 command line is used instead.
974
974
975 This will define a global variable called `name` which is a string
975 This will define a global variable called `name` which is a string
976 made of joining the slices and lines you specify (n1,n2,... numbers
976 made of joining the slices and lines you specify (n1,n2,... numbers
977 above) from your input history into a single string. This variable
977 above) from your input history into a single string. This variable
978 acts like an automatic function which re-executes those lines as if
978 acts like an automatic function which re-executes those lines as if
979 you had typed them. You just type 'name' at the prompt and the code
979 you had typed them. You just type 'name' at the prompt and the code
980 executes.
980 executes.
981
981
982 The syntax for indicating input ranges is described in %history.
982 The syntax for indicating input ranges is described in %history.
983
983
984 Note: as a 'hidden' feature, you can also use traditional python slice
984 Note: as a 'hidden' feature, you can also use traditional python slice
985 notation, where N:M means numbers N through M-1.
985 notation, where N:M means numbers N through M-1.
986
986
987 For example, if your history contains (%hist prints it)::
987 For example, if your history contains (%hist prints it)::
988
988
989 44: x=1
989 44: x=1
990 45: y=3
990 45: y=3
991 46: z=x+y
991 46: z=x+y
992 47: print x
992 47: print x
993 48: a=5
993 48: a=5
994 49: print 'x',x,'y',y
994 49: print 'x',x,'y',y
995
995
996 you can create a macro with lines 44 through 47 (included) and line 49
996 you can create a macro with lines 44 through 47 (included) and line 49
997 called my_macro with::
997 called my_macro with::
998
998
999 In [55]: %macro my_macro 44-47 49
999 In [55]: %macro my_macro 44-47 49
1000
1000
1001 Now, typing `my_macro` (without quotes) will re-execute all this code
1001 Now, typing `my_macro` (without quotes) will re-execute all this code
1002 in one pass.
1002 in one pass.
1003
1003
1004 You don't need to give the line-numbers in order, and any given line
1004 You don't need to give the line-numbers in order, and any given line
1005 number can appear multiple times. You can assemble macros with any
1005 number can appear multiple times. You can assemble macros with any
1006 lines from your input history in any order.
1006 lines from your input history in any order.
1007
1007
1008 The macro is a simple object which holds its value in an attribute,
1008 The macro is a simple object which holds its value in an attribute,
1009 but IPython's display system checks for macros and executes them as
1009 but IPython's display system checks for macros and executes them as
1010 code instead of printing them when you type their name.
1010 code instead of printing them when you type their name.
1011
1011
1012 You can view a macro's contents by explicitly printing it with::
1012 You can view a macro's contents by explicitly printing it with::
1013
1013
1014 print macro_name
1014 print macro_name
1015
1015
1016 """
1016 """
1017 opts,args = self.parse_options(parameter_s,'r',mode='list')
1017 opts,args = self.parse_options(parameter_s,'r',mode='list')
1018 if not args: # List existing macros
1018 if not args: # List existing macros
1019 return sorted(k for k,v in self.shell.user_ns.iteritems() if\
1019 return sorted(k for k,v in self.shell.user_ns.iteritems() if\
1020 isinstance(v, Macro))
1020 isinstance(v, Macro))
1021 if len(args) == 1:
1021 if len(args) == 1:
1022 raise UsageError(
1022 raise UsageError(
1023 "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
1023 "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
1024 name, codefrom = args[0], " ".join(args[1:])
1024 name, codefrom = args[0], " ".join(args[1:])
1025
1025
1026 #print 'rng',ranges # dbg
1026 #print 'rng',ranges # dbg
1027 try:
1027 try:
1028 lines = self.shell.find_user_code(codefrom, 'r' in opts)
1028 lines = self.shell.find_user_code(codefrom, 'r' in opts)
1029 except (ValueError, TypeError) as e:
1029 except (ValueError, TypeError) as e:
1030 print e.args[0]
1030 print e.args[0]
1031 return
1031 return
1032 macro = Macro(lines)
1032 macro = Macro(lines)
1033 self.shell.define_macro(name, macro)
1033 self.shell.define_macro(name, macro)
1034 print 'Macro `%s` created. To execute, type its name (without quotes).' % name
1034 print 'Macro `%s` created. To execute, type its name (without quotes).' % name
1035 print '=== Macro contents: ==='
1035 print '=== Macro contents: ==='
1036 print macro,
1036 print macro,
1037
1037
1038 @magic_arguments.magic_arguments()
1038 @magic_arguments.magic_arguments()
1039 @magic_arguments.argument('output', type=str, default='', nargs='?',
1039 @magic_arguments.argument('output', type=str, default='', nargs='?',
1040 help="""The name of the variable in which to store output.
1040 help="""The name of the variable in which to store output.
1041 This is a utils.io.CapturedIO object with stdout/err attributes
1041 This is a utils.io.CapturedIO object with stdout/err attributes
1042 for the text of the captured output.
1042 for the text of the captured output.
1043
1043
1044 CapturedOutput also has a show() method for displaying the output,
1044 CapturedOutput also has a show() method for displaying the output,
1045 and __call__ as well, so you can use that to quickly display the
1045 and __call__ as well, so you can use that to quickly display the
1046 output.
1046 output.
1047
1047
1048 If unspecified, captured output is discarded.
1048 If unspecified, captured output is discarded.
1049 """
1049 """
1050 )
1050 )
1051 @magic_arguments.argument('--no-stderr', action="store_true",
1051 @magic_arguments.argument('--no-stderr', action="store_true",
1052 help="""Don't capture stderr."""
1052 help="""Don't capture stderr."""
1053 )
1053 )
1054 @magic_arguments.argument('--no-stdout', action="store_true",
1054 @magic_arguments.argument('--no-stdout', action="store_true",
1055 help="""Don't capture stdout."""
1055 help="""Don't capture stdout."""
1056 )
1056 )
1057 @cell_magic
1057 @cell_magic
1058 def capture(self, line, cell):
1058 def capture(self, line, cell):
1059 """run the cell, capturing stdout/err"""
1059 """run the cell, capturing stdout/err"""
1060 args = magic_arguments.parse_argstring(self.capture, line)
1060 args = magic_arguments.parse_argstring(self.capture, line)
1061 out = not args.no_stdout
1061 out = not args.no_stdout
1062 err = not args.no_stderr
1062 err = not args.no_stderr
1063 with capture_output(out, err) as io:
1063 with capture_output(out, err) as io:
1064 self.shell.run_cell(cell)
1064 self.shell.run_cell(cell)
1065 if args.output:
1065 if args.output:
1066 self.shell.user_ns[args.output] = io
1066 self.shell.user_ns[args.output] = io
1067
1067
1068 def parse_breakpoint(text, current_file):
1068 def parse_breakpoint(text, current_file):
1069 '''Returns (file, line) for file:line and (current_file, line) for line'''
1069 '''Returns (file, line) for file:line and (current_file, line) for line'''
1070 colon = text.find(':')
1070 colon = text.find(':')
1071 if colon == -1:
1071 if colon == -1:
1072 return current_file, int(text)
1072 return current_file, int(text)
1073 else:
1073 else:
1074 return text[:colon], int(text[colon+1:])
1074 return text[:colon], int(text[colon+1:])
1075
1075
1076 def _format_time(timespan, precision=3):
1076 def _format_time(timespan, precision=3):
1077 """Formats the timespan in a human readable form"""
1077 """Formats the timespan in a human readable form"""
1078 import math
1078 import math
1079 # XXX: Unfortunately the unicode 'micro' symbol can cause problems in
1080 # certain terminals.
1081 # See bug: https://bugs.launchpad.net/ipython/+bug/348466
1082
1083 # This is trying to prevent crashes, so it's more secure than it needs to
1084 # E.g. eclipse is able to print a µ, but has no sys.stdout.encoding set.
1085
1086
1087 units = [u"s", u"ms",u'us',"ns"] # the save value
1088 if hasattr(sys.stdout, 'encoding') and sys.stdout.encoding:
1089 try:
1090 u'\xb5'.encode(sys.stdout.encoding)
1091 units = [u"s", u"ms",u'\xb5s',"ns"]
1092 except:
1093 pass
1094 scaling = [1, 1e3, 1e6, 1e9]
1095
1079
1096 if timespan >= 60.0:
1080 if timespan >= 60.0:
1097 # we have more than a minute, format that in a human readable form
1081 # we have more than a minute, format that in a human readable form
1098 # Idea from http://snipplr.com/view/5713/
1082 # Idea from http://snipplr.com/view/5713/
1099 parts = [("d", 60*60*24),("h", 60*60),("min", 60), ("s", 1)]
1083 parts = [("d", 60*60*24),("h", 60*60),("min", 60), ("s", 1)]
1100 time = []
1084 time = []
1101 leftover = timespan
1085 leftover = timespan
1102 for suffix, length in parts:
1086 for suffix, length in parts:
1103 value = int(leftover / length)
1087 value = int(leftover / length)
1104 if value > 0:
1088 if value > 0:
1105 leftover = leftover % length
1089 leftover = leftover % length
1106 time.append(u'%s%s' % (str(value), suffix))
1090 time.append(u'%s%s' % (str(value), suffix))
1107 if leftover < 1:
1091 if leftover < 1:
1108 break
1092 break
1109 return " ".join(time)
1093 return " ".join(time)
1110
1094
1095
1096 # Unfortunately the unicode 'micro' symbol can cause problems in
1097 # certain terminals.
1098 # See bug: https://bugs.launchpad.net/ipython/+bug/348466
1099 # Try to prevent crashes by being more secure than it needs to
1100 # E.g. eclipse is able to print a µ, but has no sys.stdout.encoding set.
1101 units = [u"s", u"ms",u'us',"ns"] # the save value
1102 if hasattr(sys.stdout, 'encoding') and sys.stdout.encoding:
1103 try:
1104 u'\xb5'.encode(sys.stdout.encoding)
1105 units = [u"s", u"ms",u'\xb5s',"ns"]
1106 except:
1107 pass
1108 scaling = [1, 1e3, 1e6, 1e9]
1109
1111 if timespan > 0.0:
1110 if timespan > 0.0:
1112 order = min(-int(math.floor(math.log10(timespan)) // 3), 3)
1111 order = min(-int(math.floor(math.log10(timespan)) // 3), 3)
1113 else:
1112 else:
1114 order = 3
1113 order = 3
1115 ret = u"%.*g %s" % (precision, timespan * scaling[order], units[order])
1114 ret = u"%.*g %s" % (precision, timespan * scaling[order], units[order])
1116 return ret
1115 return ret
General Comments 0
You need to be logged in to leave comments. Login now