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