##// END OF EJS Templates
Verbose error message for syntax error occuring at runtime
Piotr Zielinski -
Show More
@@ -1,3210 +1,3215 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Main IPython class."""
3 3
4 4 #-----------------------------------------------------------------------------
5 5 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
6 6 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
7 7 # Copyright (C) 2008-2011 The IPython Development Team
8 8 #
9 9 # Distributed under the terms of the BSD License. The full license is in
10 10 # the file COPYING, distributed as part of this software.
11 11 #-----------------------------------------------------------------------------
12 12
13 13
14 14 import abc
15 15 import ast
16 16 import atexit
17 17 import builtins as builtin_mod
18 18 import functools
19 19 import os
20 20 import re
21 21 import runpy
22 22 import sys
23 23 import tempfile
24 24 import traceback
25 25 import types
26 26 import subprocess
27 27 import warnings
28 28 from io import open as io_open
29 29
30 30 from pickleshare import PickleShareDB
31 31
32 32 from traitlets.config.configurable import SingletonConfigurable
33 33 from IPython.core import oinspect
34 34 from IPython.core import magic
35 35 from IPython.core import page
36 36 from IPython.core import prefilter
37 37 from IPython.core import shadowns
38 38 from IPython.core import ultratb
39 39 from IPython.core.alias import Alias, AliasManager
40 40 from IPython.core.autocall import ExitAutocall
41 41 from IPython.core.builtin_trap import BuiltinTrap
42 42 from IPython.core.events import EventManager, available_events
43 43 from IPython.core.compilerop import CachingCompiler, check_linecache_ipython
44 44 from IPython.core.debugger import Pdb
45 45 from IPython.core.display_trap import DisplayTrap
46 46 from IPython.core.displayhook import DisplayHook
47 47 from IPython.core.displaypub import DisplayPublisher
48 48 from IPython.core.error import InputRejected, UsageError
49 49 from IPython.core.extensions import ExtensionManager
50 50 from IPython.core.formatters import DisplayFormatter
51 51 from IPython.core.history import HistoryManager
52 52 from IPython.core.inputsplitter import ESC_MAGIC, ESC_MAGIC2
53 53 from IPython.core.logger import Logger
54 54 from IPython.core.macro import Macro
55 55 from IPython.core.payload import PayloadManager
56 56 from IPython.core.prefilter import PrefilterManager
57 57 from IPython.core.profiledir import ProfileDir
58 58 from IPython.core.usage import default_banner
59 59 from IPython.testing.skipdoctest import skip_doctest
60 60 from IPython.utils import PyColorize
61 61 from IPython.utils import io
62 62 from IPython.utils import py3compat
63 63 from IPython.utils import openpy
64 64 from IPython.utils.decorators import undoc
65 65 from IPython.utils.io import ask_yes_no
66 66 from IPython.utils.ipstruct import Struct
67 67 from IPython.paths import get_ipython_dir
68 68 from IPython.utils.path import get_home_dir, get_py_filename, ensure_dir_exists
69 69 from IPython.utils.process import system, getoutput
70 70 from IPython.utils.strdispatch import StrDispatch
71 71 from IPython.utils.syspathcontext import prepended_to_syspath
72 72 from IPython.utils.text import format_screen, LSString, SList, DollarFormatter
73 73 from IPython.utils.tempdir import TemporaryDirectory
74 74 from traitlets import (
75 75 Integer, Bool, CaselessStrEnum, Enum, List, Dict, Unicode, Instance, Type,
76 76 observe, default,
77 77 )
78 78 from warnings import warn
79 79 from logging import error
80 80 import IPython.core.hooks
81 81
82 82 # NoOpContext is deprecated, but ipykernel imports it from here.
83 83 # See https://github.com/ipython/ipykernel/issues/157
84 84 from IPython.utils.contexts import NoOpContext
85 85
86 86 try:
87 87 import docrepr.sphinxify as sphx
88 88
89 89 def sphinxify(doc):
90 90 with TemporaryDirectory() as dirname:
91 91 return {
92 92 'text/html': sphx.sphinxify(doc, dirname),
93 93 'text/plain': doc
94 94 }
95 95 except ImportError:
96 96 sphinxify = None
97 97
98 98
99 99 class ProvisionalWarning(DeprecationWarning):
100 100 """
101 101 Warning class for unstable features
102 102 """
103 103 pass
104 104
105 105 #-----------------------------------------------------------------------------
106 106 # Globals
107 107 #-----------------------------------------------------------------------------
108 108
109 109 # compiled regexps for autoindent management
110 110 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
111 111
112 112 #-----------------------------------------------------------------------------
113 113 # Utilities
114 114 #-----------------------------------------------------------------------------
115 115
116 116 @undoc
117 117 def softspace(file, newvalue):
118 118 """Copied from code.py, to remove the dependency"""
119 119
120 120 oldvalue = 0
121 121 try:
122 122 oldvalue = file.softspace
123 123 except AttributeError:
124 124 pass
125 125 try:
126 126 file.softspace = newvalue
127 127 except (AttributeError, TypeError):
128 128 # "attribute-less object" or "read-only attributes"
129 129 pass
130 130 return oldvalue
131 131
132 132 @undoc
133 133 def no_op(*a, **kw):
134 134 pass
135 135
136 136
137 137 class SpaceInInput(Exception): pass
138 138
139 139
140 140 def get_default_colors():
141 141 "DEPRECATED"
142 142 warn('get_default_color is deprecated since IPython 5.0, and returns `Neutral` on all platforms.',
143 143 DeprecationWarning, stacklevel=2)
144 144 return 'Neutral'
145 145
146 146
147 147 class SeparateUnicode(Unicode):
148 148 r"""A Unicode subclass to validate separate_in, separate_out, etc.
149 149
150 150 This is a Unicode based trait that converts '0'->'' and ``'\\n'->'\n'``.
151 151 """
152 152
153 153 def validate(self, obj, value):
154 154 if value == '0': value = ''
155 155 value = value.replace('\\n','\n')
156 156 return super(SeparateUnicode, self).validate(obj, value)
157 157
158 158
159 159 @undoc
160 160 class DummyMod(object):
161 161 """A dummy module used for IPython's interactive module when
162 162 a namespace must be assigned to the module's __dict__."""
163 163 pass
164 164
165 165
166 166 class ExecutionResult(object):
167 167 """The result of a call to :meth:`InteractiveShell.run_cell`
168 168
169 169 Stores information about what took place.
170 170 """
171 171 execution_count = None
172 172 error_before_exec = None
173 173 error_in_exec = None
174 174 result = None
175 175
176 176 @property
177 177 def success(self):
178 178 return (self.error_before_exec is None) and (self.error_in_exec is None)
179 179
180 180 def raise_error(self):
181 181 """Reraises error if `success` is `False`, otherwise does nothing"""
182 182 if self.error_before_exec is not None:
183 183 raise self.error_before_exec
184 184 if self.error_in_exec is not None:
185 185 raise self.error_in_exec
186 186
187 187 def __repr__(self):
188 188 name = self.__class__.__qualname__
189 189 return '<%s object at %x, execution_count=%s error_before_exec=%s error_in_exec=%s result=%s>' %\
190 190 (name, id(self), self.execution_count, self.error_before_exec, self.error_in_exec, repr(self.result))
191 191
192 192
193 193 class InteractiveShell(SingletonConfigurable):
194 194 """An enhanced, interactive shell for Python."""
195 195
196 196 _instance = None
197 197
198 198 ast_transformers = List([], help=
199 199 """
200 200 A list of ast.NodeTransformer subclass instances, which will be applied
201 201 to user input before code is run.
202 202 """
203 203 ).tag(config=True)
204 204
205 205 autocall = Enum((0,1,2), default_value=0, help=
206 206 """
207 207 Make IPython automatically call any callable object even if you didn't
208 208 type explicit parentheses. For example, 'str 43' becomes 'str(43)'
209 209 automatically. The value can be '0' to disable the feature, '1' for
210 210 'smart' autocall, where it is not applied if there are no more
211 211 arguments on the line, and '2' for 'full' autocall, where all callable
212 212 objects are automatically called (even if no arguments are present).
213 213 """
214 214 ).tag(config=True)
215 215 # TODO: remove all autoindent logic and put into frontends.
216 216 # We can't do this yet because even runlines uses the autoindent.
217 217 autoindent = Bool(True, help=
218 218 """
219 219 Autoindent IPython code entered interactively.
220 220 """
221 221 ).tag(config=True)
222 222
223 223 automagic = Bool(True, help=
224 224 """
225 225 Enable magic commands to be called without the leading %.
226 226 """
227 227 ).tag(config=True)
228 228
229 229 banner1 = Unicode(default_banner,
230 230 help="""The part of the banner to be printed before the profile"""
231 231 ).tag(config=True)
232 232 banner2 = Unicode('',
233 233 help="""The part of the banner to be printed after the profile"""
234 234 ).tag(config=True)
235 235
236 236 cache_size = Integer(1000, help=
237 237 """
238 238 Set the size of the output cache. The default is 1000, you can
239 239 change it permanently in your config file. Setting it to 0 completely
240 240 disables the caching system, and the minimum value accepted is 20 (if
241 241 you provide a value less than 20, it is reset to 0 and a warning is
242 242 issued). This limit is defined because otherwise you'll spend more
243 243 time re-flushing a too small cache than working
244 244 """
245 245 ).tag(config=True)
246 246 color_info = Bool(True, help=
247 247 """
248 248 Use colors for displaying information about objects. Because this
249 249 information is passed through a pager (like 'less'), and some pagers
250 250 get confused with color codes, this capability can be turned off.
251 251 """
252 252 ).tag(config=True)
253 253 colors = CaselessStrEnum(('Neutral', 'NoColor','LightBG','Linux'),
254 254 default_value='Neutral',
255 255 help="Set the color scheme (NoColor, Neutral, Linux, or LightBG)."
256 256 ).tag(config=True)
257 257 debug = Bool(False).tag(config=True)
258 258 disable_failing_post_execute = Bool(False,
259 259 help="Don't call post-execute functions that have failed in the past."
260 260 ).tag(config=True)
261 261 display_formatter = Instance(DisplayFormatter, allow_none=True)
262 262 displayhook_class = Type(DisplayHook)
263 263 display_pub_class = Type(DisplayPublisher)
264 264
265 265 sphinxify_docstring = Bool(False, help=
266 266 """
267 267 Enables rich html representation of docstrings. (This requires the
268 268 docrepr module).
269 269 """).tag(config=True)
270 270
271 271 @observe("sphinxify_docstring")
272 272 def _sphinxify_docstring_changed(self, change):
273 273 if change['new']:
274 274 warn("`sphinxify_docstring` is provisional since IPython 5.0 and might change in future versions." , ProvisionalWarning)
275 275
276 276 enable_html_pager = Bool(False, help=
277 277 """
278 278 (Provisional API) enables html representation in mime bundles sent
279 279 to pagers.
280 280 """).tag(config=True)
281 281
282 282 @observe("enable_html_pager")
283 283 def _enable_html_pager_changed(self, change):
284 284 if change['new']:
285 285 warn("`enable_html_pager` is provisional since IPython 5.0 and might change in future versions.", ProvisionalWarning)
286 286
287 287 data_pub_class = None
288 288
289 289 exit_now = Bool(False)
290 290 exiter = Instance(ExitAutocall)
291 291 @default('exiter')
292 292 def _exiter_default(self):
293 293 return ExitAutocall(self)
294 294 # Monotonically increasing execution counter
295 295 execution_count = Integer(1)
296 296 filename = Unicode("<ipython console>")
297 297 ipython_dir= Unicode('').tag(config=True) # Set to get_ipython_dir() in __init__
298 298
299 299 # Input splitter, to transform input line by line and detect when a block
300 300 # is ready to be executed.
301 301 input_splitter = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
302 302 (), {'line_input_checker': True})
303 303
304 304 # This InputSplitter instance is used to transform completed cells before
305 305 # running them. It allows cell magics to contain blank lines.
306 306 input_transformer_manager = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
307 307 (), {'line_input_checker': False})
308 308
309 309 logstart = Bool(False, help=
310 310 """
311 311 Start logging to the default log file in overwrite mode.
312 312 Use `logappend` to specify a log file to **append** logs to.
313 313 """
314 314 ).tag(config=True)
315 315 logfile = Unicode('', help=
316 316 """
317 317 The name of the logfile to use.
318 318 """
319 319 ).tag(config=True)
320 320 logappend = Unicode('', help=
321 321 """
322 322 Start logging to the given file in append mode.
323 323 Use `logfile` to specify a log file to **overwrite** logs to.
324 324 """
325 325 ).tag(config=True)
326 326 object_info_string_level = Enum((0,1,2), default_value=0,
327 327 ).tag(config=True)
328 328 pdb = Bool(False, help=
329 329 """
330 330 Automatically call the pdb debugger after every exception.
331 331 """
332 332 ).tag(config=True)
333 333 display_page = Bool(False,
334 334 help="""If True, anything that would be passed to the pager
335 335 will be displayed as regular output instead."""
336 336 ).tag(config=True)
337 337
338 338 # deprecated prompt traits:
339 339
340 340 prompt_in1 = Unicode('In [\\#]: ',
341 341 help="Deprecated since IPython 4.0 and ignored since 5.0, set TerminalInteractiveShell.prompts object directly."
342 342 ).tag(config=True)
343 343 prompt_in2 = Unicode(' .\\D.: ',
344 344 help="Deprecated since IPython 4.0 and ignored since 5.0, set TerminalInteractiveShell.prompts object directly."
345 345 ).tag(config=True)
346 346 prompt_out = Unicode('Out[\\#]: ',
347 347 help="Deprecated since IPython 4.0 and ignored since 5.0, set TerminalInteractiveShell.prompts object directly."
348 348 ).tag(config=True)
349 349 prompts_pad_left = Bool(True,
350 350 help="Deprecated since IPython 4.0 and ignored since 5.0, set TerminalInteractiveShell.prompts object directly."
351 351 ).tag(config=True)
352 352
353 353 @observe('prompt_in1', 'prompt_in2', 'prompt_out', 'prompt_pad_left')
354 354 def _prompt_trait_changed(self, change):
355 355 name = change['name']
356 356 warn("InteractiveShell.{name} is deprecated since IPython 4.0"
357 357 " and ignored since 5.0, set TerminalInteractiveShell.prompts"
358 358 " object directly.".format(name=name))
359 359
360 360 # protect against weird cases where self.config may not exist:
361 361
362 362 show_rewritten_input = Bool(True,
363 363 help="Show rewritten input, e.g. for autocall."
364 364 ).tag(config=True)
365 365
366 366 quiet = Bool(False).tag(config=True)
367 367
368 368 history_length = Integer(10000,
369 369 help='Total length of command history'
370 370 ).tag(config=True)
371 371
372 372 history_load_length = Integer(1000, help=
373 373 """
374 374 The number of saved history entries to be loaded
375 375 into the history buffer at startup.
376 376 """
377 377 ).tag(config=True)
378 378
379 379 ast_node_interactivity = Enum(['all', 'last', 'last_expr', 'none'],
380 380 default_value='last_expr',
381 381 help="""
382 382 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
383 383 run interactively (displaying output from expressions)."""
384 384 ).tag(config=True)
385 385
386 386 # TODO: this part of prompt management should be moved to the frontends.
387 387 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
388 388 separate_in = SeparateUnicode('\n').tag(config=True)
389 389 separate_out = SeparateUnicode('').tag(config=True)
390 390 separate_out2 = SeparateUnicode('').tag(config=True)
391 391 wildcards_case_sensitive = Bool(True).tag(config=True)
392 392 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
393 393 default_value='Context',
394 394 help="Switch modes for the IPython exception handlers."
395 395 ).tag(config=True)
396 396
397 397 # Subcomponents of InteractiveShell
398 398 alias_manager = Instance('IPython.core.alias.AliasManager', allow_none=True)
399 399 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager', allow_none=True)
400 400 builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap', allow_none=True)
401 401 display_trap = Instance('IPython.core.display_trap.DisplayTrap', allow_none=True)
402 402 extension_manager = Instance('IPython.core.extensions.ExtensionManager', allow_none=True)
403 403 payload_manager = Instance('IPython.core.payload.PayloadManager', allow_none=True)
404 404 history_manager = Instance('IPython.core.history.HistoryAccessorBase', allow_none=True)
405 405 magics_manager = Instance('IPython.core.magic.MagicsManager', allow_none=True)
406 406
407 407 profile_dir = Instance('IPython.core.application.ProfileDir', allow_none=True)
408 408 @property
409 409 def profile(self):
410 410 if self.profile_dir is not None:
411 411 name = os.path.basename(self.profile_dir.location)
412 412 return name.replace('profile_','')
413 413
414 414
415 415 # Private interface
416 416 _post_execute = Dict()
417 417
418 418 # Tracks any GUI loop loaded for pylab
419 419 pylab_gui_select = None
420 420
421 421 last_execution_succeeded = Bool(True, help='Did last executed command succeeded')
422 422
423 423 def __init__(self, ipython_dir=None, profile_dir=None,
424 424 user_module=None, user_ns=None,
425 425 custom_exceptions=((), None), **kwargs):
426 426
427 427 # This is where traits with a config_key argument are updated
428 428 # from the values on config.
429 429 super(InteractiveShell, self).__init__(**kwargs)
430 430 if 'PromptManager' in self.config:
431 431 warn('As of IPython 5.0 `PromptManager` config will have no effect'
432 432 ' and has been replaced by TerminalInteractiveShell.prompts_class')
433 433 self.configurables = [self]
434 434
435 435 # These are relatively independent and stateless
436 436 self.init_ipython_dir(ipython_dir)
437 437 self.init_profile_dir(profile_dir)
438 438 self.init_instance_attrs()
439 439 self.init_environment()
440 440
441 441 # Check if we're in a virtualenv, and set up sys.path.
442 442 self.init_virtualenv()
443 443
444 444 # Create namespaces (user_ns, user_global_ns, etc.)
445 445 self.init_create_namespaces(user_module, user_ns)
446 446 # This has to be done after init_create_namespaces because it uses
447 447 # something in self.user_ns, but before init_sys_modules, which
448 448 # is the first thing to modify sys.
449 449 # TODO: When we override sys.stdout and sys.stderr before this class
450 450 # is created, we are saving the overridden ones here. Not sure if this
451 451 # is what we want to do.
452 452 self.save_sys_module_state()
453 453 self.init_sys_modules()
454 454
455 455 # While we're trying to have each part of the code directly access what
456 456 # it needs without keeping redundant references to objects, we have too
457 457 # much legacy code that expects ip.db to exist.
458 458 self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))
459 459
460 460 self.init_history()
461 461 self.init_encoding()
462 462 self.init_prefilter()
463 463
464 464 self.init_syntax_highlighting()
465 465 self.init_hooks()
466 466 self.init_events()
467 467 self.init_pushd_popd_magic()
468 468 self.init_user_ns()
469 469 self.init_logger()
470 470 self.init_builtins()
471 471
472 472 # The following was in post_config_initialization
473 473 self.init_inspector()
474 474 self.raw_input_original = input
475 475 self.init_completer()
476 476 # TODO: init_io() needs to happen before init_traceback handlers
477 477 # because the traceback handlers hardcode the stdout/stderr streams.
478 478 # This logic in in debugger.Pdb and should eventually be changed.
479 479 self.init_io()
480 480 self.init_traceback_handlers(custom_exceptions)
481 481 self.init_prompts()
482 482 self.init_display_formatter()
483 483 self.init_display_pub()
484 484 self.init_data_pub()
485 485 self.init_displayhook()
486 486 self.init_magics()
487 487 self.init_alias()
488 488 self.init_logstart()
489 489 self.init_pdb()
490 490 self.init_extension_manager()
491 491 self.init_payload()
492 492 self.init_deprecation_warnings()
493 493 self.hooks.late_startup_hook()
494 494 self.events.trigger('shell_initialized', self)
495 495 atexit.register(self.atexit_operations)
496 496
497 497 def get_ipython(self):
498 498 """Return the currently running IPython instance."""
499 499 return self
500 500
501 501 #-------------------------------------------------------------------------
502 502 # Trait changed handlers
503 503 #-------------------------------------------------------------------------
504 504 @observe('ipython_dir')
505 505 def _ipython_dir_changed(self, change):
506 506 ensure_dir_exists(change['new'])
507 507
508 508 def set_autoindent(self,value=None):
509 509 """Set the autoindent flag.
510 510
511 511 If called with no arguments, it acts as a toggle."""
512 512 if value is None:
513 513 self.autoindent = not self.autoindent
514 514 else:
515 515 self.autoindent = value
516 516
517 517 #-------------------------------------------------------------------------
518 518 # init_* methods called by __init__
519 519 #-------------------------------------------------------------------------
520 520
521 521 def init_ipython_dir(self, ipython_dir):
522 522 if ipython_dir is not None:
523 523 self.ipython_dir = ipython_dir
524 524 return
525 525
526 526 self.ipython_dir = get_ipython_dir()
527 527
528 528 def init_profile_dir(self, profile_dir):
529 529 if profile_dir is not None:
530 530 self.profile_dir = profile_dir
531 531 return
532 532 self.profile_dir =\
533 533 ProfileDir.create_profile_dir_by_name(self.ipython_dir, 'default')
534 534
535 535 def init_instance_attrs(self):
536 536 self.more = False
537 537
538 538 # command compiler
539 539 self.compile = CachingCompiler()
540 540
541 541 # Make an empty namespace, which extension writers can rely on both
542 542 # existing and NEVER being used by ipython itself. This gives them a
543 543 # convenient location for storing additional information and state
544 544 # their extensions may require, without fear of collisions with other
545 545 # ipython names that may develop later.
546 546 self.meta = Struct()
547 547
548 548 # Temporary files used for various purposes. Deleted at exit.
549 549 self.tempfiles = []
550 550 self.tempdirs = []
551 551
552 552 # keep track of where we started running (mainly for crash post-mortem)
553 553 # This is not being used anywhere currently.
554 554 self.starting_dir = os.getcwd()
555 555
556 556 # Indentation management
557 557 self.indent_current_nsp = 0
558 558
559 559 # Dict to track post-execution functions that have been registered
560 560 self._post_execute = {}
561 561
562 562 def init_environment(self):
563 563 """Any changes we need to make to the user's environment."""
564 564 pass
565 565
566 566 def init_encoding(self):
567 567 # Get system encoding at startup time. Certain terminals (like Emacs
568 568 # under Win32 have it set to None, and we need to have a known valid
569 569 # encoding to use in the raw_input() method
570 570 try:
571 571 self.stdin_encoding = sys.stdin.encoding or 'ascii'
572 572 except AttributeError:
573 573 self.stdin_encoding = 'ascii'
574 574
575 575
576 576 @observe('colors')
577 577 def init_syntax_highlighting(self, changes=None):
578 578 # Python source parser/formatter for syntax highlighting
579 579 pyformat = PyColorize.Parser(style=self.colors, parent=self).format
580 580 self.pycolorize = lambda src: pyformat(src,'str')
581 581
582 582 def refresh_style(self):
583 583 # No-op here, used in subclass
584 584 pass
585 585
586 586 def init_pushd_popd_magic(self):
587 587 # for pushd/popd management
588 588 self.home_dir = get_home_dir()
589 589
590 590 self.dir_stack = []
591 591
592 592 def init_logger(self):
593 593 self.logger = Logger(self.home_dir, logfname='ipython_log.py',
594 594 logmode='rotate')
595 595
596 596 def init_logstart(self):
597 597 """Initialize logging in case it was requested at the command line.
598 598 """
599 599 if self.logappend:
600 600 self.magic('logstart %s append' % self.logappend)
601 601 elif self.logfile:
602 602 self.magic('logstart %s' % self.logfile)
603 603 elif self.logstart:
604 604 self.magic('logstart')
605 605
606 606 def init_deprecation_warnings(self):
607 607 """
608 608 register default filter for deprecation warning.
609 609
610 610 This will allow deprecation warning of function used interactively to show
611 611 warning to users, and still hide deprecation warning from libraries import.
612 612 """
613 613 warnings.filterwarnings("default", category=DeprecationWarning, module=self.user_ns.get("__name__"))
614 614
615 615 def init_builtins(self):
616 616 # A single, static flag that we set to True. Its presence indicates
617 617 # that an IPython shell has been created, and we make no attempts at
618 618 # removing on exit or representing the existence of more than one
619 619 # IPython at a time.
620 620 builtin_mod.__dict__['__IPYTHON__'] = True
621 621
622 622 self.builtin_trap = BuiltinTrap(shell=self)
623 623
624 624 def init_inspector(self):
625 625 # Object inspector
626 626 self.inspector = oinspect.Inspector(oinspect.InspectColors,
627 627 PyColorize.ANSICodeColors,
628 628 self.colors,
629 629 self.object_info_string_level)
630 630
631 631 def init_io(self):
632 632 # This will just use sys.stdout and sys.stderr. If you want to
633 633 # override sys.stdout and sys.stderr themselves, you need to do that
634 634 # *before* instantiating this class, because io holds onto
635 635 # references to the underlying streams.
636 636 # io.std* are deprecated, but don't show our own deprecation warnings
637 637 # during initialization of the deprecated API.
638 638 with warnings.catch_warnings():
639 639 warnings.simplefilter('ignore', DeprecationWarning)
640 640 io.stdout = io.IOStream(sys.stdout)
641 641 io.stderr = io.IOStream(sys.stderr)
642 642
643 643 def init_prompts(self):
644 644 # Set system prompts, so that scripts can decide if they are running
645 645 # interactively.
646 646 sys.ps1 = 'In : '
647 647 sys.ps2 = '...: '
648 648 sys.ps3 = 'Out: '
649 649
650 650 def init_display_formatter(self):
651 651 self.display_formatter = DisplayFormatter(parent=self)
652 652 self.configurables.append(self.display_formatter)
653 653
654 654 def init_display_pub(self):
655 655 self.display_pub = self.display_pub_class(parent=self)
656 656 self.configurables.append(self.display_pub)
657 657
658 658 def init_data_pub(self):
659 659 if not self.data_pub_class:
660 660 self.data_pub = None
661 661 return
662 662 self.data_pub = self.data_pub_class(parent=self)
663 663 self.configurables.append(self.data_pub)
664 664
665 665 def init_displayhook(self):
666 666 # Initialize displayhook, set in/out prompts and printing system
667 667 self.displayhook = self.displayhook_class(
668 668 parent=self,
669 669 shell=self,
670 670 cache_size=self.cache_size,
671 671 )
672 672 self.configurables.append(self.displayhook)
673 673 # This is a context manager that installs/revmoes the displayhook at
674 674 # the appropriate time.
675 675 self.display_trap = DisplayTrap(hook=self.displayhook)
676 676
677 677 def init_virtualenv(self):
678 678 """Add a virtualenv to sys.path so the user can import modules from it.
679 679 This isn't perfect: it doesn't use the Python interpreter with which the
680 680 virtualenv was built, and it ignores the --no-site-packages option. A
681 681 warning will appear suggesting the user installs IPython in the
682 682 virtualenv, but for many cases, it probably works well enough.
683 683
684 684 Adapted from code snippets online.
685 685
686 686 http://blog.ufsoft.org/2009/1/29/ipython-and-virtualenv
687 687 """
688 688 if 'VIRTUAL_ENV' not in os.environ:
689 689 # Not in a virtualenv
690 690 return
691 691
692 692 # venv detection:
693 693 # stdlib venv may symlink sys.executable, so we can't use realpath.
694 694 # but others can symlink *to* the venv Python, so we can't just use sys.executable.
695 695 # So we just check every item in the symlink tree (generally <= 3)
696 696 p = os.path.normcase(sys.executable)
697 697 paths = [p]
698 698 while os.path.islink(p):
699 699 p = os.path.normcase(os.path.join(os.path.dirname(p), os.readlink(p)))
700 700 paths.append(p)
701 701 p_venv = os.path.normcase(os.environ['VIRTUAL_ENV'])
702 702
703 703 # In Cygwin paths like "c:\..." and '\cygdrive\c\...' are possible
704 704 if p_venv.startswith('\\cygdrive'):
705 705 p_venv = p_venv[11:]
706 706 elif p_venv[1] == ':':
707 707 p_venv = p_venv[2:]
708 708
709 709 if any(p_venv in p for p in paths):
710 710 # Running properly in the virtualenv, don't need to do anything
711 711 return
712 712
713 713 warn("Attempting to work in a virtualenv. If you encounter problems, please "
714 714 "install IPython inside the virtualenv.")
715 715 if sys.platform == "win32":
716 716 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'Lib', 'site-packages')
717 717 else:
718 718 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'lib',
719 719 'python%d.%d' % sys.version_info[:2], 'site-packages')
720 720
721 721 import site
722 722 sys.path.insert(0, virtual_env)
723 723 site.addsitedir(virtual_env)
724 724
725 725 #-------------------------------------------------------------------------
726 726 # Things related to injections into the sys module
727 727 #-------------------------------------------------------------------------
728 728
729 729 def save_sys_module_state(self):
730 730 """Save the state of hooks in the sys module.
731 731
732 732 This has to be called after self.user_module is created.
733 733 """
734 734 self._orig_sys_module_state = {'stdin': sys.stdin,
735 735 'stdout': sys.stdout,
736 736 'stderr': sys.stderr,
737 737 'excepthook': sys.excepthook}
738 738 self._orig_sys_modules_main_name = self.user_module.__name__
739 739 self._orig_sys_modules_main_mod = sys.modules.get(self.user_module.__name__)
740 740
741 741 def restore_sys_module_state(self):
742 742 """Restore the state of the sys module."""
743 743 try:
744 744 for k, v in self._orig_sys_module_state.items():
745 745 setattr(sys, k, v)
746 746 except AttributeError:
747 747 pass
748 748 # Reset what what done in self.init_sys_modules
749 749 if self._orig_sys_modules_main_mod is not None:
750 750 sys.modules[self._orig_sys_modules_main_name] = self._orig_sys_modules_main_mod
751 751
752 752 #-------------------------------------------------------------------------
753 753 # Things related to the banner
754 754 #-------------------------------------------------------------------------
755 755
756 756 @property
757 757 def banner(self):
758 758 banner = self.banner1
759 759 if self.profile and self.profile != 'default':
760 760 banner += '\nIPython profile: %s\n' % self.profile
761 761 if self.banner2:
762 762 banner += '\n' + self.banner2
763 763 return banner
764 764
765 765 def show_banner(self, banner=None):
766 766 if banner is None:
767 767 banner = self.banner
768 768 sys.stdout.write(banner)
769 769
770 770 #-------------------------------------------------------------------------
771 771 # Things related to hooks
772 772 #-------------------------------------------------------------------------
773 773
774 774 def init_hooks(self):
775 775 # hooks holds pointers used for user-side customizations
776 776 self.hooks = Struct()
777 777
778 778 self.strdispatchers = {}
779 779
780 780 # Set all default hooks, defined in the IPython.hooks module.
781 781 hooks = IPython.core.hooks
782 782 for hook_name in hooks.__all__:
783 783 # default hooks have priority 100, i.e. low; user hooks should have
784 784 # 0-100 priority
785 785 self.set_hook(hook_name,getattr(hooks,hook_name), 100, _warn_deprecated=False)
786 786
787 787 if self.display_page:
788 788 self.set_hook('show_in_pager', page.as_hook(page.display_page), 90)
789 789
790 790 def set_hook(self,name,hook, priority=50, str_key=None, re_key=None,
791 791 _warn_deprecated=True):
792 792 """set_hook(name,hook) -> sets an internal IPython hook.
793 793
794 794 IPython exposes some of its internal API as user-modifiable hooks. By
795 795 adding your function to one of these hooks, you can modify IPython's
796 796 behavior to call at runtime your own routines."""
797 797
798 798 # At some point in the future, this should validate the hook before it
799 799 # accepts it. Probably at least check that the hook takes the number
800 800 # of args it's supposed to.
801 801
802 802 f = types.MethodType(hook,self)
803 803
804 804 # check if the hook is for strdispatcher first
805 805 if str_key is not None:
806 806 sdp = self.strdispatchers.get(name, StrDispatch())
807 807 sdp.add_s(str_key, f, priority )
808 808 self.strdispatchers[name] = sdp
809 809 return
810 810 if re_key is not None:
811 811 sdp = self.strdispatchers.get(name, StrDispatch())
812 812 sdp.add_re(re.compile(re_key), f, priority )
813 813 self.strdispatchers[name] = sdp
814 814 return
815 815
816 816 dp = getattr(self.hooks, name, None)
817 817 if name not in IPython.core.hooks.__all__:
818 818 print("Warning! Hook '%s' is not one of %s" % \
819 819 (name, IPython.core.hooks.__all__ ))
820 820
821 821 if _warn_deprecated and (name in IPython.core.hooks.deprecated):
822 822 alternative = IPython.core.hooks.deprecated[name]
823 823 warn("Hook {} is deprecated. Use {} instead.".format(name, alternative), stacklevel=2)
824 824
825 825 if not dp:
826 826 dp = IPython.core.hooks.CommandChainDispatcher()
827 827
828 828 try:
829 829 dp.add(f,priority)
830 830 except AttributeError:
831 831 # it was not commandchain, plain old func - replace
832 832 dp = f
833 833
834 834 setattr(self.hooks,name, dp)
835 835
836 836 #-------------------------------------------------------------------------
837 837 # Things related to events
838 838 #-------------------------------------------------------------------------
839 839
840 840 def init_events(self):
841 841 self.events = EventManager(self, available_events)
842 842
843 843 self.events.register("pre_execute", self._clear_warning_registry)
844 844
845 845 def register_post_execute(self, func):
846 846 """DEPRECATED: Use ip.events.register('post_run_cell', func)
847 847
848 848 Register a function for calling after code execution.
849 849 """
850 850 warn("ip.register_post_execute is deprecated, use "
851 851 "ip.events.register('post_run_cell', func) instead.", stacklevel=2)
852 852 self.events.register('post_run_cell', func)
853 853
854 854 def _clear_warning_registry(self):
855 855 # clear the warning registry, so that different code blocks with
856 856 # overlapping line number ranges don't cause spurious suppression of
857 857 # warnings (see gh-6611 for details)
858 858 if "__warningregistry__" in self.user_global_ns:
859 859 del self.user_global_ns["__warningregistry__"]
860 860
861 861 #-------------------------------------------------------------------------
862 862 # Things related to the "main" module
863 863 #-------------------------------------------------------------------------
864 864
865 865 def new_main_mod(self, filename, modname):
866 866 """Return a new 'main' module object for user code execution.
867 867
868 868 ``filename`` should be the path of the script which will be run in the
869 869 module. Requests with the same filename will get the same module, with
870 870 its namespace cleared.
871 871
872 872 ``modname`` should be the module name - normally either '__main__' or
873 873 the basename of the file without the extension.
874 874
875 875 When scripts are executed via %run, we must keep a reference to their
876 876 __main__ module around so that Python doesn't
877 877 clear it, rendering references to module globals useless.
878 878
879 879 This method keeps said reference in a private dict, keyed by the
880 880 absolute path of the script. This way, for multiple executions of the
881 881 same script we only keep one copy of the namespace (the last one),
882 882 thus preventing memory leaks from old references while allowing the
883 883 objects from the last execution to be accessible.
884 884 """
885 885 filename = os.path.abspath(filename)
886 886 try:
887 887 main_mod = self._main_mod_cache[filename]
888 888 except KeyError:
889 889 main_mod = self._main_mod_cache[filename] = types.ModuleType(
890 890 py3compat.cast_bytes_py2(modname),
891 891 doc="Module created for script run in IPython")
892 892 else:
893 893 main_mod.__dict__.clear()
894 894 main_mod.__name__ = modname
895 895
896 896 main_mod.__file__ = filename
897 897 # It seems pydoc (and perhaps others) needs any module instance to
898 898 # implement a __nonzero__ method
899 899 main_mod.__nonzero__ = lambda : True
900 900
901 901 return main_mod
902 902
903 903 def clear_main_mod_cache(self):
904 904 """Clear the cache of main modules.
905 905
906 906 Mainly for use by utilities like %reset.
907 907
908 908 Examples
909 909 --------
910 910
911 911 In [15]: import IPython
912 912
913 913 In [16]: m = _ip.new_main_mod(IPython.__file__, 'IPython')
914 914
915 915 In [17]: len(_ip._main_mod_cache) > 0
916 916 Out[17]: True
917 917
918 918 In [18]: _ip.clear_main_mod_cache()
919 919
920 920 In [19]: len(_ip._main_mod_cache) == 0
921 921 Out[19]: True
922 922 """
923 923 self._main_mod_cache.clear()
924 924
925 925 #-------------------------------------------------------------------------
926 926 # Things related to debugging
927 927 #-------------------------------------------------------------------------
928 928
929 929 def init_pdb(self):
930 930 # Set calling of pdb on exceptions
931 931 # self.call_pdb is a property
932 932 self.call_pdb = self.pdb
933 933
934 934 def _get_call_pdb(self):
935 935 return self._call_pdb
936 936
937 937 def _set_call_pdb(self,val):
938 938
939 939 if val not in (0,1,False,True):
940 940 raise ValueError('new call_pdb value must be boolean')
941 941
942 942 # store value in instance
943 943 self._call_pdb = val
944 944
945 945 # notify the actual exception handlers
946 946 self.InteractiveTB.call_pdb = val
947 947
948 948 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
949 949 'Control auto-activation of pdb at exceptions')
950 950
951 951 def debugger(self,force=False):
952 952 """Call the pdb debugger.
953 953
954 954 Keywords:
955 955
956 956 - force(False): by default, this routine checks the instance call_pdb
957 957 flag and does not actually invoke the debugger if the flag is false.
958 958 The 'force' option forces the debugger to activate even if the flag
959 959 is false.
960 960 """
961 961
962 962 if not (force or self.call_pdb):
963 963 return
964 964
965 965 if not hasattr(sys,'last_traceback'):
966 966 error('No traceback has been produced, nothing to debug.')
967 967 return
968 968
969 969 self.InteractiveTB.debugger(force=True)
970 970
971 971 #-------------------------------------------------------------------------
972 972 # Things related to IPython's various namespaces
973 973 #-------------------------------------------------------------------------
974 974 default_user_namespaces = True
975 975
976 976 def init_create_namespaces(self, user_module=None, user_ns=None):
977 977 # Create the namespace where the user will operate. user_ns is
978 978 # normally the only one used, and it is passed to the exec calls as
979 979 # the locals argument. But we do carry a user_global_ns namespace
980 980 # given as the exec 'globals' argument, This is useful in embedding
981 981 # situations where the ipython shell opens in a context where the
982 982 # distinction between locals and globals is meaningful. For
983 983 # non-embedded contexts, it is just the same object as the user_ns dict.
984 984
985 985 # FIXME. For some strange reason, __builtins__ is showing up at user
986 986 # level as a dict instead of a module. This is a manual fix, but I
987 987 # should really track down where the problem is coming from. Alex
988 988 # Schmolck reported this problem first.
989 989
990 990 # A useful post by Alex Martelli on this topic:
991 991 # Re: inconsistent value from __builtins__
992 992 # Von: Alex Martelli <aleaxit@yahoo.com>
993 993 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
994 994 # Gruppen: comp.lang.python
995 995
996 996 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
997 997 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
998 998 # > <type 'dict'>
999 999 # > >>> print type(__builtins__)
1000 1000 # > <type 'module'>
1001 1001 # > Is this difference in return value intentional?
1002 1002
1003 1003 # Well, it's documented that '__builtins__' can be either a dictionary
1004 1004 # or a module, and it's been that way for a long time. Whether it's
1005 1005 # intentional (or sensible), I don't know. In any case, the idea is
1006 1006 # that if you need to access the built-in namespace directly, you
1007 1007 # should start with "import __builtin__" (note, no 's') which will
1008 1008 # definitely give you a module. Yeah, it's somewhat confusing:-(.
1009 1009
1010 1010 # These routines return a properly built module and dict as needed by
1011 1011 # the rest of the code, and can also be used by extension writers to
1012 1012 # generate properly initialized namespaces.
1013 1013 if (user_ns is not None) or (user_module is not None):
1014 1014 self.default_user_namespaces = False
1015 1015 self.user_module, self.user_ns = self.prepare_user_module(user_module, user_ns)
1016 1016
1017 1017 # A record of hidden variables we have added to the user namespace, so
1018 1018 # we can list later only variables defined in actual interactive use.
1019 1019 self.user_ns_hidden = {}
1020 1020
1021 1021 # Now that FakeModule produces a real module, we've run into a nasty
1022 1022 # problem: after script execution (via %run), the module where the user
1023 1023 # code ran is deleted. Now that this object is a true module (needed
1024 1024 # so doctest and other tools work correctly), the Python module
1025 1025 # teardown mechanism runs over it, and sets to None every variable
1026 1026 # present in that module. Top-level references to objects from the
1027 1027 # script survive, because the user_ns is updated with them. However,
1028 1028 # calling functions defined in the script that use other things from
1029 1029 # the script will fail, because the function's closure had references
1030 1030 # to the original objects, which are now all None. So we must protect
1031 1031 # these modules from deletion by keeping a cache.
1032 1032 #
1033 1033 # To avoid keeping stale modules around (we only need the one from the
1034 1034 # last run), we use a dict keyed with the full path to the script, so
1035 1035 # only the last version of the module is held in the cache. Note,
1036 1036 # however, that we must cache the module *namespace contents* (their
1037 1037 # __dict__). Because if we try to cache the actual modules, old ones
1038 1038 # (uncached) could be destroyed while still holding references (such as
1039 1039 # those held by GUI objects that tend to be long-lived)>
1040 1040 #
1041 1041 # The %reset command will flush this cache. See the cache_main_mod()
1042 1042 # and clear_main_mod_cache() methods for details on use.
1043 1043
1044 1044 # This is the cache used for 'main' namespaces
1045 1045 self._main_mod_cache = {}
1046 1046
1047 1047 # A table holding all the namespaces IPython deals with, so that
1048 1048 # introspection facilities can search easily.
1049 1049 self.ns_table = {'user_global':self.user_module.__dict__,
1050 1050 'user_local':self.user_ns,
1051 1051 'builtin':builtin_mod.__dict__
1052 1052 }
1053 1053
1054 1054 @property
1055 1055 def user_global_ns(self):
1056 1056 return self.user_module.__dict__
1057 1057
1058 1058 def prepare_user_module(self, user_module=None, user_ns=None):
1059 1059 """Prepare the module and namespace in which user code will be run.
1060 1060
1061 1061 When IPython is started normally, both parameters are None: a new module
1062 1062 is created automatically, and its __dict__ used as the namespace.
1063 1063
1064 1064 If only user_module is provided, its __dict__ is used as the namespace.
1065 1065 If only user_ns is provided, a dummy module is created, and user_ns
1066 1066 becomes the global namespace. If both are provided (as they may be
1067 1067 when embedding), user_ns is the local namespace, and user_module
1068 1068 provides the global namespace.
1069 1069
1070 1070 Parameters
1071 1071 ----------
1072 1072 user_module : module, optional
1073 1073 The current user module in which IPython is being run. If None,
1074 1074 a clean module will be created.
1075 1075 user_ns : dict, optional
1076 1076 A namespace in which to run interactive commands.
1077 1077
1078 1078 Returns
1079 1079 -------
1080 1080 A tuple of user_module and user_ns, each properly initialised.
1081 1081 """
1082 1082 if user_module is None and user_ns is not None:
1083 1083 user_ns.setdefault("__name__", "__main__")
1084 1084 user_module = DummyMod()
1085 1085 user_module.__dict__ = user_ns
1086 1086
1087 1087 if user_module is None:
1088 1088 user_module = types.ModuleType("__main__",
1089 1089 doc="Automatically created module for IPython interactive environment")
1090 1090
1091 1091 # We must ensure that __builtin__ (without the final 's') is always
1092 1092 # available and pointing to the __builtin__ *module*. For more details:
1093 1093 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1094 1094 user_module.__dict__.setdefault('__builtin__', builtin_mod)
1095 1095 user_module.__dict__.setdefault('__builtins__', builtin_mod)
1096 1096
1097 1097 if user_ns is None:
1098 1098 user_ns = user_module.__dict__
1099 1099
1100 1100 return user_module, user_ns
1101 1101
1102 1102 def init_sys_modules(self):
1103 1103 # We need to insert into sys.modules something that looks like a
1104 1104 # module but which accesses the IPython namespace, for shelve and
1105 1105 # pickle to work interactively. Normally they rely on getting
1106 1106 # everything out of __main__, but for embedding purposes each IPython
1107 1107 # instance has its own private namespace, so we can't go shoving
1108 1108 # everything into __main__.
1109 1109
1110 1110 # note, however, that we should only do this for non-embedded
1111 1111 # ipythons, which really mimic the __main__.__dict__ with their own
1112 1112 # namespace. Embedded instances, on the other hand, should not do
1113 1113 # this because they need to manage the user local/global namespaces
1114 1114 # only, but they live within a 'normal' __main__ (meaning, they
1115 1115 # shouldn't overtake the execution environment of the script they're
1116 1116 # embedded in).
1117 1117
1118 1118 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
1119 1119 main_name = self.user_module.__name__
1120 1120 sys.modules[main_name] = self.user_module
1121 1121
1122 1122 def init_user_ns(self):
1123 1123 """Initialize all user-visible namespaces to their minimum defaults.
1124 1124
1125 1125 Certain history lists are also initialized here, as they effectively
1126 1126 act as user namespaces.
1127 1127
1128 1128 Notes
1129 1129 -----
1130 1130 All data structures here are only filled in, they are NOT reset by this
1131 1131 method. If they were not empty before, data will simply be added to
1132 1132 therm.
1133 1133 """
1134 1134 # This function works in two parts: first we put a few things in
1135 1135 # user_ns, and we sync that contents into user_ns_hidden so that these
1136 1136 # initial variables aren't shown by %who. After the sync, we add the
1137 1137 # rest of what we *do* want the user to see with %who even on a new
1138 1138 # session (probably nothing, so they really only see their own stuff)
1139 1139
1140 1140 # The user dict must *always* have a __builtin__ reference to the
1141 1141 # Python standard __builtin__ namespace, which must be imported.
1142 1142 # This is so that certain operations in prompt evaluation can be
1143 1143 # reliably executed with builtins. Note that we can NOT use
1144 1144 # __builtins__ (note the 's'), because that can either be a dict or a
1145 1145 # module, and can even mutate at runtime, depending on the context
1146 1146 # (Python makes no guarantees on it). In contrast, __builtin__ is
1147 1147 # always a module object, though it must be explicitly imported.
1148 1148
1149 1149 # For more details:
1150 1150 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1151 1151 ns = {}
1152 1152
1153 1153 # make global variables for user access to the histories
1154 1154 ns['_ih'] = self.history_manager.input_hist_parsed
1155 1155 ns['_oh'] = self.history_manager.output_hist
1156 1156 ns['_dh'] = self.history_manager.dir_hist
1157 1157
1158 1158 ns['_sh'] = shadowns
1159 1159
1160 1160 # user aliases to input and output histories. These shouldn't show up
1161 1161 # in %who, as they can have very large reprs.
1162 1162 ns['In'] = self.history_manager.input_hist_parsed
1163 1163 ns['Out'] = self.history_manager.output_hist
1164 1164
1165 1165 # Store myself as the public api!!!
1166 1166 ns['get_ipython'] = self.get_ipython
1167 1167
1168 1168 ns['exit'] = self.exiter
1169 1169 ns['quit'] = self.exiter
1170 1170
1171 1171 # Sync what we've added so far to user_ns_hidden so these aren't seen
1172 1172 # by %who
1173 1173 self.user_ns_hidden.update(ns)
1174 1174
1175 1175 # Anything put into ns now would show up in %who. Think twice before
1176 1176 # putting anything here, as we really want %who to show the user their
1177 1177 # stuff, not our variables.
1178 1178
1179 1179 # Finally, update the real user's namespace
1180 1180 self.user_ns.update(ns)
1181 1181
1182 1182 @property
1183 1183 def all_ns_refs(self):
1184 1184 """Get a list of references to all the namespace dictionaries in which
1185 1185 IPython might store a user-created object.
1186 1186
1187 1187 Note that this does not include the displayhook, which also caches
1188 1188 objects from the output."""
1189 1189 return [self.user_ns, self.user_global_ns, self.user_ns_hidden] + \
1190 1190 [m.__dict__ for m in self._main_mod_cache.values()]
1191 1191
1192 1192 def reset(self, new_session=True):
1193 1193 """Clear all internal namespaces, and attempt to release references to
1194 1194 user objects.
1195 1195
1196 1196 If new_session is True, a new history session will be opened.
1197 1197 """
1198 1198 # Clear histories
1199 1199 self.history_manager.reset(new_session)
1200 1200 # Reset counter used to index all histories
1201 1201 if new_session:
1202 1202 self.execution_count = 1
1203 1203
1204 1204 # Flush cached output items
1205 1205 if self.displayhook.do_full_cache:
1206 1206 self.displayhook.flush()
1207 1207
1208 1208 # The main execution namespaces must be cleared very carefully,
1209 1209 # skipping the deletion of the builtin-related keys, because doing so
1210 1210 # would cause errors in many object's __del__ methods.
1211 1211 if self.user_ns is not self.user_global_ns:
1212 1212 self.user_ns.clear()
1213 1213 ns = self.user_global_ns
1214 1214 drop_keys = set(ns.keys())
1215 1215 drop_keys.discard('__builtin__')
1216 1216 drop_keys.discard('__builtins__')
1217 1217 drop_keys.discard('__name__')
1218 1218 for k in drop_keys:
1219 1219 del ns[k]
1220 1220
1221 1221 self.user_ns_hidden.clear()
1222 1222
1223 1223 # Restore the user namespaces to minimal usability
1224 1224 self.init_user_ns()
1225 1225
1226 1226 # Restore the default and user aliases
1227 1227 self.alias_manager.clear_aliases()
1228 1228 self.alias_manager.init_aliases()
1229 1229
1230 1230 # Flush the private list of module references kept for script
1231 1231 # execution protection
1232 1232 self.clear_main_mod_cache()
1233 1233
1234 1234 def del_var(self, varname, by_name=False):
1235 1235 """Delete a variable from the various namespaces, so that, as
1236 1236 far as possible, we're not keeping any hidden references to it.
1237 1237
1238 1238 Parameters
1239 1239 ----------
1240 1240 varname : str
1241 1241 The name of the variable to delete.
1242 1242 by_name : bool
1243 1243 If True, delete variables with the given name in each
1244 1244 namespace. If False (default), find the variable in the user
1245 1245 namespace, and delete references to it.
1246 1246 """
1247 1247 if varname in ('__builtin__', '__builtins__'):
1248 1248 raise ValueError("Refusing to delete %s" % varname)
1249 1249
1250 1250 ns_refs = self.all_ns_refs
1251 1251
1252 1252 if by_name: # Delete by name
1253 1253 for ns in ns_refs:
1254 1254 try:
1255 1255 del ns[varname]
1256 1256 except KeyError:
1257 1257 pass
1258 1258 else: # Delete by object
1259 1259 try:
1260 1260 obj = self.user_ns[varname]
1261 1261 except KeyError:
1262 1262 raise NameError("name '%s' is not defined" % varname)
1263 1263 # Also check in output history
1264 1264 ns_refs.append(self.history_manager.output_hist)
1265 1265 for ns in ns_refs:
1266 1266 to_delete = [n for n, o in ns.items() if o is obj]
1267 1267 for name in to_delete:
1268 1268 del ns[name]
1269 1269
1270 1270 # displayhook keeps extra references, but not in a dictionary
1271 1271 for name in ('_', '__', '___'):
1272 1272 if getattr(self.displayhook, name) is obj:
1273 1273 setattr(self.displayhook, name, None)
1274 1274
1275 1275 def reset_selective(self, regex=None):
1276 1276 """Clear selective variables from internal namespaces based on a
1277 1277 specified regular expression.
1278 1278
1279 1279 Parameters
1280 1280 ----------
1281 1281 regex : string or compiled pattern, optional
1282 1282 A regular expression pattern that will be used in searching
1283 1283 variable names in the users namespaces.
1284 1284 """
1285 1285 if regex is not None:
1286 1286 try:
1287 1287 m = re.compile(regex)
1288 1288 except TypeError:
1289 1289 raise TypeError('regex must be a string or compiled pattern')
1290 1290 # Search for keys in each namespace that match the given regex
1291 1291 # If a match is found, delete the key/value pair.
1292 1292 for ns in self.all_ns_refs:
1293 1293 for var in ns:
1294 1294 if m.search(var):
1295 1295 del ns[var]
1296 1296
1297 1297 def push(self, variables, interactive=True):
1298 1298 """Inject a group of variables into the IPython user namespace.
1299 1299
1300 1300 Parameters
1301 1301 ----------
1302 1302 variables : dict, str or list/tuple of str
1303 1303 The variables to inject into the user's namespace. If a dict, a
1304 1304 simple update is done. If a str, the string is assumed to have
1305 1305 variable names separated by spaces. A list/tuple of str can also
1306 1306 be used to give the variable names. If just the variable names are
1307 1307 give (list/tuple/str) then the variable values looked up in the
1308 1308 callers frame.
1309 1309 interactive : bool
1310 1310 If True (default), the variables will be listed with the ``who``
1311 1311 magic.
1312 1312 """
1313 1313 vdict = None
1314 1314
1315 1315 # We need a dict of name/value pairs to do namespace updates.
1316 1316 if isinstance(variables, dict):
1317 1317 vdict = variables
1318 1318 elif isinstance(variables, (str, list, tuple)):
1319 1319 if isinstance(variables, str):
1320 1320 vlist = variables.split()
1321 1321 else:
1322 1322 vlist = variables
1323 1323 vdict = {}
1324 1324 cf = sys._getframe(1)
1325 1325 for name in vlist:
1326 1326 try:
1327 1327 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1328 1328 except:
1329 1329 print('Could not get variable %s from %s' %
1330 1330 (name,cf.f_code.co_name))
1331 1331 else:
1332 1332 raise ValueError('variables must be a dict/str/list/tuple')
1333 1333
1334 1334 # Propagate variables to user namespace
1335 1335 self.user_ns.update(vdict)
1336 1336
1337 1337 # And configure interactive visibility
1338 1338 user_ns_hidden = self.user_ns_hidden
1339 1339 if interactive:
1340 1340 for name in vdict:
1341 1341 user_ns_hidden.pop(name, None)
1342 1342 else:
1343 1343 user_ns_hidden.update(vdict)
1344 1344
1345 1345 def drop_by_id(self, variables):
1346 1346 """Remove a dict of variables from the user namespace, if they are the
1347 1347 same as the values in the dictionary.
1348 1348
1349 1349 This is intended for use by extensions: variables that they've added can
1350 1350 be taken back out if they are unloaded, without removing any that the
1351 1351 user has overwritten.
1352 1352
1353 1353 Parameters
1354 1354 ----------
1355 1355 variables : dict
1356 1356 A dictionary mapping object names (as strings) to the objects.
1357 1357 """
1358 1358 for name, obj in variables.items():
1359 1359 if name in self.user_ns and self.user_ns[name] is obj:
1360 1360 del self.user_ns[name]
1361 1361 self.user_ns_hidden.pop(name, None)
1362 1362
1363 1363 #-------------------------------------------------------------------------
1364 1364 # Things related to object introspection
1365 1365 #-------------------------------------------------------------------------
1366 1366
1367 1367 def _ofind(self, oname, namespaces=None):
1368 1368 """Find an object in the available namespaces.
1369 1369
1370 1370 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
1371 1371
1372 1372 Has special code to detect magic functions.
1373 1373 """
1374 1374 oname = oname.strip()
1375 1375 if not oname.startswith(ESC_MAGIC) and \
1376 1376 not oname.startswith(ESC_MAGIC2) and \
1377 1377 not all(a.isidentifier() for a in oname.split(".")):
1378 1378 return {'found': False}
1379 1379
1380 1380 if namespaces is None:
1381 1381 # Namespaces to search in:
1382 1382 # Put them in a list. The order is important so that we
1383 1383 # find things in the same order that Python finds them.
1384 1384 namespaces = [ ('Interactive', self.user_ns),
1385 1385 ('Interactive (global)', self.user_global_ns),
1386 1386 ('Python builtin', builtin_mod.__dict__),
1387 1387 ]
1388 1388
1389 1389 ismagic = False
1390 1390 isalias = False
1391 1391 found = False
1392 1392 ospace = None
1393 1393 parent = None
1394 1394 obj = None
1395 1395
1396 1396 # Look for the given name by splitting it in parts. If the head is
1397 1397 # found, then we look for all the remaining parts as members, and only
1398 1398 # declare success if we can find them all.
1399 1399 oname_parts = oname.split('.')
1400 1400 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
1401 1401 for nsname,ns in namespaces:
1402 1402 try:
1403 1403 obj = ns[oname_head]
1404 1404 except KeyError:
1405 1405 continue
1406 1406 else:
1407 1407 for idx, part in enumerate(oname_rest):
1408 1408 try:
1409 1409 parent = obj
1410 1410 # The last part is looked up in a special way to avoid
1411 1411 # descriptor invocation as it may raise or have side
1412 1412 # effects.
1413 1413 if idx == len(oname_rest) - 1:
1414 1414 obj = self._getattr_property(obj, part)
1415 1415 else:
1416 1416 obj = getattr(obj, part)
1417 1417 except:
1418 1418 # Blanket except b/c some badly implemented objects
1419 1419 # allow __getattr__ to raise exceptions other than
1420 1420 # AttributeError, which then crashes IPython.
1421 1421 break
1422 1422 else:
1423 1423 # If we finish the for loop (no break), we got all members
1424 1424 found = True
1425 1425 ospace = nsname
1426 1426 break # namespace loop
1427 1427
1428 1428 # Try to see if it's magic
1429 1429 if not found:
1430 1430 obj = None
1431 1431 if oname.startswith(ESC_MAGIC2):
1432 1432 oname = oname.lstrip(ESC_MAGIC2)
1433 1433 obj = self.find_cell_magic(oname)
1434 1434 elif oname.startswith(ESC_MAGIC):
1435 1435 oname = oname.lstrip(ESC_MAGIC)
1436 1436 obj = self.find_line_magic(oname)
1437 1437 else:
1438 1438 # search without prefix, so run? will find %run?
1439 1439 obj = self.find_line_magic(oname)
1440 1440 if obj is None:
1441 1441 obj = self.find_cell_magic(oname)
1442 1442 if obj is not None:
1443 1443 found = True
1444 1444 ospace = 'IPython internal'
1445 1445 ismagic = True
1446 1446 isalias = isinstance(obj, Alias)
1447 1447
1448 1448 return {'found':found, 'obj':obj, 'namespace':ospace,
1449 1449 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1450 1450
1451 1451 @staticmethod
1452 1452 def _getattr_property(obj, attrname):
1453 1453 """Property-aware getattr to use in object finding.
1454 1454
1455 1455 If attrname represents a property, return it unevaluated (in case it has
1456 1456 side effects or raises an error.
1457 1457
1458 1458 """
1459 1459 if not isinstance(obj, type):
1460 1460 try:
1461 1461 # `getattr(type(obj), attrname)` is not guaranteed to return
1462 1462 # `obj`, but does so for property:
1463 1463 #
1464 1464 # property.__get__(self, None, cls) -> self
1465 1465 #
1466 1466 # The universal alternative is to traverse the mro manually
1467 1467 # searching for attrname in class dicts.
1468 1468 attr = getattr(type(obj), attrname)
1469 1469 except AttributeError:
1470 1470 pass
1471 1471 else:
1472 1472 # This relies on the fact that data descriptors (with both
1473 1473 # __get__ & __set__ magic methods) take precedence over
1474 1474 # instance-level attributes:
1475 1475 #
1476 1476 # class A(object):
1477 1477 # @property
1478 1478 # def foobar(self): return 123
1479 1479 # a = A()
1480 1480 # a.__dict__['foobar'] = 345
1481 1481 # a.foobar # == 123
1482 1482 #
1483 1483 # So, a property may be returned right away.
1484 1484 if isinstance(attr, property):
1485 1485 return attr
1486 1486
1487 1487 # Nothing helped, fall back.
1488 1488 return getattr(obj, attrname)
1489 1489
1490 1490 def _object_find(self, oname, namespaces=None):
1491 1491 """Find an object and return a struct with info about it."""
1492 1492 return Struct(self._ofind(oname, namespaces))
1493 1493
1494 1494 def _inspect(self, meth, oname, namespaces=None, **kw):
1495 1495 """Generic interface to the inspector system.
1496 1496
1497 1497 This function is meant to be called by pdef, pdoc & friends.
1498 1498 """
1499 1499 info = self._object_find(oname, namespaces)
1500 1500 docformat = sphinxify if self.sphinxify_docstring else None
1501 1501 if info.found:
1502 1502 pmethod = getattr(self.inspector, meth)
1503 1503 # TODO: only apply format_screen to the plain/text repr of the mime
1504 1504 # bundle.
1505 1505 formatter = format_screen if info.ismagic else docformat
1506 1506 if meth == 'pdoc':
1507 1507 pmethod(info.obj, oname, formatter)
1508 1508 elif meth == 'pinfo':
1509 1509 pmethod(info.obj, oname, formatter, info,
1510 1510 enable_html_pager=self.enable_html_pager, **kw)
1511 1511 else:
1512 1512 pmethod(info.obj, oname)
1513 1513 else:
1514 1514 print('Object `%s` not found.' % oname)
1515 1515 return 'not found' # so callers can take other action
1516 1516
1517 1517 def object_inspect(self, oname, detail_level=0):
1518 1518 """Get object info about oname"""
1519 1519 with self.builtin_trap:
1520 1520 info = self._object_find(oname)
1521 1521 if info.found:
1522 1522 return self.inspector.info(info.obj, oname, info=info,
1523 1523 detail_level=detail_level
1524 1524 )
1525 1525 else:
1526 1526 return oinspect.object_info(name=oname, found=False)
1527 1527
1528 1528 def object_inspect_text(self, oname, detail_level=0):
1529 1529 """Get object info as formatted text"""
1530 1530 return self.object_inspect_mime(oname, detail_level)['text/plain']
1531 1531
1532 1532 def object_inspect_mime(self, oname, detail_level=0):
1533 1533 """Get object info as a mimebundle of formatted representations.
1534 1534
1535 1535 A mimebundle is a dictionary, keyed by mime-type.
1536 1536 It must always have the key `'text/plain'`.
1537 1537 """
1538 1538 with self.builtin_trap:
1539 1539 info = self._object_find(oname)
1540 1540 if info.found:
1541 1541 return self.inspector._get_info(info.obj, oname, info=info,
1542 1542 detail_level=detail_level
1543 1543 )
1544 1544 else:
1545 1545 raise KeyError(oname)
1546 1546
1547 1547 #-------------------------------------------------------------------------
1548 1548 # Things related to history management
1549 1549 #-------------------------------------------------------------------------
1550 1550
1551 1551 def init_history(self):
1552 1552 """Sets up the command history, and starts regular autosaves."""
1553 1553 self.history_manager = HistoryManager(shell=self, parent=self)
1554 1554 self.configurables.append(self.history_manager)
1555 1555
1556 1556 #-------------------------------------------------------------------------
1557 1557 # Things related to exception handling and tracebacks (not debugging)
1558 1558 #-------------------------------------------------------------------------
1559 1559
1560 1560 debugger_cls = Pdb
1561 1561
1562 1562 def init_traceback_handlers(self, custom_exceptions):
1563 1563 # Syntax error handler.
1564 1564 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor', parent=self)
1565 1565
1566 1566 # The interactive one is initialized with an offset, meaning we always
1567 1567 # want to remove the topmost item in the traceback, which is our own
1568 1568 # internal code. Valid modes: ['Plain','Context','Verbose']
1569 1569 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1570 1570 color_scheme='NoColor',
1571 1571 tb_offset = 1,
1572 1572 check_cache=check_linecache_ipython,
1573 1573 debugger_cls=self.debugger_cls, parent=self)
1574 1574
1575 1575 # The instance will store a pointer to the system-wide exception hook,
1576 1576 # so that runtime code (such as magics) can access it. This is because
1577 1577 # during the read-eval loop, it may get temporarily overwritten.
1578 1578 self.sys_excepthook = sys.excepthook
1579 1579
1580 1580 # and add any custom exception handlers the user may have specified
1581 1581 self.set_custom_exc(*custom_exceptions)
1582 1582
1583 1583 # Set the exception mode
1584 1584 self.InteractiveTB.set_mode(mode=self.xmode)
1585 1585
1586 1586 def set_custom_exc(self, exc_tuple, handler):
1587 1587 """set_custom_exc(exc_tuple, handler)
1588 1588
1589 1589 Set a custom exception handler, which will be called if any of the
1590 1590 exceptions in exc_tuple occur in the mainloop (specifically, in the
1591 1591 run_code() method).
1592 1592
1593 1593 Parameters
1594 1594 ----------
1595 1595
1596 1596 exc_tuple : tuple of exception classes
1597 1597 A *tuple* of exception classes, for which to call the defined
1598 1598 handler. It is very important that you use a tuple, and NOT A
1599 1599 LIST here, because of the way Python's except statement works. If
1600 1600 you only want to trap a single exception, use a singleton tuple::
1601 1601
1602 1602 exc_tuple == (MyCustomException,)
1603 1603
1604 1604 handler : callable
1605 1605 handler must have the following signature::
1606 1606
1607 1607 def my_handler(self, etype, value, tb, tb_offset=None):
1608 1608 ...
1609 1609 return structured_traceback
1610 1610
1611 1611 Your handler must return a structured traceback (a list of strings),
1612 1612 or None.
1613 1613
1614 1614 This will be made into an instance method (via types.MethodType)
1615 1615 of IPython itself, and it will be called if any of the exceptions
1616 1616 listed in the exc_tuple are caught. If the handler is None, an
1617 1617 internal basic one is used, which just prints basic info.
1618 1618
1619 1619 To protect IPython from crashes, if your handler ever raises an
1620 1620 exception or returns an invalid result, it will be immediately
1621 1621 disabled.
1622 1622
1623 1623 WARNING: by putting in your own exception handler into IPython's main
1624 1624 execution loop, you run a very good chance of nasty crashes. This
1625 1625 facility should only be used if you really know what you are doing."""
1626 1626 if not isinstance(exc_tuple, tuple):
1627 1627 raise TypeError("The custom exceptions must be given as a tuple.")
1628 1628
1629 1629 def dummy_handler(self, etype, value, tb, tb_offset=None):
1630 1630 print('*** Simple custom exception handler ***')
1631 1631 print('Exception type :', etype)
1632 1632 print('Exception value:', value)
1633 1633 print('Traceback :', tb)
1634 1634
1635 1635 def validate_stb(stb):
1636 1636 """validate structured traceback return type
1637 1637
1638 1638 return type of CustomTB *should* be a list of strings, but allow
1639 1639 single strings or None, which are harmless.
1640 1640
1641 1641 This function will *always* return a list of strings,
1642 1642 and will raise a TypeError if stb is inappropriate.
1643 1643 """
1644 1644 msg = "CustomTB must return list of strings, not %r" % stb
1645 1645 if stb is None:
1646 1646 return []
1647 1647 elif isinstance(stb, str):
1648 1648 return [stb]
1649 1649 elif not isinstance(stb, list):
1650 1650 raise TypeError(msg)
1651 1651 # it's a list
1652 1652 for line in stb:
1653 1653 # check every element
1654 1654 if not isinstance(line, str):
1655 1655 raise TypeError(msg)
1656 1656 return stb
1657 1657
1658 1658 if handler is None:
1659 1659 wrapped = dummy_handler
1660 1660 else:
1661 1661 def wrapped(self,etype,value,tb,tb_offset=None):
1662 1662 """wrap CustomTB handler, to protect IPython from user code
1663 1663
1664 1664 This makes it harder (but not impossible) for custom exception
1665 1665 handlers to crash IPython.
1666 1666 """
1667 1667 try:
1668 1668 stb = handler(self,etype,value,tb,tb_offset=tb_offset)
1669 1669 return validate_stb(stb)
1670 1670 except:
1671 1671 # clear custom handler immediately
1672 1672 self.set_custom_exc((), None)
1673 1673 print("Custom TB Handler failed, unregistering", file=sys.stderr)
1674 1674 # show the exception in handler first
1675 1675 stb = self.InteractiveTB.structured_traceback(*sys.exc_info())
1676 1676 print(self.InteractiveTB.stb2text(stb))
1677 1677 print("The original exception:")
1678 1678 stb = self.InteractiveTB.structured_traceback(
1679 1679 (etype,value,tb), tb_offset=tb_offset
1680 1680 )
1681 1681 return stb
1682 1682
1683 1683 self.CustomTB = types.MethodType(wrapped,self)
1684 1684 self.custom_exceptions = exc_tuple
1685 1685
1686 1686 def excepthook(self, etype, value, tb):
1687 1687 """One more defense for GUI apps that call sys.excepthook.
1688 1688
1689 1689 GUI frameworks like wxPython trap exceptions and call
1690 1690 sys.excepthook themselves. I guess this is a feature that
1691 1691 enables them to keep running after exceptions that would
1692 1692 otherwise kill their mainloop. This is a bother for IPython
1693 1693 which excepts to catch all of the program exceptions with a try:
1694 1694 except: statement.
1695 1695
1696 1696 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1697 1697 any app directly invokes sys.excepthook, it will look to the user like
1698 1698 IPython crashed. In order to work around this, we can disable the
1699 1699 CrashHandler and replace it with this excepthook instead, which prints a
1700 1700 regular traceback using our InteractiveTB. In this fashion, apps which
1701 1701 call sys.excepthook will generate a regular-looking exception from
1702 1702 IPython, and the CrashHandler will only be triggered by real IPython
1703 1703 crashes.
1704 1704
1705 1705 This hook should be used sparingly, only in places which are not likely
1706 1706 to be true IPython errors.
1707 1707 """
1708 1708 self.showtraceback((etype, value, tb), tb_offset=0)
1709 1709
1710 1710 def _get_exc_info(self, exc_tuple=None):
1711 1711 """get exc_info from a given tuple, sys.exc_info() or sys.last_type etc.
1712 1712
1713 1713 Ensures sys.last_type,value,traceback hold the exc_info we found,
1714 1714 from whichever source.
1715 1715
1716 1716 raises ValueError if none of these contain any information
1717 1717 """
1718 1718 if exc_tuple is None:
1719 1719 etype, value, tb = sys.exc_info()
1720 1720 else:
1721 1721 etype, value, tb = exc_tuple
1722 1722
1723 1723 if etype is None:
1724 1724 if hasattr(sys, 'last_type'):
1725 1725 etype, value, tb = sys.last_type, sys.last_value, \
1726 1726 sys.last_traceback
1727 1727
1728 1728 if etype is None:
1729 1729 raise ValueError("No exception to find")
1730 1730
1731 1731 # Now store the exception info in sys.last_type etc.
1732 1732 # WARNING: these variables are somewhat deprecated and not
1733 1733 # necessarily safe to use in a threaded environment, but tools
1734 1734 # like pdb depend on their existence, so let's set them. If we
1735 1735 # find problems in the field, we'll need to revisit their use.
1736 1736 sys.last_type = etype
1737 1737 sys.last_value = value
1738 1738 sys.last_traceback = tb
1739 1739
1740 1740 return etype, value, tb
1741 1741
1742 1742 def show_usage_error(self, exc):
1743 1743 """Show a short message for UsageErrors
1744 1744
1745 1745 These are special exceptions that shouldn't show a traceback.
1746 1746 """
1747 1747 print("UsageError: %s" % exc, file=sys.stderr)
1748 1748
1749 1749 def get_exception_only(self, exc_tuple=None):
1750 1750 """
1751 1751 Return as a string (ending with a newline) the exception that
1752 1752 just occurred, without any traceback.
1753 1753 """
1754 1754 etype, value, tb = self._get_exc_info(exc_tuple)
1755 1755 msg = traceback.format_exception_only(etype, value)
1756 1756 return ''.join(msg)
1757 1757
1758 1758 def showtraceback(self, exc_tuple=None, filename=None, tb_offset=None,
1759 exception_only=False):
1759 exception_only=False, running_compiled_code=False):
1760 1760 """Display the exception that just occurred.
1761 1761
1762 1762 If nothing is known about the exception, this is the method which
1763 1763 should be used throughout the code for presenting user tracebacks,
1764 1764 rather than directly invoking the InteractiveTB object.
1765 1765
1766 1766 A specific showsyntaxerror() also exists, but this method can take
1767 1767 care of calling it if needed, so unless you are explicitly catching a
1768 1768 SyntaxError exception, don't try to analyze the stack manually and
1769 1769 simply call this method."""
1770 1770
1771 1771 try:
1772 1772 try:
1773 1773 etype, value, tb = self._get_exc_info(exc_tuple)
1774 1774 except ValueError:
1775 1775 print('No traceback available to show.', file=sys.stderr)
1776 1776 return
1777 1777
1778 1778 if issubclass(etype, SyntaxError):
1779 1779 # Though this won't be called by syntax errors in the input
1780 1780 # line, there may be SyntaxError cases with imported code.
1781 self.showsyntaxerror(filename)
1781 self.showsyntaxerror(filename, running_compiled_code)
1782 1782 elif etype is UsageError:
1783 1783 self.show_usage_error(value)
1784 1784 else:
1785 1785 if exception_only:
1786 1786 stb = ['An exception has occurred, use %tb to see '
1787 1787 'the full traceback.\n']
1788 1788 stb.extend(self.InteractiveTB.get_exception_only(etype,
1789 1789 value))
1790 1790 else:
1791 1791 try:
1792 1792 # Exception classes can customise their traceback - we
1793 1793 # use this in IPython.parallel for exceptions occurring
1794 1794 # in the engines. This should return a list of strings.
1795 1795 stb = value._render_traceback_()
1796 1796 except Exception:
1797 1797 stb = self.InteractiveTB.structured_traceback(etype,
1798 1798 value, tb, tb_offset=tb_offset)
1799 1799
1800 1800 self._showtraceback(etype, value, stb)
1801 1801 if self.call_pdb:
1802 1802 # drop into debugger
1803 1803 self.debugger(force=True)
1804 1804 return
1805 1805
1806 1806 # Actually show the traceback
1807 1807 self._showtraceback(etype, value, stb)
1808 1808
1809 1809 except KeyboardInterrupt:
1810 1810 print('\n' + self.get_exception_only(), file=sys.stderr)
1811 1811
1812 1812 def _showtraceback(self, etype, evalue, stb):
1813 1813 """Actually show a traceback.
1814 1814
1815 1815 Subclasses may override this method to put the traceback on a different
1816 1816 place, like a side channel.
1817 1817 """
1818 1818 print(self.InteractiveTB.stb2text(stb))
1819 1819
1820 def showsyntaxerror(self, filename=None):
1820 def showsyntaxerror(self, filename=None, running_compiled_code=False):
1821 1821 """Display the syntax error that just occurred.
1822 1822
1823 1823 This doesn't display a stack trace because there isn't one.
1824 1824
1825 1825 If a filename is given, it is stuffed in the exception instead
1826 1826 of what was there before (because Python's parser always uses
1827 1827 "<string>" when reading from a string).
1828
1829 If the syntax error occurred when running a compiled code (i.e. running_compile_code=True),
1830 longer stack trace will be displayed.
1828 1831 """
1829 1832 etype, value, last_traceback = self._get_exc_info()
1830 1833
1831 1834 if filename and issubclass(etype, SyntaxError):
1832 1835 try:
1833 1836 value.filename = filename
1834 1837 except:
1835 1838 # Not the format we expect; leave it alone
1836 1839 pass
1837 1840
1838 stb = self.SyntaxTB.structured_traceback(etype, value, [])
1841 # If the error occured when executing compiled code, we should provide full stacktrace.
1842 elist = traceback.extract_tb(last_traceback) if running_compiled_code else []
1843 stb = self.SyntaxTB.structured_traceback(etype, value, elist)
1839 1844 self._showtraceback(etype, value, stb)
1840 1845
1841 1846 # This is overridden in TerminalInteractiveShell to show a message about
1842 1847 # the %paste magic.
1843 1848 def showindentationerror(self):
1844 1849 """Called by run_cell when there's an IndentationError in code entered
1845 1850 at the prompt.
1846 1851
1847 1852 This is overridden in TerminalInteractiveShell to show a message about
1848 1853 the %paste magic."""
1849 1854 self.showsyntaxerror()
1850 1855
1851 1856 #-------------------------------------------------------------------------
1852 1857 # Things related to readline
1853 1858 #-------------------------------------------------------------------------
1854 1859
1855 1860 def init_readline(self):
1856 1861 """DEPRECATED
1857 1862
1858 1863 Moved to terminal subclass, here only to simplify the init logic."""
1859 1864 # Set a number of methods that depend on readline to be no-op
1860 1865 warnings.warn('`init_readline` is no-op since IPython 5.0 and is Deprecated',
1861 1866 DeprecationWarning, stacklevel=2)
1862 1867 self.set_custom_completer = no_op
1863 1868
1864 1869 @skip_doctest
1865 1870 def set_next_input(self, s, replace=False):
1866 1871 """ Sets the 'default' input string for the next command line.
1867 1872
1868 1873 Example::
1869 1874
1870 1875 In [1]: _ip.set_next_input("Hello Word")
1871 1876 In [2]: Hello Word_ # cursor is here
1872 1877 """
1873 1878 self.rl_next_input = py3compat.cast_bytes_py2(s)
1874 1879
1875 1880 def _indent_current_str(self):
1876 1881 """return the current level of indentation as a string"""
1877 1882 return self.input_splitter.indent_spaces * ' '
1878 1883
1879 1884 #-------------------------------------------------------------------------
1880 1885 # Things related to text completion
1881 1886 #-------------------------------------------------------------------------
1882 1887
1883 1888 def init_completer(self):
1884 1889 """Initialize the completion machinery.
1885 1890
1886 1891 This creates completion machinery that can be used by client code,
1887 1892 either interactively in-process (typically triggered by the readline
1888 1893 library), programmatically (such as in test suites) or out-of-process
1889 1894 (typically over the network by remote frontends).
1890 1895 """
1891 1896 from IPython.core.completer import IPCompleter
1892 1897 from IPython.core.completerlib import (module_completer,
1893 1898 magic_run_completer, cd_completer, reset_completer)
1894 1899
1895 1900 self.Completer = IPCompleter(shell=self,
1896 1901 namespace=self.user_ns,
1897 1902 global_namespace=self.user_global_ns,
1898 1903 parent=self,
1899 1904 )
1900 1905 self.configurables.append(self.Completer)
1901 1906
1902 1907 # Add custom completers to the basic ones built into IPCompleter
1903 1908 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1904 1909 self.strdispatchers['complete_command'] = sdisp
1905 1910 self.Completer.custom_completers = sdisp
1906 1911
1907 1912 self.set_hook('complete_command', module_completer, str_key = 'import')
1908 1913 self.set_hook('complete_command', module_completer, str_key = 'from')
1909 1914 self.set_hook('complete_command', module_completer, str_key = '%aimport')
1910 1915 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
1911 1916 self.set_hook('complete_command', cd_completer, str_key = '%cd')
1912 1917 self.set_hook('complete_command', reset_completer, str_key = '%reset')
1913 1918
1914 1919
1915 1920 def complete(self, text, line=None, cursor_pos=None):
1916 1921 """Return the completed text and a list of completions.
1917 1922
1918 1923 Parameters
1919 1924 ----------
1920 1925
1921 1926 text : string
1922 1927 A string of text to be completed on. It can be given as empty and
1923 1928 instead a line/position pair are given. In this case, the
1924 1929 completer itself will split the line like readline does.
1925 1930
1926 1931 line : string, optional
1927 1932 The complete line that text is part of.
1928 1933
1929 1934 cursor_pos : int, optional
1930 1935 The position of the cursor on the input line.
1931 1936
1932 1937 Returns
1933 1938 -------
1934 1939 text : string
1935 1940 The actual text that was completed.
1936 1941
1937 1942 matches : list
1938 1943 A sorted list with all possible completions.
1939 1944
1940 1945 The optional arguments allow the completion to take more context into
1941 1946 account, and are part of the low-level completion API.
1942 1947
1943 1948 This is a wrapper around the completion mechanism, similar to what
1944 1949 readline does at the command line when the TAB key is hit. By
1945 1950 exposing it as a method, it can be used by other non-readline
1946 1951 environments (such as GUIs) for text completion.
1947 1952
1948 1953 Simple usage example:
1949 1954
1950 1955 In [1]: x = 'hello'
1951 1956
1952 1957 In [2]: _ip.complete('x.l')
1953 1958 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
1954 1959 """
1955 1960
1956 1961 # Inject names into __builtin__ so we can complete on the added names.
1957 1962 with self.builtin_trap:
1958 1963 return self.Completer.complete(text, line, cursor_pos)
1959 1964
1960 1965 def set_custom_completer(self, completer, pos=0):
1961 1966 """Adds a new custom completer function.
1962 1967
1963 1968 The position argument (defaults to 0) is the index in the completers
1964 1969 list where you want the completer to be inserted."""
1965 1970
1966 1971 newcomp = types.MethodType(completer,self.Completer)
1967 1972 self.Completer.matchers.insert(pos,newcomp)
1968 1973
1969 1974 def set_completer_frame(self, frame=None):
1970 1975 """Set the frame of the completer."""
1971 1976 if frame:
1972 1977 self.Completer.namespace = frame.f_locals
1973 1978 self.Completer.global_namespace = frame.f_globals
1974 1979 else:
1975 1980 self.Completer.namespace = self.user_ns
1976 1981 self.Completer.global_namespace = self.user_global_ns
1977 1982
1978 1983 #-------------------------------------------------------------------------
1979 1984 # Things related to magics
1980 1985 #-------------------------------------------------------------------------
1981 1986
1982 1987 def init_magics(self):
1983 1988 from IPython.core import magics as m
1984 1989 self.magics_manager = magic.MagicsManager(shell=self,
1985 1990 parent=self,
1986 1991 user_magics=m.UserMagics(self))
1987 1992 self.configurables.append(self.magics_manager)
1988 1993
1989 1994 # Expose as public API from the magics manager
1990 1995 self.register_magics = self.magics_manager.register
1991 1996
1992 1997 self.register_magics(m.AutoMagics, m.BasicMagics, m.CodeMagics,
1993 1998 m.ConfigMagics, m.DisplayMagics, m.ExecutionMagics,
1994 1999 m.ExtensionMagics, m.HistoryMagics, m.LoggingMagics,
1995 2000 m.NamespaceMagics, m.OSMagics, m.PylabMagics, m.ScriptMagics,
1996 2001 )
1997 2002
1998 2003 # Register Magic Aliases
1999 2004 mman = self.magics_manager
2000 2005 # FIXME: magic aliases should be defined by the Magics classes
2001 2006 # or in MagicsManager, not here
2002 2007 mman.register_alias('ed', 'edit')
2003 2008 mman.register_alias('hist', 'history')
2004 2009 mman.register_alias('rep', 'recall')
2005 2010 mman.register_alias('SVG', 'svg', 'cell')
2006 2011 mman.register_alias('HTML', 'html', 'cell')
2007 2012 mman.register_alias('file', 'writefile', 'cell')
2008 2013
2009 2014 # FIXME: Move the color initialization to the DisplayHook, which
2010 2015 # should be split into a prompt manager and displayhook. We probably
2011 2016 # even need a centralize colors management object.
2012 2017 self.magic('colors %s' % self.colors)
2013 2018
2014 2019 # Defined here so that it's included in the documentation
2015 2020 @functools.wraps(magic.MagicsManager.register_function)
2016 2021 def register_magic_function(self, func, magic_kind='line', magic_name=None):
2017 2022 self.magics_manager.register_function(func,
2018 2023 magic_kind=magic_kind, magic_name=magic_name)
2019 2024
2020 2025 def run_line_magic(self, magic_name, line):
2021 2026 """Execute the given line magic.
2022 2027
2023 2028 Parameters
2024 2029 ----------
2025 2030 magic_name : str
2026 2031 Name of the desired magic function, without '%' prefix.
2027 2032
2028 2033 line : str
2029 2034 The rest of the input line as a single string.
2030 2035 """
2031 2036 fn = self.find_line_magic(magic_name)
2032 2037 if fn is None:
2033 2038 cm = self.find_cell_magic(magic_name)
2034 2039 etpl = "Line magic function `%%%s` not found%s."
2035 2040 extra = '' if cm is None else (' (But cell magic `%%%%%s` exists, '
2036 2041 'did you mean that instead?)' % magic_name )
2037 2042 error(etpl % (magic_name, extra))
2038 2043 else:
2039 2044 # Note: this is the distance in the stack to the user's frame.
2040 2045 # This will need to be updated if the internal calling logic gets
2041 2046 # refactored, or else we'll be expanding the wrong variables.
2042 2047 stack_depth = 2
2043 2048 magic_arg_s = self.var_expand(line, stack_depth)
2044 2049 # Put magic args in a list so we can call with f(*a) syntax
2045 2050 args = [magic_arg_s]
2046 2051 kwargs = {}
2047 2052 # Grab local namespace if we need it:
2048 2053 if getattr(fn, "needs_local_scope", False):
2049 2054 kwargs['local_ns'] = sys._getframe(stack_depth).f_locals
2050 2055 with self.builtin_trap:
2051 2056 result = fn(*args,**kwargs)
2052 2057 return result
2053 2058
2054 2059 def run_cell_magic(self, magic_name, line, cell):
2055 2060 """Execute the given cell magic.
2056 2061
2057 2062 Parameters
2058 2063 ----------
2059 2064 magic_name : str
2060 2065 Name of the desired magic function, without '%' prefix.
2061 2066
2062 2067 line : str
2063 2068 The rest of the first input line as a single string.
2064 2069
2065 2070 cell : str
2066 2071 The body of the cell as a (possibly multiline) string.
2067 2072 """
2068 2073 fn = self.find_cell_magic(magic_name)
2069 2074 if fn is None:
2070 2075 lm = self.find_line_magic(magic_name)
2071 2076 etpl = "Cell magic `%%{0}` not found{1}."
2072 2077 extra = '' if lm is None else (' (But line magic `%{0}` exists, '
2073 2078 'did you mean that instead?)'.format(magic_name))
2074 2079 error(etpl.format(magic_name, extra))
2075 2080 elif cell == '':
2076 2081 message = '%%{0} is a cell magic, but the cell body is empty.'.format(magic_name)
2077 2082 if self.find_line_magic(magic_name) is not None:
2078 2083 message += ' Did you mean the line magic %{0} (single %)?'.format(magic_name)
2079 2084 raise UsageError(message)
2080 2085 else:
2081 2086 # Note: this is the distance in the stack to the user's frame.
2082 2087 # This will need to be updated if the internal calling logic gets
2083 2088 # refactored, or else we'll be expanding the wrong variables.
2084 2089 stack_depth = 2
2085 2090 magic_arg_s = self.var_expand(line, stack_depth)
2086 2091 with self.builtin_trap:
2087 2092 result = fn(magic_arg_s, cell)
2088 2093 return result
2089 2094
2090 2095 def find_line_magic(self, magic_name):
2091 2096 """Find and return a line magic by name.
2092 2097
2093 2098 Returns None if the magic isn't found."""
2094 2099 return self.magics_manager.magics['line'].get(magic_name)
2095 2100
2096 2101 def find_cell_magic(self, magic_name):
2097 2102 """Find and return a cell magic by name.
2098 2103
2099 2104 Returns None if the magic isn't found."""
2100 2105 return self.magics_manager.magics['cell'].get(magic_name)
2101 2106
2102 2107 def find_magic(self, magic_name, magic_kind='line'):
2103 2108 """Find and return a magic of the given type by name.
2104 2109
2105 2110 Returns None if the magic isn't found."""
2106 2111 return self.magics_manager.magics[magic_kind].get(magic_name)
2107 2112
2108 2113 def magic(self, arg_s):
2109 2114 """DEPRECATED. Use run_line_magic() instead.
2110 2115
2111 2116 Call a magic function by name.
2112 2117
2113 2118 Input: a string containing the name of the magic function to call and
2114 2119 any additional arguments to be passed to the magic.
2115 2120
2116 2121 magic('name -opt foo bar') is equivalent to typing at the ipython
2117 2122 prompt:
2118 2123
2119 2124 In[1]: %name -opt foo bar
2120 2125
2121 2126 To call a magic without arguments, simply use magic('name').
2122 2127
2123 2128 This provides a proper Python function to call IPython's magics in any
2124 2129 valid Python code you can type at the interpreter, including loops and
2125 2130 compound statements.
2126 2131 """
2127 2132 # TODO: should we issue a loud deprecation warning here?
2128 2133 magic_name, _, magic_arg_s = arg_s.partition(' ')
2129 2134 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
2130 2135 return self.run_line_magic(magic_name, magic_arg_s)
2131 2136
2132 2137 #-------------------------------------------------------------------------
2133 2138 # Things related to macros
2134 2139 #-------------------------------------------------------------------------
2135 2140
2136 2141 def define_macro(self, name, themacro):
2137 2142 """Define a new macro
2138 2143
2139 2144 Parameters
2140 2145 ----------
2141 2146 name : str
2142 2147 The name of the macro.
2143 2148 themacro : str or Macro
2144 2149 The action to do upon invoking the macro. If a string, a new
2145 2150 Macro object is created by passing the string to it.
2146 2151 """
2147 2152
2148 2153 from IPython.core import macro
2149 2154
2150 2155 if isinstance(themacro, str):
2151 2156 themacro = macro.Macro(themacro)
2152 2157 if not isinstance(themacro, macro.Macro):
2153 2158 raise ValueError('A macro must be a string or a Macro instance.')
2154 2159 self.user_ns[name] = themacro
2155 2160
2156 2161 #-------------------------------------------------------------------------
2157 2162 # Things related to the running of system commands
2158 2163 #-------------------------------------------------------------------------
2159 2164
2160 2165 def system_piped(self, cmd):
2161 2166 """Call the given cmd in a subprocess, piping stdout/err
2162 2167
2163 2168 Parameters
2164 2169 ----------
2165 2170 cmd : str
2166 2171 Command to execute (can not end in '&', as background processes are
2167 2172 not supported. Should not be a command that expects input
2168 2173 other than simple text.
2169 2174 """
2170 2175 if cmd.rstrip().endswith('&'):
2171 2176 # this is *far* from a rigorous test
2172 2177 # We do not support backgrounding processes because we either use
2173 2178 # pexpect or pipes to read from. Users can always just call
2174 2179 # os.system() or use ip.system=ip.system_raw
2175 2180 # if they really want a background process.
2176 2181 raise OSError("Background processes not supported.")
2177 2182
2178 2183 # we explicitly do NOT return the subprocess status code, because
2179 2184 # a non-None value would trigger :func:`sys.displayhook` calls.
2180 2185 # Instead, we store the exit_code in user_ns.
2181 2186 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=1))
2182 2187
2183 2188 def system_raw(self, cmd):
2184 2189 """Call the given cmd in a subprocess using os.system on Windows or
2185 2190 subprocess.call using the system shell on other platforms.
2186 2191
2187 2192 Parameters
2188 2193 ----------
2189 2194 cmd : str
2190 2195 Command to execute.
2191 2196 """
2192 2197 cmd = self.var_expand(cmd, depth=1)
2193 2198 # protect os.system from UNC paths on Windows, which it can't handle:
2194 2199 if sys.platform == 'win32':
2195 2200 from IPython.utils._process_win32 import AvoidUNCPath
2196 2201 with AvoidUNCPath() as path:
2197 2202 if path is not None:
2198 2203 cmd = '"pushd %s &&"%s' % (path, cmd)
2199 2204 try:
2200 2205 ec = os.system(cmd)
2201 2206 except KeyboardInterrupt:
2202 2207 print('\n' + self.get_exception_only(), file=sys.stderr)
2203 2208 ec = -2
2204 2209 else:
2205 2210 # For posix the result of the subprocess.call() below is an exit
2206 2211 # code, which by convention is zero for success, positive for
2207 2212 # program failure. Exit codes above 128 are reserved for signals,
2208 2213 # and the formula for converting a signal to an exit code is usually
2209 2214 # signal_number+128. To more easily differentiate between exit
2210 2215 # codes and signals, ipython uses negative numbers. For instance
2211 2216 # since control-c is signal 2 but exit code 130, ipython's
2212 2217 # _exit_code variable will read -2. Note that some shells like
2213 2218 # csh and fish don't follow sh/bash conventions for exit codes.
2214 2219 executable = os.environ.get('SHELL', None)
2215 2220 try:
2216 2221 # Use env shell instead of default /bin/sh
2217 2222 ec = subprocess.call(cmd, shell=True, executable=executable)
2218 2223 except KeyboardInterrupt:
2219 2224 # intercept control-C; a long traceback is not useful here
2220 2225 print('\n' + self.get_exception_only(), file=sys.stderr)
2221 2226 ec = 130
2222 2227 if ec > 128:
2223 2228 ec = -(ec - 128)
2224 2229
2225 2230 # We explicitly do NOT return the subprocess status code, because
2226 2231 # a non-None value would trigger :func:`sys.displayhook` calls.
2227 2232 # Instead, we store the exit_code in user_ns. Note the semantics
2228 2233 # of _exit_code: for control-c, _exit_code == -signal.SIGNIT,
2229 2234 # but raising SystemExit(_exit_code) will give status 254!
2230 2235 self.user_ns['_exit_code'] = ec
2231 2236
2232 2237 # use piped system by default, because it is better behaved
2233 2238 system = system_piped
2234 2239
2235 2240 def getoutput(self, cmd, split=True, depth=0):
2236 2241 """Get output (possibly including stderr) from a subprocess.
2237 2242
2238 2243 Parameters
2239 2244 ----------
2240 2245 cmd : str
2241 2246 Command to execute (can not end in '&', as background processes are
2242 2247 not supported.
2243 2248 split : bool, optional
2244 2249 If True, split the output into an IPython SList. Otherwise, an
2245 2250 IPython LSString is returned. These are objects similar to normal
2246 2251 lists and strings, with a few convenience attributes for easier
2247 2252 manipulation of line-based output. You can use '?' on them for
2248 2253 details.
2249 2254 depth : int, optional
2250 2255 How many frames above the caller are the local variables which should
2251 2256 be expanded in the command string? The default (0) assumes that the
2252 2257 expansion variables are in the stack frame calling this function.
2253 2258 """
2254 2259 if cmd.rstrip().endswith('&'):
2255 2260 # this is *far* from a rigorous test
2256 2261 raise OSError("Background processes not supported.")
2257 2262 out = getoutput(self.var_expand(cmd, depth=depth+1))
2258 2263 if split:
2259 2264 out = SList(out.splitlines())
2260 2265 else:
2261 2266 out = LSString(out)
2262 2267 return out
2263 2268
2264 2269 #-------------------------------------------------------------------------
2265 2270 # Things related to aliases
2266 2271 #-------------------------------------------------------------------------
2267 2272
2268 2273 def init_alias(self):
2269 2274 self.alias_manager = AliasManager(shell=self, parent=self)
2270 2275 self.configurables.append(self.alias_manager)
2271 2276
2272 2277 #-------------------------------------------------------------------------
2273 2278 # Things related to extensions
2274 2279 #-------------------------------------------------------------------------
2275 2280
2276 2281 def init_extension_manager(self):
2277 2282 self.extension_manager = ExtensionManager(shell=self, parent=self)
2278 2283 self.configurables.append(self.extension_manager)
2279 2284
2280 2285 #-------------------------------------------------------------------------
2281 2286 # Things related to payloads
2282 2287 #-------------------------------------------------------------------------
2283 2288
2284 2289 def init_payload(self):
2285 2290 self.payload_manager = PayloadManager(parent=self)
2286 2291 self.configurables.append(self.payload_manager)
2287 2292
2288 2293 #-------------------------------------------------------------------------
2289 2294 # Things related to the prefilter
2290 2295 #-------------------------------------------------------------------------
2291 2296
2292 2297 def init_prefilter(self):
2293 2298 self.prefilter_manager = PrefilterManager(shell=self, parent=self)
2294 2299 self.configurables.append(self.prefilter_manager)
2295 2300 # Ultimately this will be refactored in the new interpreter code, but
2296 2301 # for now, we should expose the main prefilter method (there's legacy
2297 2302 # code out there that may rely on this).
2298 2303 self.prefilter = self.prefilter_manager.prefilter_lines
2299 2304
2300 2305 def auto_rewrite_input(self, cmd):
2301 2306 """Print to the screen the rewritten form of the user's command.
2302 2307
2303 2308 This shows visual feedback by rewriting input lines that cause
2304 2309 automatic calling to kick in, like::
2305 2310
2306 2311 /f x
2307 2312
2308 2313 into::
2309 2314
2310 2315 ------> f(x)
2311 2316
2312 2317 after the user's input prompt. This helps the user understand that the
2313 2318 input line was transformed automatically by IPython.
2314 2319 """
2315 2320 if not self.show_rewritten_input:
2316 2321 return
2317 2322
2318 2323 # This is overridden in TerminalInteractiveShell to use fancy prompts
2319 2324 print("------> " + cmd)
2320 2325
2321 2326 #-------------------------------------------------------------------------
2322 2327 # Things related to extracting values/expressions from kernel and user_ns
2323 2328 #-------------------------------------------------------------------------
2324 2329
2325 2330 def _user_obj_error(self):
2326 2331 """return simple exception dict
2327 2332
2328 2333 for use in user_expressions
2329 2334 """
2330 2335
2331 2336 etype, evalue, tb = self._get_exc_info()
2332 2337 stb = self.InteractiveTB.get_exception_only(etype, evalue)
2333 2338
2334 2339 exc_info = {
2335 2340 u'status' : 'error',
2336 2341 u'traceback' : stb,
2337 2342 u'ename' : etype.__name__,
2338 2343 u'evalue' : py3compat.safe_unicode(evalue),
2339 2344 }
2340 2345
2341 2346 return exc_info
2342 2347
2343 2348 def _format_user_obj(self, obj):
2344 2349 """format a user object to display dict
2345 2350
2346 2351 for use in user_expressions
2347 2352 """
2348 2353
2349 2354 data, md = self.display_formatter.format(obj)
2350 2355 value = {
2351 2356 'status' : 'ok',
2352 2357 'data' : data,
2353 2358 'metadata' : md,
2354 2359 }
2355 2360 return value
2356 2361
2357 2362 def user_expressions(self, expressions):
2358 2363 """Evaluate a dict of expressions in the user's namespace.
2359 2364
2360 2365 Parameters
2361 2366 ----------
2362 2367 expressions : dict
2363 2368 A dict with string keys and string values. The expression values
2364 2369 should be valid Python expressions, each of which will be evaluated
2365 2370 in the user namespace.
2366 2371
2367 2372 Returns
2368 2373 -------
2369 2374 A dict, keyed like the input expressions dict, with the rich mime-typed
2370 2375 display_data of each value.
2371 2376 """
2372 2377 out = {}
2373 2378 user_ns = self.user_ns
2374 2379 global_ns = self.user_global_ns
2375 2380
2376 2381 for key, expr in expressions.items():
2377 2382 try:
2378 2383 value = self._format_user_obj(eval(expr, global_ns, user_ns))
2379 2384 except:
2380 2385 value = self._user_obj_error()
2381 2386 out[key] = value
2382 2387 return out
2383 2388
2384 2389 #-------------------------------------------------------------------------
2385 2390 # Things related to the running of code
2386 2391 #-------------------------------------------------------------------------
2387 2392
2388 2393 def ex(self, cmd):
2389 2394 """Execute a normal python statement in user namespace."""
2390 2395 with self.builtin_trap:
2391 2396 exec(cmd, self.user_global_ns, self.user_ns)
2392 2397
2393 2398 def ev(self, expr):
2394 2399 """Evaluate python expression expr in user namespace.
2395 2400
2396 2401 Returns the result of evaluation
2397 2402 """
2398 2403 with self.builtin_trap:
2399 2404 return eval(expr, self.user_global_ns, self.user_ns)
2400 2405
2401 2406 def safe_execfile(self, fname, *where, exit_ignore=False, raise_exceptions=False, shell_futures=False):
2402 2407 """A safe version of the builtin execfile().
2403 2408
2404 2409 This version will never throw an exception, but instead print
2405 2410 helpful error messages to the screen. This only works on pure
2406 2411 Python files with the .py extension.
2407 2412
2408 2413 Parameters
2409 2414 ----------
2410 2415 fname : string
2411 2416 The name of the file to be executed.
2412 2417 where : tuple
2413 2418 One or two namespaces, passed to execfile() as (globals,locals).
2414 2419 If only one is given, it is passed as both.
2415 2420 exit_ignore : bool (False)
2416 2421 If True, then silence SystemExit for non-zero status (it is always
2417 2422 silenced for zero status, as it is so common).
2418 2423 raise_exceptions : bool (False)
2419 2424 If True raise exceptions everywhere. Meant for testing.
2420 2425 shell_futures : bool (False)
2421 2426 If True, the code will share future statements with the interactive
2422 2427 shell. It will both be affected by previous __future__ imports, and
2423 2428 any __future__ imports in the code will affect the shell. If False,
2424 2429 __future__ imports are not shared in either direction.
2425 2430
2426 2431 """
2427 2432 fname = os.path.abspath(os.path.expanduser(fname))
2428 2433
2429 2434 # Make sure we can open the file
2430 2435 try:
2431 2436 with open(fname):
2432 2437 pass
2433 2438 except:
2434 2439 warn('Could not open file <%s> for safe execution.' % fname)
2435 2440 return
2436 2441
2437 2442 # Find things also in current directory. This is needed to mimic the
2438 2443 # behavior of running a script from the system command line, where
2439 2444 # Python inserts the script's directory into sys.path
2440 2445 dname = os.path.dirname(fname)
2441 2446
2442 2447 with prepended_to_syspath(dname), self.builtin_trap:
2443 2448 try:
2444 2449 glob, loc = (where + (None, ))[:2]
2445 2450 py3compat.execfile(
2446 2451 fname, glob, loc,
2447 2452 self.compile if shell_futures else None)
2448 2453 except SystemExit as status:
2449 2454 # If the call was made with 0 or None exit status (sys.exit(0)
2450 2455 # or sys.exit() ), don't bother showing a traceback, as both of
2451 2456 # these are considered normal by the OS:
2452 2457 # > python -c'import sys;sys.exit(0)'; echo $?
2453 2458 # 0
2454 2459 # > python -c'import sys;sys.exit()'; echo $?
2455 2460 # 0
2456 2461 # For other exit status, we show the exception unless
2457 2462 # explicitly silenced, but only in short form.
2458 2463 if status.code:
2459 2464 if raise_exceptions:
2460 2465 raise
2461 2466 if not exit_ignore:
2462 2467 self.showtraceback(exception_only=True)
2463 2468 except:
2464 2469 if raise_exceptions:
2465 2470 raise
2466 2471 # tb offset is 2 because we wrap execfile
2467 2472 self.showtraceback(tb_offset=2)
2468 2473
2469 2474 def safe_execfile_ipy(self, fname, shell_futures=False, raise_exceptions=False):
2470 2475 """Like safe_execfile, but for .ipy or .ipynb files with IPython syntax.
2471 2476
2472 2477 Parameters
2473 2478 ----------
2474 2479 fname : str
2475 2480 The name of the file to execute. The filename must have a
2476 2481 .ipy or .ipynb extension.
2477 2482 shell_futures : bool (False)
2478 2483 If True, the code will share future statements with the interactive
2479 2484 shell. It will both be affected by previous __future__ imports, and
2480 2485 any __future__ imports in the code will affect the shell. If False,
2481 2486 __future__ imports are not shared in either direction.
2482 2487 raise_exceptions : bool (False)
2483 2488 If True raise exceptions everywhere. Meant for testing.
2484 2489 """
2485 2490 fname = os.path.abspath(os.path.expanduser(fname))
2486 2491
2487 2492 # Make sure we can open the file
2488 2493 try:
2489 2494 with open(fname):
2490 2495 pass
2491 2496 except:
2492 2497 warn('Could not open file <%s> for safe execution.' % fname)
2493 2498 return
2494 2499
2495 2500 # Find things also in current directory. This is needed to mimic the
2496 2501 # behavior of running a script from the system command line, where
2497 2502 # Python inserts the script's directory into sys.path
2498 2503 dname = os.path.dirname(fname)
2499 2504
2500 2505 def get_cells():
2501 2506 """generator for sequence of code blocks to run"""
2502 2507 if fname.endswith('.ipynb'):
2503 2508 from nbformat import read
2504 2509 with io_open(fname) as f:
2505 2510 nb = read(f, as_version=4)
2506 2511 if not nb.cells:
2507 2512 return
2508 2513 for cell in nb.cells:
2509 2514 if cell.cell_type == 'code':
2510 2515 yield cell.source
2511 2516 else:
2512 2517 with open(fname) as f:
2513 2518 yield f.read()
2514 2519
2515 2520 with prepended_to_syspath(dname):
2516 2521 try:
2517 2522 for cell in get_cells():
2518 2523 result = self.run_cell(cell, silent=True, shell_futures=shell_futures)
2519 2524 if raise_exceptions:
2520 2525 result.raise_error()
2521 2526 elif not result.success:
2522 2527 break
2523 2528 except:
2524 2529 if raise_exceptions:
2525 2530 raise
2526 2531 self.showtraceback()
2527 2532 warn('Unknown failure executing file: <%s>' % fname)
2528 2533
2529 2534 def safe_run_module(self, mod_name, where):
2530 2535 """A safe version of runpy.run_module().
2531 2536
2532 2537 This version will never throw an exception, but instead print
2533 2538 helpful error messages to the screen.
2534 2539
2535 2540 `SystemExit` exceptions with status code 0 or None are ignored.
2536 2541
2537 2542 Parameters
2538 2543 ----------
2539 2544 mod_name : string
2540 2545 The name of the module to be executed.
2541 2546 where : dict
2542 2547 The globals namespace.
2543 2548 """
2544 2549 try:
2545 2550 try:
2546 2551 where.update(
2547 2552 runpy.run_module(str(mod_name), run_name="__main__",
2548 2553 alter_sys=True)
2549 2554 )
2550 2555 except SystemExit as status:
2551 2556 if status.code:
2552 2557 raise
2553 2558 except:
2554 2559 self.showtraceback()
2555 2560 warn('Unknown failure executing module: <%s>' % mod_name)
2556 2561
2557 2562 def run_cell(self, raw_cell, store_history=False, silent=False, shell_futures=True):
2558 2563 """Run a complete IPython cell.
2559 2564
2560 2565 Parameters
2561 2566 ----------
2562 2567 raw_cell : str
2563 2568 The code (including IPython code such as %magic functions) to run.
2564 2569 store_history : bool
2565 2570 If True, the raw and translated cell will be stored in IPython's
2566 2571 history. For user code calling back into IPython's machinery, this
2567 2572 should be set to False.
2568 2573 silent : bool
2569 2574 If True, avoid side-effects, such as implicit displayhooks and
2570 2575 and logging. silent=True forces store_history=False.
2571 2576 shell_futures : bool
2572 2577 If True, the code will share future statements with the interactive
2573 2578 shell. It will both be affected by previous __future__ imports, and
2574 2579 any __future__ imports in the code will affect the shell. If False,
2575 2580 __future__ imports are not shared in either direction.
2576 2581
2577 2582 Returns
2578 2583 -------
2579 2584 result : :class:`ExecutionResult`
2580 2585 """
2581 2586 result = ExecutionResult()
2582 2587
2583 2588 if (not raw_cell) or raw_cell.isspace():
2584 2589 self.last_execution_succeeded = True
2585 2590 return result
2586 2591
2587 2592 if silent:
2588 2593 store_history = False
2589 2594
2590 2595 if store_history:
2591 2596 result.execution_count = self.execution_count
2592 2597
2593 2598 def error_before_exec(value):
2594 2599 result.error_before_exec = value
2595 2600 self.last_execution_succeeded = False
2596 2601 return result
2597 2602
2598 2603 self.events.trigger('pre_execute')
2599 2604 if not silent:
2600 2605 self.events.trigger('pre_run_cell')
2601 2606
2602 2607 # If any of our input transformation (input_transformer_manager or
2603 2608 # prefilter_manager) raises an exception, we store it in this variable
2604 2609 # so that we can display the error after logging the input and storing
2605 2610 # it in the history.
2606 2611 preprocessing_exc_tuple = None
2607 2612 try:
2608 2613 # Static input transformations
2609 2614 cell = self.input_transformer_manager.transform_cell(raw_cell)
2610 2615 except SyntaxError:
2611 2616 preprocessing_exc_tuple = sys.exc_info()
2612 2617 cell = raw_cell # cell has to exist so it can be stored/logged
2613 2618 else:
2614 2619 if len(cell.splitlines()) == 1:
2615 2620 # Dynamic transformations - only applied for single line commands
2616 2621 with self.builtin_trap:
2617 2622 try:
2618 2623 # use prefilter_lines to handle trailing newlines
2619 2624 # restore trailing newline for ast.parse
2620 2625 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
2621 2626 except Exception:
2622 2627 # don't allow prefilter errors to crash IPython
2623 2628 preprocessing_exc_tuple = sys.exc_info()
2624 2629
2625 2630 # Store raw and processed history
2626 2631 if store_history:
2627 2632 self.history_manager.store_inputs(self.execution_count,
2628 2633 cell, raw_cell)
2629 2634 if not silent:
2630 2635 self.logger.log(cell, raw_cell)
2631 2636
2632 2637 # Display the exception if input processing failed.
2633 2638 if preprocessing_exc_tuple is not None:
2634 2639 self.showtraceback(preprocessing_exc_tuple)
2635 2640 if store_history:
2636 2641 self.execution_count += 1
2637 2642 return error_before_exec(preprocessing_exc_tuple[2])
2638 2643
2639 2644 # Our own compiler remembers the __future__ environment. If we want to
2640 2645 # run code with a separate __future__ environment, use the default
2641 2646 # compiler
2642 2647 compiler = self.compile if shell_futures else CachingCompiler()
2643 2648
2644 2649 with self.builtin_trap:
2645 2650 cell_name = self.compile.cache(cell, self.execution_count)
2646 2651
2647 2652 with self.display_trap:
2648 2653 # Compile to bytecode
2649 2654 try:
2650 2655 code_ast = compiler.ast_parse(cell, filename=cell_name)
2651 2656 except self.custom_exceptions as e:
2652 2657 etype, value, tb = sys.exc_info()
2653 2658 self.CustomTB(etype, value, tb)
2654 2659 return error_before_exec(e)
2655 2660 except IndentationError as e:
2656 2661 self.showindentationerror()
2657 2662 if store_history:
2658 2663 self.execution_count += 1
2659 2664 return error_before_exec(e)
2660 2665 except (OverflowError, SyntaxError, ValueError, TypeError,
2661 2666 MemoryError) as e:
2662 2667 self.showsyntaxerror()
2663 2668 if store_history:
2664 2669 self.execution_count += 1
2665 2670 return error_before_exec(e)
2666 2671
2667 2672 # Apply AST transformations
2668 2673 try:
2669 2674 code_ast = self.transform_ast(code_ast)
2670 2675 except InputRejected as e:
2671 2676 self.showtraceback()
2672 2677 if store_history:
2673 2678 self.execution_count += 1
2674 2679 return error_before_exec(e)
2675 2680
2676 2681 # Give the displayhook a reference to our ExecutionResult so it
2677 2682 # can fill in the output value.
2678 2683 self.displayhook.exec_result = result
2679 2684
2680 2685 # Execute the user code
2681 2686 interactivity = "none" if silent else self.ast_node_interactivity
2682 2687 has_raised = self.run_ast_nodes(code_ast.body, cell_name,
2683 2688 interactivity=interactivity, compiler=compiler, result=result)
2684 2689
2685 2690 self.last_execution_succeeded = not has_raised
2686 2691
2687 2692 # Reset this so later displayed values do not modify the
2688 2693 # ExecutionResult
2689 2694 self.displayhook.exec_result = None
2690 2695
2691 2696 self.events.trigger('post_execute')
2692 2697 if not silent:
2693 2698 self.events.trigger('post_run_cell')
2694 2699
2695 2700 if store_history:
2696 2701 # Write output to the database. Does nothing unless
2697 2702 # history output logging is enabled.
2698 2703 self.history_manager.store_output(self.execution_count)
2699 2704 # Each cell is a *single* input, regardless of how many lines it has
2700 2705 self.execution_count += 1
2701 2706
2702 2707 return result
2703 2708
2704 2709 def transform_ast(self, node):
2705 2710 """Apply the AST transformations from self.ast_transformers
2706 2711
2707 2712 Parameters
2708 2713 ----------
2709 2714 node : ast.Node
2710 2715 The root node to be transformed. Typically called with the ast.Module
2711 2716 produced by parsing user input.
2712 2717
2713 2718 Returns
2714 2719 -------
2715 2720 An ast.Node corresponding to the node it was called with. Note that it
2716 2721 may also modify the passed object, so don't rely on references to the
2717 2722 original AST.
2718 2723 """
2719 2724 for transformer in self.ast_transformers:
2720 2725 try:
2721 2726 node = transformer.visit(node)
2722 2727 except InputRejected:
2723 2728 # User-supplied AST transformers can reject an input by raising
2724 2729 # an InputRejected. Short-circuit in this case so that we
2725 2730 # don't unregister the transform.
2726 2731 raise
2727 2732 except Exception:
2728 2733 warn("AST transformer %r threw an error. It will be unregistered." % transformer)
2729 2734 self.ast_transformers.remove(transformer)
2730 2735
2731 2736 if self.ast_transformers:
2732 2737 ast.fix_missing_locations(node)
2733 2738 return node
2734 2739
2735 2740
2736 2741 def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr',
2737 2742 compiler=compile, result=None):
2738 2743 """Run a sequence of AST nodes. The execution mode depends on the
2739 2744 interactivity parameter.
2740 2745
2741 2746 Parameters
2742 2747 ----------
2743 2748 nodelist : list
2744 2749 A sequence of AST nodes to run.
2745 2750 cell_name : str
2746 2751 Will be passed to the compiler as the filename of the cell. Typically
2747 2752 the value returned by ip.compile.cache(cell).
2748 2753 interactivity : str
2749 2754 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
2750 2755 run interactively (displaying output from expressions). 'last_expr'
2751 2756 will run the last node interactively only if it is an expression (i.e.
2752 2757 expressions in loops or other blocks are not displayed. Other values
2753 2758 for this parameter will raise a ValueError.
2754 2759 compiler : callable
2755 2760 A function with the same interface as the built-in compile(), to turn
2756 2761 the AST nodes into code objects. Default is the built-in compile().
2757 2762 result : ExecutionResult, optional
2758 2763 An object to store exceptions that occur during execution.
2759 2764
2760 2765 Returns
2761 2766 -------
2762 2767 True if an exception occurred while running code, False if it finished
2763 2768 running.
2764 2769 """
2765 2770 if not nodelist:
2766 2771 return
2767 2772
2768 2773 if interactivity == 'last_expr':
2769 2774 if isinstance(nodelist[-1], ast.Expr):
2770 2775 interactivity = "last"
2771 2776 else:
2772 2777 interactivity = "none"
2773 2778
2774 2779 if interactivity == 'none':
2775 2780 to_run_exec, to_run_interactive = nodelist, []
2776 2781 elif interactivity == 'last':
2777 2782 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
2778 2783 elif interactivity == 'all':
2779 2784 to_run_exec, to_run_interactive = [], nodelist
2780 2785 else:
2781 2786 raise ValueError("Interactivity was %r" % interactivity)
2782 2787
2783 2788 try:
2784 2789 for i, node in enumerate(to_run_exec):
2785 2790 mod = ast.Module([node])
2786 2791 code = compiler(mod, cell_name, "exec")
2787 2792 if self.run_code(code, result):
2788 2793 return True
2789 2794
2790 2795 for i, node in enumerate(to_run_interactive):
2791 2796 mod = ast.Interactive([node])
2792 2797 code = compiler(mod, cell_name, "single")
2793 2798 if self.run_code(code, result):
2794 2799 return True
2795 2800
2796 2801 # Flush softspace
2797 2802 if softspace(sys.stdout, 0):
2798 2803 print()
2799 2804
2800 2805 except:
2801 2806 # It's possible to have exceptions raised here, typically by
2802 2807 # compilation of odd code (such as a naked 'return' outside a
2803 2808 # function) that did parse but isn't valid. Typically the exception
2804 2809 # is a SyntaxError, but it's safest just to catch anything and show
2805 2810 # the user a traceback.
2806 2811
2807 2812 # We do only one try/except outside the loop to minimize the impact
2808 2813 # on runtime, and also because if any node in the node list is
2809 2814 # broken, we should stop execution completely.
2810 2815 if result:
2811 2816 result.error_before_exec = sys.exc_info()[1]
2812 2817 self.showtraceback()
2813 2818 return True
2814 2819
2815 2820 return False
2816 2821
2817 2822 def run_code(self, code_obj, result=None):
2818 2823 """Execute a code object.
2819 2824
2820 2825 When an exception occurs, self.showtraceback() is called to display a
2821 2826 traceback.
2822 2827
2823 2828 Parameters
2824 2829 ----------
2825 2830 code_obj : code object
2826 2831 A compiled code object, to be executed
2827 2832 result : ExecutionResult, optional
2828 2833 An object to store exceptions that occur during execution.
2829 2834
2830 2835 Returns
2831 2836 -------
2832 2837 False : successful execution.
2833 2838 True : an error occurred.
2834 2839 """
2835 2840 # Set our own excepthook in case the user code tries to call it
2836 2841 # directly, so that the IPython crash handler doesn't get triggered
2837 2842 old_excepthook, sys.excepthook = sys.excepthook, self.excepthook
2838 2843
2839 2844 # we save the original sys.excepthook in the instance, in case config
2840 2845 # code (such as magics) needs access to it.
2841 2846 self.sys_excepthook = old_excepthook
2842 2847 outflag = True # happens in more places, so it's easier as default
2843 2848 try:
2844 2849 try:
2845 2850 self.hooks.pre_run_code_hook()
2846 2851 #rprint('Running code', repr(code_obj)) # dbg
2847 2852 exec(code_obj, self.user_global_ns, self.user_ns)
2848 2853 finally:
2849 2854 # Reset our crash handler in place
2850 2855 sys.excepthook = old_excepthook
2851 2856 except SystemExit as e:
2852 2857 if result is not None:
2853 2858 result.error_in_exec = e
2854 2859 self.showtraceback(exception_only=True)
2855 2860 warn("To exit: use 'exit', 'quit', or Ctrl-D.", stacklevel=1)
2856 2861 except self.custom_exceptions:
2857 2862 etype, value, tb = sys.exc_info()
2858 2863 if result is not None:
2859 2864 result.error_in_exec = value
2860 2865 self.CustomTB(etype, value, tb)
2861 2866 except:
2862 2867 if result is not None:
2863 2868 result.error_in_exec = sys.exc_info()[1]
2864 self.showtraceback()
2869 self.showtraceback(running_compiled_code=True)
2865 2870 else:
2866 2871 outflag = False
2867 2872 return outflag
2868 2873
2869 2874 # For backwards compatibility
2870 2875 runcode = run_code
2871 2876
2872 2877 #-------------------------------------------------------------------------
2873 2878 # Things related to GUI support and pylab
2874 2879 #-------------------------------------------------------------------------
2875 2880
2876 2881 active_eventloop = None
2877 2882
2878 2883 def enable_gui(self, gui=None):
2879 2884 raise NotImplementedError('Implement enable_gui in a subclass')
2880 2885
2881 2886 def enable_matplotlib(self, gui=None):
2882 2887 """Enable interactive matplotlib and inline figure support.
2883 2888
2884 2889 This takes the following steps:
2885 2890
2886 2891 1. select the appropriate eventloop and matplotlib backend
2887 2892 2. set up matplotlib for interactive use with that backend
2888 2893 3. configure formatters for inline figure display
2889 2894 4. enable the selected gui eventloop
2890 2895
2891 2896 Parameters
2892 2897 ----------
2893 2898 gui : optional, string
2894 2899 If given, dictates the choice of matplotlib GUI backend to use
2895 2900 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
2896 2901 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
2897 2902 matplotlib (as dictated by the matplotlib build-time options plus the
2898 2903 user's matplotlibrc configuration file). Note that not all backends
2899 2904 make sense in all contexts, for example a terminal ipython can't
2900 2905 display figures inline.
2901 2906 """
2902 2907 from IPython.core import pylabtools as pt
2903 2908 gui, backend = pt.find_gui_and_backend(gui, self.pylab_gui_select)
2904 2909
2905 2910 if gui != 'inline':
2906 2911 # If we have our first gui selection, store it
2907 2912 if self.pylab_gui_select is None:
2908 2913 self.pylab_gui_select = gui
2909 2914 # Otherwise if they are different
2910 2915 elif gui != self.pylab_gui_select:
2911 2916 print ('Warning: Cannot change to a different GUI toolkit: %s.'
2912 2917 ' Using %s instead.' % (gui, self.pylab_gui_select))
2913 2918 gui, backend = pt.find_gui_and_backend(self.pylab_gui_select)
2914 2919
2915 2920 pt.activate_matplotlib(backend)
2916 2921 pt.configure_inline_support(self, backend)
2917 2922
2918 2923 # Now we must activate the gui pylab wants to use, and fix %run to take
2919 2924 # plot updates into account
2920 2925 self.enable_gui(gui)
2921 2926 self.magics_manager.registry['ExecutionMagics'].default_runner = \
2922 2927 pt.mpl_runner(self.safe_execfile)
2923 2928
2924 2929 return gui, backend
2925 2930
2926 2931 def enable_pylab(self, gui=None, import_all=True, welcome_message=False):
2927 2932 """Activate pylab support at runtime.
2928 2933
2929 2934 This turns on support for matplotlib, preloads into the interactive
2930 2935 namespace all of numpy and pylab, and configures IPython to correctly
2931 2936 interact with the GUI event loop. The GUI backend to be used can be
2932 2937 optionally selected with the optional ``gui`` argument.
2933 2938
2934 2939 This method only adds preloading the namespace to InteractiveShell.enable_matplotlib.
2935 2940
2936 2941 Parameters
2937 2942 ----------
2938 2943 gui : optional, string
2939 2944 If given, dictates the choice of matplotlib GUI backend to use
2940 2945 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
2941 2946 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
2942 2947 matplotlib (as dictated by the matplotlib build-time options plus the
2943 2948 user's matplotlibrc configuration file). Note that not all backends
2944 2949 make sense in all contexts, for example a terminal ipython can't
2945 2950 display figures inline.
2946 2951 import_all : optional, bool, default: True
2947 2952 Whether to do `from numpy import *` and `from pylab import *`
2948 2953 in addition to module imports.
2949 2954 welcome_message : deprecated
2950 2955 This argument is ignored, no welcome message will be displayed.
2951 2956 """
2952 2957 from IPython.core.pylabtools import import_pylab
2953 2958
2954 2959 gui, backend = self.enable_matplotlib(gui)
2955 2960
2956 2961 # We want to prevent the loading of pylab to pollute the user's
2957 2962 # namespace as shown by the %who* magics, so we execute the activation
2958 2963 # code in an empty namespace, and we update *both* user_ns and
2959 2964 # user_ns_hidden with this information.
2960 2965 ns = {}
2961 2966 import_pylab(ns, import_all)
2962 2967 # warn about clobbered names
2963 2968 ignored = {"__builtins__"}
2964 2969 both = set(ns).intersection(self.user_ns).difference(ignored)
2965 2970 clobbered = [ name for name in both if self.user_ns[name] is not ns[name] ]
2966 2971 self.user_ns.update(ns)
2967 2972 self.user_ns_hidden.update(ns)
2968 2973 return gui, backend, clobbered
2969 2974
2970 2975 #-------------------------------------------------------------------------
2971 2976 # Utilities
2972 2977 #-------------------------------------------------------------------------
2973 2978
2974 2979 def var_expand(self, cmd, depth=0, formatter=DollarFormatter()):
2975 2980 """Expand python variables in a string.
2976 2981
2977 2982 The depth argument indicates how many frames above the caller should
2978 2983 be walked to look for the local namespace where to expand variables.
2979 2984
2980 2985 The global namespace for expansion is always the user's interactive
2981 2986 namespace.
2982 2987 """
2983 2988 ns = self.user_ns.copy()
2984 2989 try:
2985 2990 frame = sys._getframe(depth+1)
2986 2991 except ValueError:
2987 2992 # This is thrown if there aren't that many frames on the stack,
2988 2993 # e.g. if a script called run_line_magic() directly.
2989 2994 pass
2990 2995 else:
2991 2996 ns.update(frame.f_locals)
2992 2997
2993 2998 try:
2994 2999 # We have to use .vformat() here, because 'self' is a valid and common
2995 3000 # name, and expanding **ns for .format() would make it collide with
2996 3001 # the 'self' argument of the method.
2997 3002 cmd = formatter.vformat(cmd, args=[], kwargs=ns)
2998 3003 except Exception:
2999 3004 # if formatter couldn't format, just let it go untransformed
3000 3005 pass
3001 3006 return cmd
3002 3007
3003 3008 def mktempfile(self, data=None, prefix='ipython_edit_'):
3004 3009 """Make a new tempfile and return its filename.
3005 3010
3006 3011 This makes a call to tempfile.mkstemp (created in a tempfile.mkdtemp),
3007 3012 but it registers the created filename internally so ipython cleans it up
3008 3013 at exit time.
3009 3014
3010 3015 Optional inputs:
3011 3016
3012 3017 - data(None): if data is given, it gets written out to the temp file
3013 3018 immediately, and the file is closed again."""
3014 3019
3015 3020 dirname = tempfile.mkdtemp(prefix=prefix)
3016 3021 self.tempdirs.append(dirname)
3017 3022
3018 3023 handle, filename = tempfile.mkstemp('.py', prefix, dir=dirname)
3019 3024 os.close(handle) # On Windows, there can only be one open handle on a file
3020 3025 self.tempfiles.append(filename)
3021 3026
3022 3027 if data:
3023 3028 tmp_file = open(filename,'w')
3024 3029 tmp_file.write(data)
3025 3030 tmp_file.close()
3026 3031 return filename
3027 3032
3028 3033 @undoc
3029 3034 def write(self,data):
3030 3035 """DEPRECATED: Write a string to the default output"""
3031 3036 warn('InteractiveShell.write() is deprecated, use sys.stdout instead',
3032 3037 DeprecationWarning, stacklevel=2)
3033 3038 sys.stdout.write(data)
3034 3039
3035 3040 @undoc
3036 3041 def write_err(self,data):
3037 3042 """DEPRECATED: Write a string to the default error output"""
3038 3043 warn('InteractiveShell.write_err() is deprecated, use sys.stderr instead',
3039 3044 DeprecationWarning, stacklevel=2)
3040 3045 sys.stderr.write(data)
3041 3046
3042 3047 def ask_yes_no(self, prompt, default=None, interrupt=None):
3043 3048 if self.quiet:
3044 3049 return True
3045 3050 return ask_yes_no(prompt,default,interrupt)
3046 3051
3047 3052 def show_usage(self):
3048 3053 """Show a usage message"""
3049 3054 page.page(IPython.core.usage.interactive_usage)
3050 3055
3051 3056 def extract_input_lines(self, range_str, raw=False):
3052 3057 """Return as a string a set of input history slices.
3053 3058
3054 3059 Parameters
3055 3060 ----------
3056 3061 range_str : string
3057 3062 The set of slices is given as a string, like "~5/6-~4/2 4:8 9",
3058 3063 since this function is for use by magic functions which get their
3059 3064 arguments as strings. The number before the / is the session
3060 3065 number: ~n goes n back from the current session.
3061 3066
3062 3067 raw : bool, optional
3063 3068 By default, the processed input is used. If this is true, the raw
3064 3069 input history is used instead.
3065 3070
3066 3071 Notes
3067 3072 -----
3068 3073
3069 3074 Slices can be described with two notations:
3070 3075
3071 3076 * ``N:M`` -> standard python form, means including items N...(M-1).
3072 3077 * ``N-M`` -> include items N..M (closed endpoint).
3073 3078 """
3074 3079 lines = self.history_manager.get_range_by_str(range_str, raw=raw)
3075 3080 return "\n".join(x for _, _, x in lines)
3076 3081
3077 3082 def find_user_code(self, target, raw=True, py_only=False, skip_encoding_cookie=True, search_ns=False):
3078 3083 """Get a code string from history, file, url, or a string or macro.
3079 3084
3080 3085 This is mainly used by magic functions.
3081 3086
3082 3087 Parameters
3083 3088 ----------
3084 3089
3085 3090 target : str
3086 3091
3087 3092 A string specifying code to retrieve. This will be tried respectively
3088 3093 as: ranges of input history (see %history for syntax), url,
3089 3094 corresponding .py file, filename, or an expression evaluating to a
3090 3095 string or Macro in the user namespace.
3091 3096
3092 3097 raw : bool
3093 3098 If true (default), retrieve raw history. Has no effect on the other
3094 3099 retrieval mechanisms.
3095 3100
3096 3101 py_only : bool (default False)
3097 3102 Only try to fetch python code, do not try alternative methods to decode file
3098 3103 if unicode fails.
3099 3104
3100 3105 Returns
3101 3106 -------
3102 3107 A string of code.
3103 3108
3104 3109 ValueError is raised if nothing is found, and TypeError if it evaluates
3105 3110 to an object of another type. In each case, .args[0] is a printable
3106 3111 message.
3107 3112 """
3108 3113 code = self.extract_input_lines(target, raw=raw) # Grab history
3109 3114 if code:
3110 3115 return code
3111 3116 try:
3112 3117 if target.startswith(('http://', 'https://')):
3113 3118 return openpy.read_py_url(target, skip_encoding_cookie=skip_encoding_cookie)
3114 3119 except UnicodeDecodeError:
3115 3120 if not py_only :
3116 3121 # Deferred import
3117 3122 from urllib.request import urlopen
3118 3123 response = urlopen(target)
3119 3124 return response.read().decode('latin1')
3120 3125 raise ValueError(("'%s' seem to be unreadable.") % target)
3121 3126
3122 3127 potential_target = [target]
3123 3128 try :
3124 3129 potential_target.insert(0,get_py_filename(target))
3125 3130 except IOError:
3126 3131 pass
3127 3132
3128 3133 for tgt in potential_target :
3129 3134 if os.path.isfile(tgt): # Read file
3130 3135 try :
3131 3136 return openpy.read_py_file(tgt, skip_encoding_cookie=skip_encoding_cookie)
3132 3137 except UnicodeDecodeError :
3133 3138 if not py_only :
3134 3139 with io_open(tgt,'r', encoding='latin1') as f :
3135 3140 return f.read()
3136 3141 raise ValueError(("'%s' seem to be unreadable.") % target)
3137 3142 elif os.path.isdir(os.path.expanduser(tgt)):
3138 3143 raise ValueError("'%s' is a directory, not a regular file." % target)
3139 3144
3140 3145 if search_ns:
3141 3146 # Inspect namespace to load object source
3142 3147 object_info = self.object_inspect(target, detail_level=1)
3143 3148 if object_info['found'] and object_info['source']:
3144 3149 return object_info['source']
3145 3150
3146 3151 try: # User namespace
3147 3152 codeobj = eval(target, self.user_ns)
3148 3153 except Exception:
3149 3154 raise ValueError(("'%s' was not found in history, as a file, url, "
3150 3155 "nor in the user namespace.") % target)
3151 3156
3152 3157 if isinstance(codeobj, str):
3153 3158 return codeobj
3154 3159 elif isinstance(codeobj, Macro):
3155 3160 return codeobj.value
3156 3161
3157 3162 raise TypeError("%s is neither a string nor a macro." % target,
3158 3163 codeobj)
3159 3164
3160 3165 #-------------------------------------------------------------------------
3161 3166 # Things related to IPython exiting
3162 3167 #-------------------------------------------------------------------------
3163 3168 def atexit_operations(self):
3164 3169 """This will be executed at the time of exit.
3165 3170
3166 3171 Cleanup operations and saving of persistent data that is done
3167 3172 unconditionally by IPython should be performed here.
3168 3173
3169 3174 For things that may depend on startup flags or platform specifics (such
3170 3175 as having readline or not), register a separate atexit function in the
3171 3176 code that has the appropriate information, rather than trying to
3172 3177 clutter
3173 3178 """
3174 3179 # Close the history session (this stores the end time and line count)
3175 3180 # this must be *before* the tempfile cleanup, in case of temporary
3176 3181 # history db
3177 3182 self.history_manager.end_session()
3178 3183
3179 3184 # Cleanup all tempfiles and folders left around
3180 3185 for tfile in self.tempfiles:
3181 3186 try:
3182 3187 os.unlink(tfile)
3183 3188 except OSError:
3184 3189 pass
3185 3190
3186 3191 for tdir in self.tempdirs:
3187 3192 try:
3188 3193 os.rmdir(tdir)
3189 3194 except OSError:
3190 3195 pass
3191 3196
3192 3197 # Clear all user namespaces to release all references cleanly.
3193 3198 self.reset(new_session=False)
3194 3199
3195 3200 # Run user hooks
3196 3201 self.hooks.shutdown_hook()
3197 3202
3198 3203 def cleanup(self):
3199 3204 self.restore_sys_module_state()
3200 3205
3201 3206
3202 3207 # Overridden in terminal subclass to change prompts
3203 3208 def switch_doctest_mode(self, mode):
3204 3209 pass
3205 3210
3206 3211
3207 3212 class InteractiveShellABC(metaclass=abc.ABCMeta):
3208 3213 """An abstract base class for InteractiveShell."""
3209 3214
3210 3215 InteractiveShellABC.register(InteractiveShell)
@@ -1,347 +1,374 b''
1 1 # encoding: utf-8
2 2 """Tests for IPython.core.ultratb
3 3 """
4 4 import io
5 5 import sys
6 6 import os.path
7 7 from textwrap import dedent
8 8 import traceback
9 9 import unittest
10 10 from unittest import mock
11 11
12 12 from ..ultratb import ColorTB, VerboseTB, find_recursion
13 13
14 14
15 15 from IPython.testing import tools as tt
16 16 from IPython.testing.decorators import onlyif_unicode_paths
17 17 from IPython.utils.syspathcontext import prepended_to_syspath
18 18 from IPython.utils.tempdir import TemporaryDirectory
19 19
20 20 ip = get_ipython()
21 21
22 22 file_1 = """1
23 23 2
24 24 3
25 25 def f():
26 26 1/0
27 27 """
28 28
29 29 file_2 = """def f():
30 30 1/0
31 31 """
32 32
33 33 class ChangedPyFileTest(unittest.TestCase):
34 34 def test_changing_py_file(self):
35 35 """Traceback produced if the line where the error occurred is missing?
36 36
37 37 https://github.com/ipython/ipython/issues/1456
38 38 """
39 39 with TemporaryDirectory() as td:
40 40 fname = os.path.join(td, "foo.py")
41 41 with open(fname, "w") as f:
42 42 f.write(file_1)
43 43
44 44 with prepended_to_syspath(td):
45 45 ip.run_cell("import foo")
46 46
47 47 with tt.AssertPrints("ZeroDivisionError"):
48 48 ip.run_cell("foo.f()")
49 49
50 50 # Make the file shorter, so the line of the error is missing.
51 51 with open(fname, "w") as f:
52 52 f.write(file_2)
53 53
54 54 # For some reason, this was failing on the *second* call after
55 55 # changing the file, so we call f() twice.
56 56 with tt.AssertNotPrints("Internal Python error", channel='stderr'):
57 57 with tt.AssertPrints("ZeroDivisionError"):
58 58 ip.run_cell("foo.f()")
59 59 with tt.AssertPrints("ZeroDivisionError"):
60 60 ip.run_cell("foo.f()")
61 61
62 62 iso_8859_5_file = u'''# coding: iso-8859-5
63 63
64 64 def fail():
65 65 """Π΄Π±Π˜Π–"""
66 66 1/0 # Π΄Π±Π˜Π–
67 67 '''
68 68
69 69 class NonAsciiTest(unittest.TestCase):
70 70 @onlyif_unicode_paths
71 71 def test_nonascii_path(self):
72 72 # Non-ascii directory name as well.
73 73 with TemporaryDirectory(suffix=u'Γ©') as td:
74 74 fname = os.path.join(td, u"fooΓ©.py")
75 75 with open(fname, "w") as f:
76 76 f.write(file_1)
77 77
78 78 with prepended_to_syspath(td):
79 79 ip.run_cell("import foo")
80 80
81 81 with tt.AssertPrints("ZeroDivisionError"):
82 82 ip.run_cell("foo.f()")
83 83
84 84 def test_iso8859_5(self):
85 85 with TemporaryDirectory() as td:
86 86 fname = os.path.join(td, 'dfghjkl.py')
87 87
88 88 with io.open(fname, 'w', encoding='iso-8859-5') as f:
89 89 f.write(iso_8859_5_file)
90 90
91 91 with prepended_to_syspath(td):
92 92 ip.run_cell("from dfghjkl import fail")
93 93
94 94 with tt.AssertPrints("ZeroDivisionError"):
95 95 with tt.AssertPrints(u'Π΄Π±Π˜Π–', suppress=False):
96 96 ip.run_cell('fail()')
97 97
98 98 def test_nonascii_msg(self):
99 99 cell = u"raise Exception('Γ©')"
100 100 expected = u"Exception('Γ©')"
101 101 ip.run_cell("%xmode plain")
102 102 with tt.AssertPrints(expected):
103 103 ip.run_cell(cell)
104 104
105 105 ip.run_cell("%xmode verbose")
106 106 with tt.AssertPrints(expected):
107 107 ip.run_cell(cell)
108 108
109 109 ip.run_cell("%xmode context")
110 110 with tt.AssertPrints(expected):
111 111 ip.run_cell(cell)
112 112
113 113
114 114 class NestedGenExprTestCase(unittest.TestCase):
115 115 """
116 116 Regression test for the following issues:
117 117 https://github.com/ipython/ipython/issues/8293
118 118 https://github.com/ipython/ipython/issues/8205
119 119 """
120 120 def test_nested_genexpr(self):
121 121 code = dedent(
122 122 """\
123 123 class SpecificException(Exception):
124 124 pass
125 125
126 126 def foo(x):
127 127 raise SpecificException("Success!")
128 128
129 129 sum(sum(foo(x) for _ in [0]) for x in [0])
130 130 """
131 131 )
132 132 with tt.AssertPrints('SpecificException: Success!', suppress=False):
133 133 ip.run_cell(code)
134 134
135 135
136 136 indentationerror_file = """if True:
137 137 zoon()
138 138 """
139 139
140 140 class IndentationErrorTest(unittest.TestCase):
141 141 def test_indentationerror_shows_line(self):
142 142 # See issue gh-2398
143 143 with tt.AssertPrints("IndentationError"):
144 144 with tt.AssertPrints("zoon()", suppress=False):
145 145 ip.run_cell(indentationerror_file)
146 146
147 147 with TemporaryDirectory() as td:
148 148 fname = os.path.join(td, "foo.py")
149 149 with open(fname, "w") as f:
150 150 f.write(indentationerror_file)
151 151
152 152 with tt.AssertPrints("IndentationError"):
153 153 with tt.AssertPrints("zoon()", suppress=False):
154 154 ip.magic('run %s' % fname)
155 155
156 156 se_file_1 = """1
157 157 2
158 158 7/
159 159 """
160 160
161 161 se_file_2 = """7/
162 162 """
163 163
164 164 class SyntaxErrorTest(unittest.TestCase):
165 165 def test_syntaxerror_without_lineno(self):
166 166 with tt.AssertNotPrints("TypeError"):
167 167 with tt.AssertPrints("line unknown"):
168 168 ip.run_cell("raise SyntaxError()")
169 169
170 def test_syntaxerror_no_stacktrace_at_compile_time(self):
171 syntax_error_at_compile_time = """
172 def foo():
173 ..
174 """
175 with tt.AssertPrints("SyntaxError"):
176 ip.run_cell(syntax_error_at_compile_time)
177
178 with tt.AssertNotPrints("foo()"):
179 ip.run_cell(syntax_error_at_compile_time)
180
181 def test_syntaxerror_stacktrace_when_running_compiled_code(self):
182 syntax_error_at_runtime = """
183 def foo():
184 eval("..")
185
186 def bar():
187 foo()
188
189 bar()
190 """
191 with tt.AssertPrints("SyntaxError"):
192 ip.run_cell(syntax_error_at_runtime)
193 # Assert syntax error during runtime generate stacktrace
194 with tt.AssertPrints(["foo()", "bar()"]):
195 ip.run_cell(syntax_error_at_runtime)
196
170 197 def test_changing_py_file(self):
171 198 with TemporaryDirectory() as td:
172 199 fname = os.path.join(td, "foo.py")
173 200 with open(fname, 'w') as f:
174 201 f.write(se_file_1)
175 202
176 203 with tt.AssertPrints(["7/", "SyntaxError"]):
177 204 ip.magic("run " + fname)
178 205
179 206 # Modify the file
180 207 with open(fname, 'w') as f:
181 208 f.write(se_file_2)
182 209
183 210 # The SyntaxError should point to the correct line
184 211 with tt.AssertPrints(["7/", "SyntaxError"]):
185 212 ip.magic("run " + fname)
186 213
187 214 def test_non_syntaxerror(self):
188 215 # SyntaxTB may be called with an error other than a SyntaxError
189 216 # See e.g. gh-4361
190 217 try:
191 218 raise ValueError('QWERTY')
192 219 except ValueError:
193 220 with tt.AssertPrints('QWERTY'):
194 221 ip.showsyntaxerror()
195 222
196 223
197 224 class Python3ChainedExceptionsTest(unittest.TestCase):
198 225 DIRECT_CAUSE_ERROR_CODE = """
199 226 try:
200 227 x = 1 + 2
201 228 print(not_defined_here)
202 229 except Exception as e:
203 230 x += 55
204 231 x - 1
205 232 y = {}
206 233 raise KeyError('uh') from e
207 234 """
208 235
209 236 EXCEPTION_DURING_HANDLING_CODE = """
210 237 try:
211 238 x = 1 + 2
212 239 print(not_defined_here)
213 240 except Exception as e:
214 241 x += 55
215 242 x - 1
216 243 y = {}
217 244 raise KeyError('uh')
218 245 """
219 246
220 247 SUPPRESS_CHAINING_CODE = """
221 248 try:
222 249 1/0
223 250 except Exception:
224 251 raise ValueError("Yikes") from None
225 252 """
226 253
227 254 def test_direct_cause_error(self):
228 255 with tt.AssertPrints(["KeyError", "NameError", "direct cause"]):
229 256 ip.run_cell(self.DIRECT_CAUSE_ERROR_CODE)
230 257
231 258 def test_exception_during_handling_error(self):
232 259 with tt.AssertPrints(["KeyError", "NameError", "During handling"]):
233 260 ip.run_cell(self.EXCEPTION_DURING_HANDLING_CODE)
234 261
235 262 def test_suppress_exception_chaining(self):
236 263 with tt.AssertNotPrints("ZeroDivisionError"), \
237 264 tt.AssertPrints("ValueError", suppress=False):
238 265 ip.run_cell(self.SUPPRESS_CHAINING_CODE)
239 266
240 267
241 268 class RecursionTest(unittest.TestCase):
242 269 DEFINITIONS = """
243 270 def non_recurs():
244 271 1/0
245 272
246 273 def r1():
247 274 r1()
248 275
249 276 def r3a():
250 277 r3b()
251 278
252 279 def r3b():
253 280 r3c()
254 281
255 282 def r3c():
256 283 r3a()
257 284
258 285 def r3o1():
259 286 r3a()
260 287
261 288 def r3o2():
262 289 r3o1()
263 290 """
264 291 def setUp(self):
265 292 ip.run_cell(self.DEFINITIONS)
266 293
267 294 def test_no_recursion(self):
268 295 with tt.AssertNotPrints("frames repeated"):
269 296 ip.run_cell("non_recurs()")
270 297
271 298 def test_recursion_one_frame(self):
272 299 with tt.AssertPrints("1 frames repeated"):
273 300 ip.run_cell("r1()")
274 301
275 302 def test_recursion_three_frames(self):
276 303 with tt.AssertPrints("3 frames repeated"):
277 304 ip.run_cell("r3o2()")
278 305
279 306 def test_find_recursion(self):
280 307 captured = []
281 308 def capture_exc(*args, **kwargs):
282 309 captured.append(sys.exc_info())
283 310 with mock.patch.object(ip, 'showtraceback', capture_exc):
284 311 ip.run_cell("r3o2()")
285 312
286 313 self.assertEqual(len(captured), 1)
287 314 etype, evalue, tb = captured[0]
288 315 self.assertIn("recursion", str(evalue))
289 316
290 317 records = ip.InteractiveTB.get_records(tb, 3, ip.InteractiveTB.tb_offset)
291 318 for r in records[:10]:
292 319 print(r[1:4])
293 320
294 321 # The outermost frames should be:
295 322 # 0: the 'cell' that was running when the exception came up
296 323 # 1: r3o2()
297 324 # 2: r3o1()
298 325 # 3: r3a()
299 326 # Then repeating r3b, r3c, r3a
300 327 last_unique, repeat_length = find_recursion(etype, evalue, records)
301 328 self.assertEqual(last_unique, 2)
302 329 self.assertEqual(repeat_length, 3)
303 330
304 331
305 332 #----------------------------------------------------------------------------
306 333
307 334 # module testing (minimal)
308 335 def test_handlers():
309 336 def spam(c, d_e):
310 337 (d, e) = d_e
311 338 x = c + d
312 339 y = c * d
313 340 foo(x, y)
314 341
315 342 def foo(a, b, bar=1):
316 343 eggs(a, b + bar)
317 344
318 345 def eggs(f, g, z=globals()):
319 346 h = f + g
320 347 i = f - g
321 348 return h / i
322 349
323 350 buff = io.StringIO()
324 351
325 352 buff.write('')
326 353 buff.write('*** Before ***')
327 354 try:
328 355 buff.write(spam(1, (2, 3)))
329 356 except:
330 357 traceback.print_exc(file=buff)
331 358
332 359 handler = ColorTB(ostream=buff)
333 360 buff.write('*** ColorTB ***')
334 361 try:
335 362 buff.write(spam(1, (2, 3)))
336 363 except:
337 364 handler(*sys.exc_info())
338 365 buff.write('')
339 366
340 367 handler = VerboseTB(ostream=buff)
341 368 buff.write('*** VerboseTB ***')
342 369 try:
343 370 buff.write(spam(1, (2, 3)))
344 371 except:
345 372 handler(*sys.exc_info())
346 373 buff.write('')
347 374
General Comments 0
You need to be logged in to leave comments. Login now