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