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