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