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