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