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