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