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