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