##// END OF EJS Templates
Only split ast if last item is expression.
Matthias Bussonnier -
Show More
@@ -1,1502 +1,1501 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Implementation of execution-related magic functions."""
3 3
4 4 # Copyright (c) IPython Development Team.
5 5 # Distributed under the terms of the Modified BSD License.
6 6
7 7
8 8 import ast
9 9 import bdb
10 10 import builtins as builtin_mod
11 11 import gc
12 12 import itertools
13 13 import os
14 14 import shlex
15 15 import sys
16 16 import time
17 17 import timeit
18 18 import math
19 19 import re
20 20 from pdb import Restart
21 21
22 22 # cProfile was added in Python2.5
23 23 try:
24 24 import cProfile as profile
25 25 import pstats
26 26 except ImportError:
27 27 # profile isn't bundled by default in Debian for license reasons
28 28 try:
29 29 import profile, pstats
30 30 except ImportError:
31 31 profile = pstats = None
32 32
33 33 from IPython.core import oinspect
34 34 from IPython.core import magic_arguments
35 35 from IPython.core import page
36 36 from IPython.core.error import UsageError
37 37 from IPython.core.macro import Macro
38 38 from IPython.core.magic import (Magics, magics_class, line_magic, cell_magic,
39 39 line_cell_magic, on_off, needs_local_scope,
40 40 no_var_expand)
41 41 from IPython.testing.skipdoctest import skip_doctest
42 42 from IPython.utils.contexts import preserve_keys
43 43 from IPython.utils.capture import capture_output
44 44 from IPython.utils.ipstruct import Struct
45 45 from IPython.utils.module_paths import find_mod
46 46 from IPython.utils.path import get_py_filename, shellglob
47 47 from IPython.utils.timing import clock, clock2
48 48 from warnings import warn
49 49 from logging import error
50 50 from io import StringIO
51 51
52 52 if sys.version_info > (3,8):
53 53 from ast import Module
54 54 else :
55 55 # mock the new API, ignore second argument
56 56 # see https://github.com/ipython/ipython/issues/11590
57 57 from ast import Module as OriginalModule
58 58 Module = lambda nodelist, type_ignores: OriginalModule(nodelist)
59 59
60 60
61 61 #-----------------------------------------------------------------------------
62 62 # Magic implementation classes
63 63 #-----------------------------------------------------------------------------
64 64
65 65
66 66 class TimeitResult(object):
67 67 """
68 68 Object returned by the timeit magic with info about the run.
69 69
70 70 Contains the following attributes :
71 71
72 72 loops: (int) number of loops done per measurement
73 73 repeat: (int) number of times the measurement has been repeated
74 74 best: (float) best execution time / number
75 75 all_runs: (list of float) execution time of each run (in s)
76 76 compile_time: (float) time of statement compilation (s)
77 77
78 78 """
79 79 def __init__(self, loops, repeat, best, worst, all_runs, compile_time, precision):
80 80 self.loops = loops
81 81 self.repeat = repeat
82 82 self.best = best
83 83 self.worst = worst
84 84 self.all_runs = all_runs
85 85 self.compile_time = compile_time
86 86 self._precision = precision
87 87 self.timings = [ dt / self.loops for dt in all_runs]
88 88
89 89 @property
90 90 def average(self):
91 91 return math.fsum(self.timings) / len(self.timings)
92 92
93 93 @property
94 94 def stdev(self):
95 95 mean = self.average
96 96 return (math.fsum([(x - mean) ** 2 for x in self.timings]) / len(self.timings)) ** 0.5
97 97
98 98 def __str__(self):
99 99 pm = '+-'
100 100 if hasattr(sys.stdout, 'encoding') and sys.stdout.encoding:
101 101 try:
102 102 u'\xb1'.encode(sys.stdout.encoding)
103 103 pm = u'\xb1'
104 104 except:
105 105 pass
106 106 return (
107 107 u"{mean} {pm} {std} per loop (mean {pm} std. dev. of {runs} run{run_plural}, {loops} loop{loop_plural} each)"
108 108 .format(
109 109 pm = pm,
110 110 runs = self.repeat,
111 111 loops = self.loops,
112 112 loop_plural = "" if self.loops == 1 else "s",
113 113 run_plural = "" if self.repeat == 1 else "s",
114 114 mean = _format_time(self.average, self._precision),
115 115 std = _format_time(self.stdev, self._precision))
116 116 )
117 117
118 118 def _repr_pretty_(self, p , cycle):
119 119 unic = self.__str__()
120 120 p.text(u'<TimeitResult : '+unic+u'>')
121 121
122 122
123 123 class TimeitTemplateFiller(ast.NodeTransformer):
124 124 """Fill in the AST template for timing execution.
125 125
126 126 This is quite closely tied to the template definition, which is in
127 127 :meth:`ExecutionMagics.timeit`.
128 128 """
129 129 def __init__(self, ast_setup, ast_stmt):
130 130 self.ast_setup = ast_setup
131 131 self.ast_stmt = ast_stmt
132 132
133 133 def visit_FunctionDef(self, node):
134 134 "Fill in the setup statement"
135 135 self.generic_visit(node)
136 136 if node.name == "inner":
137 137 node.body[:1] = self.ast_setup.body
138 138
139 139 return node
140 140
141 141 def visit_For(self, node):
142 142 "Fill in the statement to be timed"
143 143 if getattr(getattr(node.body[0], 'value', None), 'id', None) == 'stmt':
144 144 node.body = self.ast_stmt.body
145 145 return node
146 146
147 147
148 148 class Timer(timeit.Timer):
149 149 """Timer class that explicitly uses self.inner
150 150
151 151 which is an undocumented implementation detail of CPython,
152 152 not shared by PyPy.
153 153 """
154 154 # Timer.timeit copied from CPython 3.4.2
155 155 def timeit(self, number=timeit.default_number):
156 156 """Time 'number' executions of the main statement.
157 157
158 158 To be precise, this executes the setup statement once, and
159 159 then returns the time it takes to execute the main statement
160 160 a number of times, as a float measured in seconds. The
161 161 argument is the number of times through the loop, defaulting
162 162 to one million. The main statement, the setup statement and
163 163 the timer function to be used are passed to the constructor.
164 164 """
165 165 it = itertools.repeat(None, number)
166 166 gcold = gc.isenabled()
167 167 gc.disable()
168 168 try:
169 169 timing = self.inner(it, self.timer)
170 170 finally:
171 171 if gcold:
172 172 gc.enable()
173 173 return timing
174 174
175 175
176 176 @magics_class
177 177 class ExecutionMagics(Magics):
178 178 """Magics related to code execution, debugging, profiling, etc.
179 179
180 180 """
181 181
182 182 def __init__(self, shell):
183 183 super(ExecutionMagics, self).__init__(shell)
184 184 if profile is None:
185 185 self.prun = self.profile_missing_notice
186 186 # Default execution function used to actually run user code.
187 187 self.default_runner = None
188 188
189 189 def profile_missing_notice(self, *args, **kwargs):
190 190 error("""\
191 191 The profile module could not be found. It has been removed from the standard
192 192 python packages because of its non-free license. To use profiling, install the
193 193 python-profiler package from non-free.""")
194 194
195 195 @skip_doctest
196 196 @no_var_expand
197 197 @line_cell_magic
198 198 def prun(self, parameter_s='', cell=None):
199 199
200 200 """Run a statement through the python code profiler.
201 201
202 202 Usage, in line mode:
203 203 %prun [options] statement
204 204
205 205 Usage, in cell mode:
206 206 %%prun [options] [statement]
207 207 code...
208 208 code...
209 209
210 210 In cell mode, the additional code lines are appended to the (possibly
211 211 empty) statement in the first line. Cell mode allows you to easily
212 212 profile multiline blocks without having to put them in a separate
213 213 function.
214 214
215 215 The given statement (which doesn't require quote marks) is run via the
216 216 python profiler in a manner similar to the profile.run() function.
217 217 Namespaces are internally managed to work correctly; profile.run
218 218 cannot be used in IPython because it makes certain assumptions about
219 219 namespaces which do not hold under IPython.
220 220
221 221 Options:
222 222
223 223 -l <limit>
224 224 you can place restrictions on what or how much of the
225 225 profile gets printed. The limit value can be:
226 226
227 227 * A string: only information for function names containing this string
228 228 is printed.
229 229
230 230 * An integer: only these many lines are printed.
231 231
232 232 * A float (between 0 and 1): this fraction of the report is printed
233 233 (for example, use a limit of 0.4 to see the topmost 40% only).
234 234
235 235 You can combine several limits with repeated use of the option. For
236 236 example, ``-l __init__ -l 5`` will print only the topmost 5 lines of
237 237 information about class constructors.
238 238
239 239 -r
240 240 return the pstats.Stats object generated by the profiling. This
241 241 object has all the information about the profile in it, and you can
242 242 later use it for further analysis or in other functions.
243 243
244 244 -s <key>
245 245 sort profile by given key. You can provide more than one key
246 246 by using the option several times: '-s key1 -s key2 -s key3...'. The
247 247 default sorting key is 'time'.
248 248
249 249 The following is copied verbatim from the profile documentation
250 250 referenced below:
251 251
252 252 When more than one key is provided, additional keys are used as
253 253 secondary criteria when the there is equality in all keys selected
254 254 before them.
255 255
256 256 Abbreviations can be used for any key names, as long as the
257 257 abbreviation is unambiguous. The following are the keys currently
258 258 defined:
259 259
260 260 ============ =====================
261 261 Valid Arg Meaning
262 262 ============ =====================
263 263 "calls" call count
264 264 "cumulative" cumulative time
265 265 "file" file name
266 266 "module" file name
267 267 "pcalls" primitive call count
268 268 "line" line number
269 269 "name" function name
270 270 "nfl" name/file/line
271 271 "stdname" standard name
272 272 "time" internal time
273 273 ============ =====================
274 274
275 275 Note that all sorts on statistics are in descending order (placing
276 276 most time consuming items first), where as name, file, and line number
277 277 searches are in ascending order (i.e., alphabetical). The subtle
278 278 distinction between "nfl" and "stdname" is that the standard name is a
279 279 sort of the name as printed, which means that the embedded line
280 280 numbers get compared in an odd way. For example, lines 3, 20, and 40
281 281 would (if the file names were the same) appear in the string order
282 282 "20" "3" and "40". In contrast, "nfl" does a numeric compare of the
283 283 line numbers. In fact, sort_stats("nfl") is the same as
284 284 sort_stats("name", "file", "line").
285 285
286 286 -T <filename>
287 287 save profile results as shown on screen to a text
288 288 file. The profile is still shown on screen.
289 289
290 290 -D <filename>
291 291 save (via dump_stats) profile statistics to given
292 292 filename. This data is in a format understood by the pstats module, and
293 293 is generated by a call to the dump_stats() method of profile
294 294 objects. The profile is still shown on screen.
295 295
296 296 -q
297 297 suppress output to the pager. Best used with -T and/or -D above.
298 298
299 299 If you want to run complete programs under the profiler's control, use
300 300 ``%run -p [prof_opts] filename.py [args to program]`` where prof_opts
301 301 contains profiler specific options as described here.
302 302
303 303 You can read the complete documentation for the profile module with::
304 304
305 305 In [1]: import profile; profile.help()
306 306
307 307 .. versionchanged:: 7.3
308 308 User variables are no longer expanded,
309 309 the magic line is always left unmodified.
310 310
311 311 """
312 312 opts, arg_str = self.parse_options(parameter_s, 'D:l:rs:T:q',
313 313 list_all=True, posix=False)
314 314 if cell is not None:
315 315 arg_str += '\n' + cell
316 316 arg_str = self.shell.transform_cell(arg_str)
317 317 return self._run_with_profiler(arg_str, opts, self.shell.user_ns)
318 318
319 319 def _run_with_profiler(self, code, opts, namespace):
320 320 """
321 321 Run `code` with profiler. Used by ``%prun`` and ``%run -p``.
322 322
323 323 Parameters
324 324 ----------
325 325 code : str
326 326 Code to be executed.
327 327 opts : Struct
328 328 Options parsed by `self.parse_options`.
329 329 namespace : dict
330 330 A dictionary for Python namespace (e.g., `self.shell.user_ns`).
331 331
332 332 """
333 333
334 334 # Fill default values for unspecified options:
335 335 opts.merge(Struct(D=[''], l=[], s=['time'], T=['']))
336 336
337 337 prof = profile.Profile()
338 338 try:
339 339 prof = prof.runctx(code, namespace, namespace)
340 340 sys_exit = ''
341 341 except SystemExit:
342 342 sys_exit = """*** SystemExit exception caught in code being profiled."""
343 343
344 344 stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
345 345
346 346 lims = opts.l
347 347 if lims:
348 348 lims = [] # rebuild lims with ints/floats/strings
349 349 for lim in opts.l:
350 350 try:
351 351 lims.append(int(lim))
352 352 except ValueError:
353 353 try:
354 354 lims.append(float(lim))
355 355 except ValueError:
356 356 lims.append(lim)
357 357
358 358 # Trap output.
359 359 stdout_trap = StringIO()
360 360 stats_stream = stats.stream
361 361 try:
362 362 stats.stream = stdout_trap
363 363 stats.print_stats(*lims)
364 364 finally:
365 365 stats.stream = stats_stream
366 366
367 367 output = stdout_trap.getvalue()
368 368 output = output.rstrip()
369 369
370 370 if 'q' not in opts:
371 371 page.page(output)
372 372 print(sys_exit, end=' ')
373 373
374 374 dump_file = opts.D[0]
375 375 text_file = opts.T[0]
376 376 if dump_file:
377 377 prof.dump_stats(dump_file)
378 378 print('\n*** Profile stats marshalled to file',\
379 379 repr(dump_file)+'.',sys_exit)
380 380 if text_file:
381 381 with open(text_file, 'w') as pfile:
382 382 pfile.write(output)
383 383 print('\n*** Profile printout saved to text file',\
384 384 repr(text_file)+'.',sys_exit)
385 385
386 386 if 'r' in opts:
387 387 return stats
388 388 else:
389 389 return None
390 390
391 391 @line_magic
392 392 def pdb(self, parameter_s=''):
393 393 """Control the automatic calling of the pdb interactive debugger.
394 394
395 395 Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
396 396 argument it works as a toggle.
397 397
398 398 When an exception is triggered, IPython can optionally call the
399 399 interactive pdb debugger after the traceback printout. %pdb toggles
400 400 this feature on and off.
401 401
402 402 The initial state of this feature is set in your configuration
403 403 file (the option is ``InteractiveShell.pdb``).
404 404
405 405 If you want to just activate the debugger AFTER an exception has fired,
406 406 without having to type '%pdb on' and rerunning your code, you can use
407 407 the %debug magic."""
408 408
409 409 par = parameter_s.strip().lower()
410 410
411 411 if par:
412 412 try:
413 413 new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
414 414 except KeyError:
415 415 print ('Incorrect argument. Use on/1, off/0, '
416 416 'or nothing for a toggle.')
417 417 return
418 418 else:
419 419 # toggle
420 420 new_pdb = not self.shell.call_pdb
421 421
422 422 # set on the shell
423 423 self.shell.call_pdb = new_pdb
424 424 print('Automatic pdb calling has been turned',on_off(new_pdb))
425 425
426 426 @skip_doctest
427 427 @magic_arguments.magic_arguments()
428 428 @magic_arguments.argument('--breakpoint', '-b', metavar='FILE:LINE',
429 429 help="""
430 430 Set break point at LINE in FILE.
431 431 """
432 432 )
433 433 @magic_arguments.argument('statement', nargs='*',
434 434 help="""
435 435 Code to run in debugger.
436 436 You can omit this in cell magic mode.
437 437 """
438 438 )
439 439 @no_var_expand
440 440 @line_cell_magic
441 441 def debug(self, line='', cell=None):
442 442 """Activate the interactive debugger.
443 443
444 444 This magic command support two ways of activating debugger.
445 445 One is to activate debugger before executing code. This way, you
446 446 can set a break point, to step through the code from the point.
447 447 You can use this mode by giving statements to execute and optionally
448 448 a breakpoint.
449 449
450 450 The other one is to activate debugger in post-mortem mode. You can
451 451 activate this mode simply running %debug without any argument.
452 452 If an exception has just occurred, this lets you inspect its stack
453 453 frames interactively. Note that this will always work only on the last
454 454 traceback that occurred, so you must call this quickly after an
455 455 exception that you wish to inspect has fired, because if another one
456 456 occurs, it clobbers the previous one.
457 457
458 458 If you want IPython to automatically do this on every exception, see
459 459 the %pdb magic for more details.
460 460
461 461 .. versionchanged:: 7.3
462 462 When running code, user variables are no longer expanded,
463 463 the magic line is always left unmodified.
464 464
465 465 """
466 466 args = magic_arguments.parse_argstring(self.debug, line)
467 467
468 468 if not (args.breakpoint or args.statement or cell):
469 469 self._debug_post_mortem()
470 470 else:
471 471 code = "\n".join(args.statement)
472 472 if cell:
473 473 code += "\n" + cell
474 474 self._debug_exec(code, args.breakpoint)
475 475
476 476 def _debug_post_mortem(self):
477 477 self.shell.debugger(force=True)
478 478
479 479 def _debug_exec(self, code, breakpoint):
480 480 if breakpoint:
481 481 (filename, bp_line) = breakpoint.rsplit(':', 1)
482 482 bp_line = int(bp_line)
483 483 else:
484 484 (filename, bp_line) = (None, None)
485 485 self._run_with_debugger(code, self.shell.user_ns, filename, bp_line)
486 486
487 487 @line_magic
488 488 def tb(self, s):
489 489 """Print the last traceback.
490 490
491 491 Optionally, specify an exception reporting mode, tuning the
492 492 verbosity of the traceback. By default the currently-active exception
493 493 mode is used. See %xmode for changing exception reporting modes.
494 494
495 495 Valid modes: Plain, Context, Verbose, and Minimal.
496 496 """
497 497 interactive_tb = self.shell.InteractiveTB
498 498 if s:
499 499 # Switch exception reporting mode for this one call.
500 500 # Ensure it is switched back.
501 501 def xmode_switch_err(name):
502 502 warn('Error changing %s exception modes.\n%s' %
503 503 (name,sys.exc_info()[1]))
504 504
505 505 new_mode = s.strip().capitalize()
506 506 original_mode = interactive_tb.mode
507 507 try:
508 508 try:
509 509 interactive_tb.set_mode(mode=new_mode)
510 510 except Exception:
511 511 xmode_switch_err('user')
512 512 else:
513 513 self.shell.showtraceback()
514 514 finally:
515 515 interactive_tb.set_mode(mode=original_mode)
516 516 else:
517 517 self.shell.showtraceback()
518 518
519 519 @skip_doctest
520 520 @line_magic
521 521 def run(self, parameter_s='', runner=None,
522 522 file_finder=get_py_filename):
523 523 """Run the named file inside IPython as a program.
524 524
525 525 Usage::
526 526
527 527 %run [-n -i -e -G]
528 528 [( -t [-N<N>] | -d [-b<N>] | -p [profile options] )]
529 529 ( -m mod | file ) [args]
530 530
531 531 Parameters after the filename are passed as command-line arguments to
532 532 the program (put in sys.argv). Then, control returns to IPython's
533 533 prompt.
534 534
535 535 This is similar to running at a system prompt ``python file args``,
536 536 but with the advantage of giving you IPython's tracebacks, and of
537 537 loading all variables into your interactive namespace for further use
538 538 (unless -p is used, see below).
539 539
540 540 The file is executed in a namespace initially consisting only of
541 541 ``__name__=='__main__'`` and sys.argv constructed as indicated. It thus
542 542 sees its environment as if it were being run as a stand-alone program
543 543 (except for sharing global objects such as previously imported
544 544 modules). But after execution, the IPython interactive namespace gets
545 545 updated with all variables defined in the program (except for __name__
546 546 and sys.argv). This allows for very convenient loading of code for
547 547 interactive work, while giving each program a 'clean sheet' to run in.
548 548
549 549 Arguments are expanded using shell-like glob match. Patterns
550 550 '*', '?', '[seq]' and '[!seq]' can be used. Additionally,
551 551 tilde '~' will be expanded into user's home directory. Unlike
552 552 real shells, quotation does not suppress expansions. Use
553 553 *two* back slashes (e.g. ``\\\\*``) to suppress expansions.
554 554 To completely disable these expansions, you can use -G flag.
555 555
556 556 On Windows systems, the use of single quotes `'` when specifying
557 557 a file is not supported. Use double quotes `"`.
558 558
559 559 Options:
560 560
561 561 -n
562 562 __name__ is NOT set to '__main__', but to the running file's name
563 563 without extension (as python does under import). This allows running
564 564 scripts and reloading the definitions in them without calling code
565 565 protected by an ``if __name__ == "__main__"`` clause.
566 566
567 567 -i
568 568 run the file in IPython's namespace instead of an empty one. This
569 569 is useful if you are experimenting with code written in a text editor
570 570 which depends on variables defined interactively.
571 571
572 572 -e
573 573 ignore sys.exit() calls or SystemExit exceptions in the script
574 574 being run. This is particularly useful if IPython is being used to
575 575 run unittests, which always exit with a sys.exit() call. In such
576 576 cases you are interested in the output of the test results, not in
577 577 seeing a traceback of the unittest module.
578 578
579 579 -t
580 580 print timing information at the end of the run. IPython will give
581 581 you an estimated CPU time consumption for your script, which under
582 582 Unix uses the resource module to avoid the wraparound problems of
583 583 time.clock(). Under Unix, an estimate of time spent on system tasks
584 584 is also given (for Windows platforms this is reported as 0.0).
585 585
586 586 If -t is given, an additional ``-N<N>`` option can be given, where <N>
587 587 must be an integer indicating how many times you want the script to
588 588 run. The final timing report will include total and per run results.
589 589
590 590 For example (testing the script uniq_stable.py)::
591 591
592 592 In [1]: run -t uniq_stable
593 593
594 594 IPython CPU timings (estimated):
595 595 User : 0.19597 s.
596 596 System: 0.0 s.
597 597
598 598 In [2]: run -t -N5 uniq_stable
599 599
600 600 IPython CPU timings (estimated):
601 601 Total runs performed: 5
602 602 Times : Total Per run
603 603 User : 0.910862 s, 0.1821724 s.
604 604 System: 0.0 s, 0.0 s.
605 605
606 606 -d
607 607 run your program under the control of pdb, the Python debugger.
608 608 This allows you to execute your program step by step, watch variables,
609 609 etc. Internally, what IPython does is similar to calling::
610 610
611 611 pdb.run('execfile("YOURFILENAME")')
612 612
613 613 with a breakpoint set on line 1 of your file. You can change the line
614 614 number for this automatic breakpoint to be <N> by using the -bN option
615 615 (where N must be an integer). For example::
616 616
617 617 %run -d -b40 myscript
618 618
619 619 will set the first breakpoint at line 40 in myscript.py. Note that
620 620 the first breakpoint must be set on a line which actually does
621 621 something (not a comment or docstring) for it to stop execution.
622 622
623 623 Or you can specify a breakpoint in a different file::
624 624
625 625 %run -d -b myotherfile.py:20 myscript
626 626
627 627 When the pdb debugger starts, you will see a (Pdb) prompt. You must
628 628 first enter 'c' (without quotes) to start execution up to the first
629 629 breakpoint.
630 630
631 631 Entering 'help' gives information about the use of the debugger. You
632 632 can easily see pdb's full documentation with "import pdb;pdb.help()"
633 633 at a prompt.
634 634
635 635 -p
636 636 run program under the control of the Python profiler module (which
637 637 prints a detailed report of execution times, function calls, etc).
638 638
639 639 You can pass other options after -p which affect the behavior of the
640 640 profiler itself. See the docs for %prun for details.
641 641
642 642 In this mode, the program's variables do NOT propagate back to the
643 643 IPython interactive namespace (because they remain in the namespace
644 644 where the profiler executes them).
645 645
646 646 Internally this triggers a call to %prun, see its documentation for
647 647 details on the options available specifically for profiling.
648 648
649 649 There is one special usage for which the text above doesn't apply:
650 650 if the filename ends with .ipy[nb], the file is run as ipython script,
651 651 just as if the commands were written on IPython prompt.
652 652
653 653 -m
654 654 specify module name to load instead of script path. Similar to
655 655 the -m option for the python interpreter. Use this option last if you
656 656 want to combine with other %run options. Unlike the python interpreter
657 657 only source modules are allowed no .pyc or .pyo files.
658 658 For example::
659 659
660 660 %run -m example
661 661
662 662 will run the example module.
663 663
664 664 -G
665 665 disable shell-like glob expansion of arguments.
666 666
667 667 """
668 668
669 669 # Logic to handle issue #3664
670 670 # Add '--' after '-m <module_name>' to ignore additional args passed to a module.
671 671 if '-m' in parameter_s and '--' not in parameter_s:
672 672 argv = shlex.split(parameter_s, posix=(os.name == 'posix'))
673 673 for idx, arg in enumerate(argv):
674 674 if arg and arg.startswith('-') and arg != '-':
675 675 if arg == '-m':
676 676 argv.insert(idx + 2, '--')
677 677 break
678 678 else:
679 679 # Positional arg, break
680 680 break
681 681 parameter_s = ' '.join(shlex.quote(arg) for arg in argv)
682 682
683 683 # get arguments and set sys.argv for program to be run.
684 684 opts, arg_lst = self.parse_options(parameter_s,
685 685 'nidtN:b:pD:l:rs:T:em:G',
686 686 mode='list', list_all=1)
687 687 if "m" in opts:
688 688 modulename = opts["m"][0]
689 689 modpath = find_mod(modulename)
690 690 if modpath is None:
691 691 warn('%r is not a valid modulename on sys.path'%modulename)
692 692 return
693 693 arg_lst = [modpath] + arg_lst
694 694 try:
695 695 fpath = None # initialize to make sure fpath is in scope later
696 696 fpath = arg_lst[0]
697 697 filename = file_finder(fpath)
698 698 except IndexError:
699 699 warn('you must provide at least a filename.')
700 700 print('\n%run:\n', oinspect.getdoc(self.run))
701 701 return
702 702 except IOError as e:
703 703 try:
704 704 msg = str(e)
705 705 except UnicodeError:
706 706 msg = e.message
707 707 if os.name == 'nt' and re.match(r"^'.*'$",fpath):
708 708 warn('For Windows, use double quotes to wrap a filename: %run "mypath\\myfile.py"')
709 709 error(msg)
710 710 return
711 711
712 712 if filename.lower().endswith(('.ipy', '.ipynb')):
713 713 with preserve_keys(self.shell.user_ns, '__file__'):
714 714 self.shell.user_ns['__file__'] = filename
715 715 self.shell.safe_execfile_ipy(filename)
716 716 return
717 717
718 718 # Control the response to exit() calls made by the script being run
719 719 exit_ignore = 'e' in opts
720 720
721 721 # Make sure that the running script gets a proper sys.argv as if it
722 722 # were run from a system shell.
723 723 save_argv = sys.argv # save it for later restoring
724 724
725 725 if 'G' in opts:
726 726 args = arg_lst[1:]
727 727 else:
728 728 # tilde and glob expansion
729 729 args = shellglob(map(os.path.expanduser, arg_lst[1:]))
730 730
731 731 sys.argv = [filename] + args # put in the proper filename
732 732
733 733 if 'n' in opts:
734 734 name = os.path.splitext(os.path.basename(filename))[0]
735 735 else:
736 736 name = '__main__'
737 737
738 738 if 'i' in opts:
739 739 # Run in user's interactive namespace
740 740 prog_ns = self.shell.user_ns
741 741 __name__save = self.shell.user_ns['__name__']
742 742 prog_ns['__name__'] = name
743 743 main_mod = self.shell.user_module
744 744
745 745 # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
746 746 # set the __file__ global in the script's namespace
747 747 # TK: Is this necessary in interactive mode?
748 748 prog_ns['__file__'] = filename
749 749 else:
750 750 # Run in a fresh, empty namespace
751 751
752 752 # The shell MUST hold a reference to prog_ns so after %run
753 753 # exits, the python deletion mechanism doesn't zero it out
754 754 # (leaving dangling references). See interactiveshell for details
755 755 main_mod = self.shell.new_main_mod(filename, name)
756 756 prog_ns = main_mod.__dict__
757 757
758 758 # pickle fix. See interactiveshell for an explanation. But we need to
759 759 # make sure that, if we overwrite __main__, we replace it at the end
760 760 main_mod_name = prog_ns['__name__']
761 761
762 762 if main_mod_name == '__main__':
763 763 restore_main = sys.modules['__main__']
764 764 else:
765 765 restore_main = False
766 766
767 767 # This needs to be undone at the end to prevent holding references to
768 768 # every single object ever created.
769 769 sys.modules[main_mod_name] = main_mod
770 770
771 771 if 'p' in opts or 'd' in opts:
772 772 if 'm' in opts:
773 773 code = 'run_module(modulename, prog_ns)'
774 774 code_ns = {
775 775 'run_module': self.shell.safe_run_module,
776 776 'prog_ns': prog_ns,
777 777 'modulename': modulename,
778 778 }
779 779 else:
780 780 if 'd' in opts:
781 781 # allow exceptions to raise in debug mode
782 782 code = 'execfile(filename, prog_ns, raise_exceptions=True)'
783 783 else:
784 784 code = 'execfile(filename, prog_ns)'
785 785 code_ns = {
786 786 'execfile': self.shell.safe_execfile,
787 787 'prog_ns': prog_ns,
788 788 'filename': get_py_filename(filename),
789 789 }
790 790
791 791 try:
792 792 stats = None
793 793 if 'p' in opts:
794 794 stats = self._run_with_profiler(code, opts, code_ns)
795 795 else:
796 796 if 'd' in opts:
797 797 bp_file, bp_line = parse_breakpoint(
798 798 opts.get('b', ['1'])[0], filename)
799 799 self._run_with_debugger(
800 800 code, code_ns, filename, bp_line, bp_file)
801 801 else:
802 802 if 'm' in opts:
803 803 def run():
804 804 self.shell.safe_run_module(modulename, prog_ns)
805 805 else:
806 806 if runner is None:
807 807 runner = self.default_runner
808 808 if runner is None:
809 809 runner = self.shell.safe_execfile
810 810
811 811 def run():
812 812 runner(filename, prog_ns, prog_ns,
813 813 exit_ignore=exit_ignore)
814 814
815 815 if 't' in opts:
816 816 # timed execution
817 817 try:
818 818 nruns = int(opts['N'][0])
819 819 if nruns < 1:
820 820 error('Number of runs must be >=1')
821 821 return
822 822 except (KeyError):
823 823 nruns = 1
824 824 self._run_with_timing(run, nruns)
825 825 else:
826 826 # regular execution
827 827 run()
828 828
829 829 if 'i' in opts:
830 830 self.shell.user_ns['__name__'] = __name__save
831 831 else:
832 832 # update IPython interactive namespace
833 833
834 834 # Some forms of read errors on the file may mean the
835 835 # __name__ key was never set; using pop we don't have to
836 836 # worry about a possible KeyError.
837 837 prog_ns.pop('__name__', None)
838 838
839 839 with preserve_keys(self.shell.user_ns, '__file__'):
840 840 self.shell.user_ns.update(prog_ns)
841 841 finally:
842 842 # It's a bit of a mystery why, but __builtins__ can change from
843 843 # being a module to becoming a dict missing some key data after
844 844 # %run. As best I can see, this is NOT something IPython is doing
845 845 # at all, and similar problems have been reported before:
846 846 # http://coding.derkeiler.com/Archive/Python/comp.lang.python/2004-10/0188.html
847 847 # Since this seems to be done by the interpreter itself, the best
848 848 # we can do is to at least restore __builtins__ for the user on
849 849 # exit.
850 850 self.shell.user_ns['__builtins__'] = builtin_mod
851 851
852 852 # Ensure key global structures are restored
853 853 sys.argv = save_argv
854 854 if restore_main:
855 855 sys.modules['__main__'] = restore_main
856 856 else:
857 857 # Remove from sys.modules the reference to main_mod we'd
858 858 # added. Otherwise it will trap references to objects
859 859 # contained therein.
860 860 del sys.modules[main_mod_name]
861 861
862 862 return stats
863 863
864 864 def _run_with_debugger(self, code, code_ns, filename=None,
865 865 bp_line=None, bp_file=None):
866 866 """
867 867 Run `code` in debugger with a break point.
868 868
869 869 Parameters
870 870 ----------
871 871 code : str
872 872 Code to execute.
873 873 code_ns : dict
874 874 A namespace in which `code` is executed.
875 875 filename : str
876 876 `code` is ran as if it is in `filename`.
877 877 bp_line : int, optional
878 878 Line number of the break point.
879 879 bp_file : str, optional
880 880 Path to the file in which break point is specified.
881 881 `filename` is used if not given.
882 882
883 883 Raises
884 884 ------
885 885 UsageError
886 886 If the break point given by `bp_line` is not valid.
887 887
888 888 """
889 889 deb = self.shell.InteractiveTB.pdb
890 890 if not deb:
891 891 self.shell.InteractiveTB.pdb = self.shell.InteractiveTB.debugger_cls()
892 892 deb = self.shell.InteractiveTB.pdb
893 893
894 894 # deb.checkline() fails if deb.curframe exists but is None; it can
895 895 # handle it not existing. https://github.com/ipython/ipython/issues/10028
896 896 if hasattr(deb, 'curframe'):
897 897 del deb.curframe
898 898
899 899 # reset Breakpoint state, which is moronically kept
900 900 # in a class
901 901 bdb.Breakpoint.next = 1
902 902 bdb.Breakpoint.bplist = {}
903 903 bdb.Breakpoint.bpbynumber = [None]
904 904 deb.clear_all_breaks()
905 905 if bp_line is not None:
906 906 # Set an initial breakpoint to stop execution
907 907 maxtries = 10
908 908 bp_file = bp_file or filename
909 909 checkline = deb.checkline(bp_file, bp_line)
910 910 if not checkline:
911 911 for bp in range(bp_line + 1, bp_line + maxtries + 1):
912 912 if deb.checkline(bp_file, bp):
913 913 break
914 914 else:
915 915 msg = ("\nI failed to find a valid line to set "
916 916 "a breakpoint\n"
917 917 "after trying up to line: %s.\n"
918 918 "Please set a valid breakpoint manually "
919 919 "with the -b option." % bp)
920 920 raise UsageError(msg)
921 921 # if we find a good linenumber, set the breakpoint
922 922 deb.do_break('%s:%s' % (bp_file, bp_line))
923 923
924 924 if filename:
925 925 # Mimic Pdb._runscript(...)
926 926 deb._wait_for_mainpyfile = True
927 927 deb.mainpyfile = deb.canonic(filename)
928 928
929 929 # Start file run
930 930 print("NOTE: Enter 'c' at the %s prompt to continue execution." % deb.prompt)
931 931 try:
932 932 if filename:
933 933 # save filename so it can be used by methods on the deb object
934 934 deb._exec_filename = filename
935 935 while True:
936 936 try:
937 937 trace = sys.gettrace()
938 938 deb.run(code, code_ns)
939 939 except Restart:
940 940 print("Restarting")
941 941 if filename:
942 942 deb._wait_for_mainpyfile = True
943 943 deb.mainpyfile = deb.canonic(filename)
944 944 continue
945 945 else:
946 946 break
947 947 finally:
948 948 sys.settrace(trace)
949 949
950 950
951 951 except:
952 952 etype, value, tb = sys.exc_info()
953 953 # Skip three frames in the traceback: the %run one,
954 954 # one inside bdb.py, and the command-line typed by the
955 955 # user (run by exec in pdb itself).
956 956 self.shell.InteractiveTB(etype, value, tb, tb_offset=3)
957 957
958 958 @staticmethod
959 959 def _run_with_timing(run, nruns):
960 960 """
961 961 Run function `run` and print timing information.
962 962
963 963 Parameters
964 964 ----------
965 965 run : callable
966 966 Any callable object which takes no argument.
967 967 nruns : int
968 968 Number of times to execute `run`.
969 969
970 970 """
971 971 twall0 = time.perf_counter()
972 972 if nruns == 1:
973 973 t0 = clock2()
974 974 run()
975 975 t1 = clock2()
976 976 t_usr = t1[0] - t0[0]
977 977 t_sys = t1[1] - t0[1]
978 978 print("\nIPython CPU timings (estimated):")
979 979 print(" User : %10.2f s." % t_usr)
980 980 print(" System : %10.2f s." % t_sys)
981 981 else:
982 982 runs = range(nruns)
983 983 t0 = clock2()
984 984 for nr in runs:
985 985 run()
986 986 t1 = clock2()
987 987 t_usr = t1[0] - t0[0]
988 988 t_sys = t1[1] - t0[1]
989 989 print("\nIPython CPU timings (estimated):")
990 990 print("Total runs performed:", nruns)
991 991 print(" Times : %10s %10s" % ('Total', 'Per run'))
992 992 print(" User : %10.2f s, %10.2f s." % (t_usr, t_usr / nruns))
993 993 print(" System : %10.2f s, %10.2f s." % (t_sys, t_sys / nruns))
994 994 twall1 = time.perf_counter()
995 995 print("Wall time: %10.2f s." % (twall1 - twall0))
996 996
997 997 @skip_doctest
998 998 @no_var_expand
999 999 @line_cell_magic
1000 1000 @needs_local_scope
1001 1001 def timeit(self, line='', cell=None, local_ns=None):
1002 1002 """Time execution of a Python statement or expression
1003 1003
1004 1004 Usage, in line mode:
1005 1005 %timeit [-n<N> -r<R> [-t|-c] -q -p<P> -o] statement
1006 1006 or in cell mode:
1007 1007 %%timeit [-n<N> -r<R> [-t|-c] -q -p<P> -o] setup_code
1008 1008 code
1009 1009 code...
1010 1010
1011 1011 Time execution of a Python statement or expression using the timeit
1012 1012 module. This function can be used both as a line and cell magic:
1013 1013
1014 1014 - In line mode you can time a single-line statement (though multiple
1015 1015 ones can be chained with using semicolons).
1016 1016
1017 1017 - In cell mode, the statement in the first line is used as setup code
1018 1018 (executed but not timed) and the body of the cell is timed. The cell
1019 1019 body has access to any variables created in the setup code.
1020 1020
1021 1021 Options:
1022 1022 -n<N>: execute the given statement <N> times in a loop. If <N> is not
1023 1023 provided, <N> is determined so as to get sufficient accuracy.
1024 1024
1025 1025 -r<R>: number of repeats <R>, each consisting of <N> loops, and take the
1026 1026 best result.
1027 1027 Default: 7
1028 1028
1029 1029 -t: use time.time to measure the time, which is the default on Unix.
1030 1030 This function measures wall time.
1031 1031
1032 1032 -c: use time.clock to measure the time, which is the default on
1033 1033 Windows and measures wall time. On Unix, resource.getrusage is used
1034 1034 instead and returns the CPU user time.
1035 1035
1036 1036 -p<P>: use a precision of <P> digits to display the timing result.
1037 1037 Default: 3
1038 1038
1039 1039 -q: Quiet, do not print result.
1040 1040
1041 1041 -o: return a TimeitResult that can be stored in a variable to inspect
1042 1042 the result in more details.
1043 1043
1044 1044 .. versionchanged:: 7.3
1045 1045 User variables are no longer expanded,
1046 1046 the magic line is always left unmodified.
1047 1047
1048 1048 Examples
1049 1049 --------
1050 1050 ::
1051 1051
1052 1052 In [1]: %timeit pass
1053 1053 8.26 ns ± 0.12 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)
1054 1054
1055 1055 In [2]: u = None
1056 1056
1057 1057 In [3]: %timeit u is None
1058 1058 29.9 ns ± 0.643 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
1059 1059
1060 1060 In [4]: %timeit -r 4 u == None
1061 1061
1062 1062 In [5]: import time
1063 1063
1064 1064 In [6]: %timeit -n1 time.sleep(2)
1065 1065
1066 1066
1067 1067 The times reported by %timeit will be slightly higher than those
1068 1068 reported by the timeit.py script when variables are accessed. This is
1069 1069 due to the fact that %timeit executes the statement in the namespace
1070 1070 of the shell, compared with timeit.py, which uses a single setup
1071 1071 statement to import function or create variables. Generally, the bias
1072 1072 does not matter as long as results from timeit.py are not mixed with
1073 1073 those from %timeit."""
1074 1074
1075 1075 opts, stmt = self.parse_options(line,'n:r:tcp:qo',
1076 1076 posix=False, strict=False)
1077 1077 if stmt == "" and cell is None:
1078 1078 return
1079 1079
1080 1080 timefunc = timeit.default_timer
1081 1081 number = int(getattr(opts, "n", 0))
1082 1082 default_repeat = 7 if timeit.default_repeat < 7 else timeit.default_repeat
1083 1083 repeat = int(getattr(opts, "r", default_repeat))
1084 1084 precision = int(getattr(opts, "p", 3))
1085 1085 quiet = 'q' in opts
1086 1086 return_result = 'o' in opts
1087 1087 if hasattr(opts, "t"):
1088 1088 timefunc = time.time
1089 1089 if hasattr(opts, "c"):
1090 1090 timefunc = clock
1091 1091
1092 1092 timer = Timer(timer=timefunc)
1093 1093 # this code has tight coupling to the inner workings of timeit.Timer,
1094 1094 # but is there a better way to achieve that the code stmt has access
1095 1095 # to the shell namespace?
1096 1096 transform = self.shell.transform_cell
1097 1097
1098 1098 if cell is None:
1099 1099 # called as line magic
1100 1100 ast_setup = self.shell.compile.ast_parse("pass")
1101 1101 ast_stmt = self.shell.compile.ast_parse(transform(stmt))
1102 1102 else:
1103 1103 ast_setup = self.shell.compile.ast_parse(transform(stmt))
1104 1104 ast_stmt = self.shell.compile.ast_parse(transform(cell))
1105 1105
1106 1106 ast_setup = self.shell.transform_ast(ast_setup)
1107 1107 ast_stmt = self.shell.transform_ast(ast_stmt)
1108 1108
1109 1109 # Check that these compile to valid Python code *outside* the timer func
1110 1110 # Invalid code may become valid when put inside the function & loop,
1111 1111 # which messes up error messages.
1112 1112 # https://github.com/ipython/ipython/issues/10636
1113 1113 self.shell.compile(ast_setup, "<magic-timeit-setup>", "exec")
1114 1114 self.shell.compile(ast_stmt, "<magic-timeit-stmt>", "exec")
1115 1115
1116 1116 # This codestring is taken from timeit.template - we fill it in as an
1117 1117 # AST, so that we can apply our AST transformations to the user code
1118 1118 # without affecting the timing code.
1119 1119 timeit_ast_template = ast.parse('def inner(_it, _timer):\n'
1120 1120 ' setup\n'
1121 1121 ' _t0 = _timer()\n'
1122 1122 ' for _i in _it:\n'
1123 1123 ' stmt\n'
1124 1124 ' _t1 = _timer()\n'
1125 1125 ' return _t1 - _t0\n')
1126 1126
1127 1127 timeit_ast = TimeitTemplateFiller(ast_setup, ast_stmt).visit(timeit_ast_template)
1128 1128 timeit_ast = ast.fix_missing_locations(timeit_ast)
1129 1129
1130 1130 # Track compilation time so it can be reported if too long
1131 1131 # Minimum time above which compilation time will be reported
1132 1132 tc_min = 0.1
1133 1133
1134 1134 t0 = clock()
1135 1135 code = self.shell.compile(timeit_ast, "<magic-timeit>", "exec")
1136 1136 tc = clock()-t0
1137 1137
1138 1138 ns = {}
1139 1139 glob = self.shell.user_ns
1140 1140 # handles global vars with same name as local vars. We store them in conflict_globs.
1141 1141 conflict_globs = {}
1142 1142 if local_ns and cell is None:
1143 1143 for var_name, var_val in glob.items():
1144 1144 if var_name in local_ns:
1145 1145 conflict_globs[var_name] = var_val
1146 1146 glob.update(local_ns)
1147 1147
1148 1148 exec(code, glob, ns)
1149 1149 timer.inner = ns["inner"]
1150 1150
1151 1151 # This is used to check if there is a huge difference between the
1152 1152 # best and worst timings.
1153 1153 # Issue: https://github.com/ipython/ipython/issues/6471
1154 1154 if number == 0:
1155 1155 # determine number so that 0.2 <= total time < 2.0
1156 1156 for index in range(0, 10):
1157 1157 number = 10 ** index
1158 1158 time_number = timer.timeit(number)
1159 1159 if time_number >= 0.2:
1160 1160 break
1161 1161
1162 1162 all_runs = timer.repeat(repeat, number)
1163 1163 best = min(all_runs) / number
1164 1164 worst = max(all_runs) / number
1165 1165 timeit_result = TimeitResult(number, repeat, best, worst, all_runs, tc, precision)
1166 1166
1167 1167 # Restore global vars from conflict_globs
1168 1168 if conflict_globs:
1169 1169 glob.update(conflict_globs)
1170 1170
1171 1171 if not quiet :
1172 1172 # Check best timing is greater than zero to avoid a
1173 1173 # ZeroDivisionError.
1174 1174 # In cases where the slowest timing is lesser than a micosecond
1175 1175 # we assume that it does not really matter if the fastest
1176 1176 # timing is 4 times faster than the slowest timing or not.
1177 1177 if worst > 4 * best and best > 0 and worst > 1e-6:
1178 1178 print("The slowest run took %0.2f times longer than the "
1179 1179 "fastest. This could mean that an intermediate result "
1180 1180 "is being cached." % (worst / best))
1181 1181
1182 1182 print( timeit_result )
1183 1183
1184 1184 if tc > tc_min:
1185 1185 print("Compiler time: %.2f s" % tc)
1186 1186 if return_result:
1187 1187 return timeit_result
1188 1188
1189 1189 @skip_doctest
1190 1190 @no_var_expand
1191 1191 @needs_local_scope
1192 1192 @line_cell_magic
1193 1193 def time(self,line='', cell=None, local_ns=None):
1194 1194 """Time execution of a Python statement or expression.
1195 1195
1196 1196 The CPU and wall clock times are printed, and the value of the
1197 1197 expression (if any) is returned. Note that under Win32, system time
1198 1198 is always reported as 0, since it can not be measured.
1199 1199
1200 1200 This function can be used both as a line and cell magic:
1201 1201
1202 1202 - In line mode you can time a single-line statement (though multiple
1203 1203 ones can be chained with using semicolons).
1204 1204
1205 1205 - In cell mode, you can time the cell body (a directly
1206 1206 following statement raises an error).
1207 1207
1208 1208 This function provides very basic timing functionality. Use the timeit
1209 1209 magic for more control over the measurement.
1210 1210
1211 1211 .. versionchanged:: 7.3
1212 1212 User variables are no longer expanded,
1213 1213 the magic line is always left unmodified.
1214 1214
1215 1215 Examples
1216 1216 --------
1217 1217 ::
1218 1218
1219 1219 In [1]: %time 2**128
1220 1220 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1221 1221 Wall time: 0.00
1222 1222 Out[1]: 340282366920938463463374607431768211456L
1223 1223
1224 1224 In [2]: n = 1000000
1225 1225
1226 1226 In [3]: %time sum(range(n))
1227 1227 CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
1228 1228 Wall time: 1.37
1229 1229 Out[3]: 499999500000L
1230 1230
1231 1231 In [4]: %time print 'hello world'
1232 1232 hello world
1233 1233 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1234 1234 Wall time: 0.00
1235 1235
1236 1236 Note that the time needed by Python to compile the given expression
1237 1237 will be reported if it is more than 0.1s. In this example, the
1238 1238 actual exponentiation is done by Python at compilation time, so while
1239 1239 the expression can take a noticeable amount of time to compute, that
1240 1240 time is purely due to the compilation:
1241 1241
1242 1242 In [5]: %time 3**9999;
1243 1243 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1244 1244 Wall time: 0.00 s
1245 1245
1246 1246 In [6]: %time 3**999999;
1247 1247 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
1248 1248 Wall time: 0.00 s
1249 1249 Compiler : 0.78 s
1250 1250 """
1251 1251
1252 1252 # fail immediately if the given expression can't be compiled
1253 1253
1254 1254 if line and cell:
1255 1255 raise UsageError("Can't use statement directly after '%%time'!")
1256 1256
1257 1257 if cell:
1258 1258 expr = self.shell.transform_cell(cell)
1259 1259 else:
1260 1260 expr = self.shell.transform_cell(line)
1261 1261
1262 1262 # Minimum time above which parse time will be reported
1263 1263 tp_min = 0.1
1264 1264
1265 1265 t0 = clock()
1266 1266 expr_ast = self.shell.compile.ast_parse(expr)
1267 1267 tp = clock()-t0
1268 1268
1269 1269 # Apply AST transformations
1270 1270 expr_ast = self.shell.transform_ast(expr_ast)
1271 1271
1272 1272 # Minimum time above which compilation time will be reported
1273 1273 tc_min = 0.1
1274 1274
1275 1275 expr_val=None
1276 1276 if len(expr_ast.body)==1 and isinstance(expr_ast.body[0], ast.Expr):
1277 1277 mode = 'eval'
1278 1278 source = '<timed eval>'
1279 1279 expr_ast = ast.Expression(expr_ast.body[0].value)
1280 1280 else:
1281 1281 mode = 'exec'
1282 1282 source = '<timed exec>'
1283 1283 # multi-line %%time case
1284 if len(expr_ast.body) > 1 :
1285 expr_val=expr_ast.body[-1]
1286 code_val = self.shell.compile(ast.Expression(expr_val.value)
1287 , '<timed eval>'
1288 , 'eval')
1289 expr_ast=expr_ast.body[:-1]
1284 if len(expr_ast.body) > 1 and isinstance(expr_ast.body[-1], ast.Expr):
1285 expr_val= expr_ast.body[-1]
1286 expr_ast = expr_ast.body[:-1]
1290 1287 expr_ast = Module(expr_ast, [])
1288 expr_val = ast.Expression(expr_val.value)
1291 1289
1292 1290 t0 = clock()
1293 1291 code = self.shell.compile(expr_ast, source, mode)
1294 1292 tc = clock()-t0
1295 1293
1296 1294 # skew measurement as little as possible
1297 1295 glob = self.shell.user_ns
1298 1296 wtime = time.time
1299 1297 # time execution
1300 1298 wall_st = wtime()
1301 1299 if mode=='eval':
1302 1300 st = clock2()
1303 1301 try:
1304 1302 out = eval(code, glob, local_ns)
1305 1303 except:
1306 1304 self.shell.showtraceback()
1307 1305 return
1308 1306 end = clock2()
1309 1307 else:
1310 1308 st = clock2()
1311 1309 try:
1312 1310 exec(code, glob, local_ns)
1313 1311 out=None
1314 1312 # multi-line %%time case
1315 if expr_val and isinstance(expr_val, ast.Expr):
1316 out = eval(code_val, glob, local_ns)
1313 if expr_val is not None:
1314 code_2 = self.shell.compile(expr_val, source, 'eval')
1315 out = eval(code_2, glob, local_ns)
1317 1316 except:
1318 1317 self.shell.showtraceback()
1319 1318 return
1320 1319 end = clock2()
1321 1320
1322 1321 wall_end = wtime()
1323 1322 # Compute actual times and report
1324 1323 wall_time = wall_end-wall_st
1325 1324 cpu_user = end[0]-st[0]
1326 1325 cpu_sys = end[1]-st[1]
1327 1326 cpu_tot = cpu_user+cpu_sys
1328 1327 # On windows cpu_sys is always zero, so no new information to the next print
1329 1328 if sys.platform != 'win32':
1330 1329 print("CPU times: user %s, sys: %s, total: %s" % \
1331 1330 (_format_time(cpu_user),_format_time(cpu_sys),_format_time(cpu_tot)))
1332 1331 print("Wall time: %s" % _format_time(wall_time))
1333 1332 if tc > tc_min:
1334 1333 print("Compiler : %s" % _format_time(tc))
1335 1334 if tp > tp_min:
1336 1335 print("Parser : %s" % _format_time(tp))
1337 1336 return out
1338 1337
1339 1338 @skip_doctest
1340 1339 @line_magic
1341 1340 def macro(self, parameter_s=''):
1342 1341 """Define a macro for future re-execution. It accepts ranges of history,
1343 1342 filenames or string objects.
1344 1343
1345 1344 Usage:\\
1346 1345 %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
1347 1346
1348 1347 Options:
1349 1348
1350 1349 -r: use 'raw' input. By default, the 'processed' history is used,
1351 1350 so that magics are loaded in their transformed version to valid
1352 1351 Python. If this option is given, the raw input as typed at the
1353 1352 command line is used instead.
1354 1353
1355 1354 -q: quiet macro definition. By default, a tag line is printed
1356 1355 to indicate the macro has been created, and then the contents of
1357 1356 the macro are printed. If this option is given, then no printout
1358 1357 is produced once the macro is created.
1359 1358
1360 1359 This will define a global variable called `name` which is a string
1361 1360 made of joining the slices and lines you specify (n1,n2,... numbers
1362 1361 above) from your input history into a single string. This variable
1363 1362 acts like an automatic function which re-executes those lines as if
1364 1363 you had typed them. You just type 'name' at the prompt and the code
1365 1364 executes.
1366 1365
1367 1366 The syntax for indicating input ranges is described in %history.
1368 1367
1369 1368 Note: as a 'hidden' feature, you can also use traditional python slice
1370 1369 notation, where N:M means numbers N through M-1.
1371 1370
1372 1371 For example, if your history contains (print using %hist -n )::
1373 1372
1374 1373 44: x=1
1375 1374 45: y=3
1376 1375 46: z=x+y
1377 1376 47: print x
1378 1377 48: a=5
1379 1378 49: print 'x',x,'y',y
1380 1379
1381 1380 you can create a macro with lines 44 through 47 (included) and line 49
1382 1381 called my_macro with::
1383 1382
1384 1383 In [55]: %macro my_macro 44-47 49
1385 1384
1386 1385 Now, typing `my_macro` (without quotes) will re-execute all this code
1387 1386 in one pass.
1388 1387
1389 1388 You don't need to give the line-numbers in order, and any given line
1390 1389 number can appear multiple times. You can assemble macros with any
1391 1390 lines from your input history in any order.
1392 1391
1393 1392 The macro is a simple object which holds its value in an attribute,
1394 1393 but IPython's display system checks for macros and executes them as
1395 1394 code instead of printing them when you type their name.
1396 1395
1397 1396 You can view a macro's contents by explicitly printing it with::
1398 1397
1399 1398 print macro_name
1400 1399
1401 1400 """
1402 1401 opts,args = self.parse_options(parameter_s,'rq',mode='list')
1403 1402 if not args: # List existing macros
1404 1403 return sorted(k for k,v in self.shell.user_ns.items() if isinstance(v, Macro))
1405 1404 if len(args) == 1:
1406 1405 raise UsageError(
1407 1406 "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
1408 1407 name, codefrom = args[0], " ".join(args[1:])
1409 1408
1410 1409 #print 'rng',ranges # dbg
1411 1410 try:
1412 1411 lines = self.shell.find_user_code(codefrom, 'r' in opts)
1413 1412 except (ValueError, TypeError) as e:
1414 1413 print(e.args[0])
1415 1414 return
1416 1415 macro = Macro(lines)
1417 1416 self.shell.define_macro(name, macro)
1418 1417 if not ( 'q' in opts) :
1419 1418 print('Macro `%s` created. To execute, type its name (without quotes).' % name)
1420 1419 print('=== Macro contents: ===')
1421 1420 print(macro, end=' ')
1422 1421
1423 1422 @magic_arguments.magic_arguments()
1424 1423 @magic_arguments.argument('output', type=str, default='', nargs='?',
1425 1424 help="""The name of the variable in which to store output.
1426 1425 This is a utils.io.CapturedIO object with stdout/err attributes
1427 1426 for the text of the captured output.
1428 1427
1429 1428 CapturedOutput also has a show() method for displaying the output,
1430 1429 and __call__ as well, so you can use that to quickly display the
1431 1430 output.
1432 1431
1433 1432 If unspecified, captured output is discarded.
1434 1433 """
1435 1434 )
1436 1435 @magic_arguments.argument('--no-stderr', action="store_true",
1437 1436 help="""Don't capture stderr."""
1438 1437 )
1439 1438 @magic_arguments.argument('--no-stdout', action="store_true",
1440 1439 help="""Don't capture stdout."""
1441 1440 )
1442 1441 @magic_arguments.argument('--no-display', action="store_true",
1443 1442 help="""Don't capture IPython's rich display."""
1444 1443 )
1445 1444 @cell_magic
1446 1445 def capture(self, line, cell):
1447 1446 """run the cell, capturing stdout, stderr, and IPython's rich display() calls."""
1448 1447 args = magic_arguments.parse_argstring(self.capture, line)
1449 1448 out = not args.no_stdout
1450 1449 err = not args.no_stderr
1451 1450 disp = not args.no_display
1452 1451 with capture_output(out, err, disp) as io:
1453 1452 self.shell.run_cell(cell)
1454 1453 if args.output:
1455 1454 self.shell.user_ns[args.output] = io
1456 1455
1457 1456 def parse_breakpoint(text, current_file):
1458 1457 '''Returns (file, line) for file:line and (current_file, line) for line'''
1459 1458 colon = text.find(':')
1460 1459 if colon == -1:
1461 1460 return current_file, int(text)
1462 1461 else:
1463 1462 return text[:colon], int(text[colon+1:])
1464 1463
1465 1464 def _format_time(timespan, precision=3):
1466 1465 """Formats the timespan in a human readable form"""
1467 1466
1468 1467 if timespan >= 60.0:
1469 1468 # we have more than a minute, format that in a human readable form
1470 1469 # Idea from http://snipplr.com/view/5713/
1471 1470 parts = [("d", 60*60*24),("h", 60*60),("min", 60), ("s", 1)]
1472 1471 time = []
1473 1472 leftover = timespan
1474 1473 for suffix, length in parts:
1475 1474 value = int(leftover / length)
1476 1475 if value > 0:
1477 1476 leftover = leftover % length
1478 1477 time.append(u'%s%s' % (str(value), suffix))
1479 1478 if leftover < 1:
1480 1479 break
1481 1480 return " ".join(time)
1482 1481
1483 1482
1484 1483 # Unfortunately the unicode 'micro' symbol can cause problems in
1485 1484 # certain terminals.
1486 1485 # See bug: https://bugs.launchpad.net/ipython/+bug/348466
1487 1486 # Try to prevent crashes by being more secure than it needs to
1488 1487 # E.g. eclipse is able to print a µ, but has no sys.stdout.encoding set.
1489 1488 units = [u"s", u"ms",u'us',"ns"] # the save value
1490 1489 if hasattr(sys.stdout, 'encoding') and sys.stdout.encoding:
1491 1490 try:
1492 1491 u'\xb5'.encode(sys.stdout.encoding)
1493 1492 units = [u"s", u"ms",u'\xb5s',"ns"]
1494 1493 except:
1495 1494 pass
1496 1495 scaling = [1, 1e3, 1e6, 1e9]
1497 1496
1498 1497 if timespan > 0.0:
1499 1498 order = min(-int(math.floor(math.log10(timespan)) // 3), 3)
1500 1499 else:
1501 1500 order = 3
1502 1501 return u"%.*g %s" % (precision, timespan * scaling[order], units[order])
General Comments 0
You need to be logged in to leave comments. Login now