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