##// END OF EJS Templates
Only tell the user about %paste in the terminal shell.
Thomas Kluyver -
Show More
@@ -1,2558 +1,2561
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.getcwdu()
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 # This is overridden in TerminalInteractiveShell to show a message about
1610 # the %paste magic.
1611 showindentationerror = showsyntaxerror
1612
1609 1613 #-------------------------------------------------------------------------
1610 1614 # Things related to readline
1611 1615 #-------------------------------------------------------------------------
1612 1616
1613 1617 def init_readline(self):
1614 1618 """Command history completion/saving/reloading."""
1615 1619
1616 1620 if self.readline_use:
1617 1621 import IPython.utils.rlineimpl as readline
1618 1622
1619 1623 self.rl_next_input = None
1620 1624 self.rl_do_indent = False
1621 1625
1622 1626 if not self.readline_use or not readline.have_readline:
1623 1627 self.has_readline = False
1624 1628 self.readline = None
1625 1629 # Set a number of methods that depend on readline to be no-op
1626 1630 self.set_readline_completer = no_op
1627 1631 self.set_custom_completer = no_op
1628 1632 self.set_completer_frame = no_op
1629 1633 warn('Readline services not available or not loaded.')
1630 1634 else:
1631 1635 self.has_readline = True
1632 1636 self.readline = readline
1633 1637 sys.modules['readline'] = readline
1634 1638
1635 1639 # Platform-specific configuration
1636 1640 if os.name == 'nt':
1637 1641 # FIXME - check with Frederick to see if we can harmonize
1638 1642 # naming conventions with pyreadline to avoid this
1639 1643 # platform-dependent check
1640 1644 self.readline_startup_hook = readline.set_pre_input_hook
1641 1645 else:
1642 1646 self.readline_startup_hook = readline.set_startup_hook
1643 1647
1644 1648 # Load user's initrc file (readline config)
1645 1649 # Or if libedit is used, load editrc.
1646 1650 inputrc_name = os.environ.get('INPUTRC')
1647 1651 if inputrc_name is None:
1648 1652 home_dir = get_home_dir()
1649 1653 if home_dir is not None:
1650 1654 inputrc_name = '.inputrc'
1651 1655 if readline.uses_libedit:
1652 1656 inputrc_name = '.editrc'
1653 1657 inputrc_name = os.path.join(home_dir, inputrc_name)
1654 1658 if os.path.isfile(inputrc_name):
1655 1659 try:
1656 1660 readline.read_init_file(inputrc_name)
1657 1661 except:
1658 1662 warn('Problems reading readline initialization file <%s>'
1659 1663 % inputrc_name)
1660 1664
1661 1665 # Configure readline according to user's prefs
1662 1666 # This is only done if GNU readline is being used. If libedit
1663 1667 # is being used (as on Leopard) the readline config is
1664 1668 # not run as the syntax for libedit is different.
1665 1669 if not readline.uses_libedit:
1666 1670 for rlcommand in self.readline_parse_and_bind:
1667 1671 #print "loading rl:",rlcommand # dbg
1668 1672 readline.parse_and_bind(rlcommand)
1669 1673
1670 1674 # Remove some chars from the delimiters list. If we encounter
1671 1675 # unicode chars, discard them.
1672 1676 delims = readline.get_completer_delims().encode("ascii", "ignore")
1673 1677 for d in self.readline_remove_delims:
1674 1678 delims = delims.replace(d, "")
1675 1679 delims = delims.replace(ESC_MAGIC, '')
1676 1680 readline.set_completer_delims(delims)
1677 1681 # otherwise we end up with a monster history after a while:
1678 1682 readline.set_history_length(self.history_length)
1679 1683
1680 1684 self.refill_readline_hist()
1681 1685 self.readline_no_record = ReadlineNoRecord(self)
1682 1686
1683 1687 # Configure auto-indent for all platforms
1684 1688 self.set_autoindent(self.autoindent)
1685 1689
1686 1690 def refill_readline_hist(self):
1687 1691 # Load the last 1000 lines from history
1688 1692 self.readline.clear_history()
1689 1693 stdin_encoding = sys.stdin.encoding or "utf-8"
1690 1694 for _, _, cell in self.history_manager.get_tail(1000,
1691 1695 include_latest=True):
1692 1696 if cell.strip(): # Ignore blank lines
1693 1697 for line in cell.splitlines():
1694 1698 self.readline.add_history(line.encode(stdin_encoding, 'replace'))
1695 1699
1696 1700 def set_next_input(self, s):
1697 1701 """ Sets the 'default' input string for the next command line.
1698 1702
1699 1703 Requires readline.
1700 1704
1701 1705 Example:
1702 1706
1703 1707 [D:\ipython]|1> _ip.set_next_input("Hello Word")
1704 1708 [D:\ipython]|2> Hello Word_ # cursor is here
1705 1709 """
1706 1710 if isinstance(s, unicode):
1707 1711 s = s.encode(self.stdin_encoding, 'replace')
1708 1712 self.rl_next_input = s
1709 1713
1710 1714 # Maybe move this to the terminal subclass?
1711 1715 def pre_readline(self):
1712 1716 """readline hook to be used at the start of each line.
1713 1717
1714 1718 Currently it handles auto-indent only."""
1715 1719
1716 1720 if self.rl_do_indent:
1717 1721 self.readline.insert_text(self._indent_current_str())
1718 1722 if self.rl_next_input is not None:
1719 1723 self.readline.insert_text(self.rl_next_input)
1720 1724 self.rl_next_input = None
1721 1725
1722 1726 def _indent_current_str(self):
1723 1727 """return the current level of indentation as a string"""
1724 1728 return self.input_splitter.indent_spaces * ' '
1725 1729
1726 1730 #-------------------------------------------------------------------------
1727 1731 # Things related to text completion
1728 1732 #-------------------------------------------------------------------------
1729 1733
1730 1734 def init_completer(self):
1731 1735 """Initialize the completion machinery.
1732 1736
1733 1737 This creates completion machinery that can be used by client code,
1734 1738 either interactively in-process (typically triggered by the readline
1735 1739 library), programatically (such as in test suites) or out-of-prcess
1736 1740 (typically over the network by remote frontends).
1737 1741 """
1738 1742 from IPython.core.completer import IPCompleter
1739 1743 from IPython.core.completerlib import (module_completer,
1740 1744 magic_run_completer, cd_completer)
1741 1745
1742 1746 self.Completer = IPCompleter(self,
1743 1747 self.user_ns,
1744 1748 self.user_global_ns,
1745 1749 self.readline_omit__names,
1746 1750 self.alias_manager.alias_table,
1747 1751 self.has_readline)
1748 1752
1749 1753 # Add custom completers to the basic ones built into IPCompleter
1750 1754 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1751 1755 self.strdispatchers['complete_command'] = sdisp
1752 1756 self.Completer.custom_completers = sdisp
1753 1757
1754 1758 self.set_hook('complete_command', module_completer, str_key = 'import')
1755 1759 self.set_hook('complete_command', module_completer, str_key = 'from')
1756 1760 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
1757 1761 self.set_hook('complete_command', cd_completer, str_key = '%cd')
1758 1762
1759 1763 # Only configure readline if we truly are using readline. IPython can
1760 1764 # do tab-completion over the network, in GUIs, etc, where readline
1761 1765 # itself may be absent
1762 1766 if self.has_readline:
1763 1767 self.set_readline_completer()
1764 1768
1765 1769 def complete(self, text, line=None, cursor_pos=None):
1766 1770 """Return the completed text and a list of completions.
1767 1771
1768 1772 Parameters
1769 1773 ----------
1770 1774
1771 1775 text : string
1772 1776 A string of text to be completed on. It can be given as empty and
1773 1777 instead a line/position pair are given. In this case, the
1774 1778 completer itself will split the line like readline does.
1775 1779
1776 1780 line : string, optional
1777 1781 The complete line that text is part of.
1778 1782
1779 1783 cursor_pos : int, optional
1780 1784 The position of the cursor on the input line.
1781 1785
1782 1786 Returns
1783 1787 -------
1784 1788 text : string
1785 1789 The actual text that was completed.
1786 1790
1787 1791 matches : list
1788 1792 A sorted list with all possible completions.
1789 1793
1790 1794 The optional arguments allow the completion to take more context into
1791 1795 account, and are part of the low-level completion API.
1792 1796
1793 1797 This is a wrapper around the completion mechanism, similar to what
1794 1798 readline does at the command line when the TAB key is hit. By
1795 1799 exposing it as a method, it can be used by other non-readline
1796 1800 environments (such as GUIs) for text completion.
1797 1801
1798 1802 Simple usage example:
1799 1803
1800 1804 In [1]: x = 'hello'
1801 1805
1802 1806 In [2]: _ip.complete('x.l')
1803 1807 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
1804 1808 """
1805 1809
1806 1810 # Inject names into __builtin__ so we can complete on the added names.
1807 1811 with self.builtin_trap:
1808 1812 return self.Completer.complete(text, line, cursor_pos)
1809 1813
1810 1814 def set_custom_completer(self, completer, pos=0):
1811 1815 """Adds a new custom completer function.
1812 1816
1813 1817 The position argument (defaults to 0) is the index in the completers
1814 1818 list where you want the completer to be inserted."""
1815 1819
1816 1820 newcomp = types.MethodType(completer,self.Completer)
1817 1821 self.Completer.matchers.insert(pos,newcomp)
1818 1822
1819 1823 def set_readline_completer(self):
1820 1824 """Reset readline's completer to be our own."""
1821 1825 self.readline.set_completer(self.Completer.rlcomplete)
1822 1826
1823 1827 def set_completer_frame(self, frame=None):
1824 1828 """Set the frame of the completer."""
1825 1829 if frame:
1826 1830 self.Completer.namespace = frame.f_locals
1827 1831 self.Completer.global_namespace = frame.f_globals
1828 1832 else:
1829 1833 self.Completer.namespace = self.user_ns
1830 1834 self.Completer.global_namespace = self.user_global_ns
1831 1835
1832 1836 #-------------------------------------------------------------------------
1833 1837 # Things related to magics
1834 1838 #-------------------------------------------------------------------------
1835 1839
1836 1840 def init_magics(self):
1837 1841 # FIXME: Move the color initialization to the DisplayHook, which
1838 1842 # should be split into a prompt manager and displayhook. We probably
1839 1843 # even need a centralize colors management object.
1840 1844 self.magic_colors(self.colors)
1841 1845 # History was moved to a separate module
1842 1846 from . import history
1843 1847 history.init_ipython(self)
1844 1848
1845 1849 def magic(self, arg_s, next_input=None):
1846 1850 """Call a magic function by name.
1847 1851
1848 1852 Input: a string containing the name of the magic function to call and
1849 1853 any additional arguments to be passed to the magic.
1850 1854
1851 1855 magic('name -opt foo bar') is equivalent to typing at the ipython
1852 1856 prompt:
1853 1857
1854 1858 In[1]: %name -opt foo bar
1855 1859
1856 1860 To call a magic without arguments, simply use magic('name').
1857 1861
1858 1862 This provides a proper Python function to call IPython's magics in any
1859 1863 valid Python code you can type at the interpreter, including loops and
1860 1864 compound statements.
1861 1865 """
1862 1866 # Allow setting the next input - this is used if the user does `a=abs?`.
1863 1867 # We do this first so that magic functions can override it.
1864 1868 if next_input:
1865 1869 self.set_next_input(next_input)
1866 1870
1867 1871 args = arg_s.split(' ',1)
1868 1872 magic_name = args[0]
1869 1873 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
1870 1874
1871 1875 try:
1872 1876 magic_args = args[1]
1873 1877 except IndexError:
1874 1878 magic_args = ''
1875 1879 fn = getattr(self,'magic_'+magic_name,None)
1876 1880 if fn is None:
1877 1881 error("Magic function `%s` not found." % magic_name)
1878 1882 else:
1879 1883 magic_args = self.var_expand(magic_args,1)
1880 1884 # Grab local namespace if we need it:
1881 1885 if getattr(fn, "needs_local_scope", False):
1882 1886 self._magic_locals = sys._getframe(1).f_locals
1883 1887 with self.builtin_trap:
1884 1888 result = fn(magic_args)
1885 1889 # Ensure we're not keeping object references around:
1886 1890 self._magic_locals = {}
1887 1891 return result
1888 1892
1889 1893 def define_magic(self, magicname, func):
1890 1894 """Expose own function as magic function for ipython
1891 1895
1892 1896 def foo_impl(self,parameter_s=''):
1893 1897 'My very own magic!. (Use docstrings, IPython reads them).'
1894 1898 print 'Magic function. Passed parameter is between < >:'
1895 1899 print '<%s>' % parameter_s
1896 1900 print 'The self object is:',self
1897 1901
1898 1902 self.define_magic('foo',foo_impl)
1899 1903 """
1900 1904
1901 1905 import new
1902 1906 im = types.MethodType(func,self)
1903 1907 old = getattr(self, "magic_" + magicname, None)
1904 1908 setattr(self, "magic_" + magicname, im)
1905 1909 return old
1906 1910
1907 1911 #-------------------------------------------------------------------------
1908 1912 # Things related to macros
1909 1913 #-------------------------------------------------------------------------
1910 1914
1911 1915 def define_macro(self, name, themacro):
1912 1916 """Define a new macro
1913 1917
1914 1918 Parameters
1915 1919 ----------
1916 1920 name : str
1917 1921 The name of the macro.
1918 1922 themacro : str or Macro
1919 1923 The action to do upon invoking the macro. If a string, a new
1920 1924 Macro object is created by passing the string to it.
1921 1925 """
1922 1926
1923 1927 from IPython.core import macro
1924 1928
1925 1929 if isinstance(themacro, basestring):
1926 1930 themacro = macro.Macro(themacro)
1927 1931 if not isinstance(themacro, macro.Macro):
1928 1932 raise ValueError('A macro must be a string or a Macro instance.')
1929 1933 self.user_ns[name] = themacro
1930 1934
1931 1935 #-------------------------------------------------------------------------
1932 1936 # Things related to the running of system commands
1933 1937 #-------------------------------------------------------------------------
1934 1938
1935 1939 def system_piped(self, cmd):
1936 1940 """Call the given cmd in a subprocess, piping stdout/err
1937 1941
1938 1942 Parameters
1939 1943 ----------
1940 1944 cmd : str
1941 1945 Command to execute (can not end in '&', as background processes are
1942 1946 not supported. Should not be a command that expects input
1943 1947 other than simple text.
1944 1948 """
1945 1949 if cmd.rstrip().endswith('&'):
1946 1950 # this is *far* from a rigorous test
1947 1951 # We do not support backgrounding processes because we either use
1948 1952 # pexpect or pipes to read from. Users can always just call
1949 1953 # os.system() or use ip.system=ip.system_raw
1950 1954 # if they really want a background process.
1951 1955 raise OSError("Background processes not supported.")
1952 1956
1953 1957 # we explicitly do NOT return the subprocess status code, because
1954 1958 # a non-None value would trigger :func:`sys.displayhook` calls.
1955 1959 # Instead, we store the exit_code in user_ns.
1956 1960 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=2))
1957 1961
1958 1962 def system_raw(self, cmd):
1959 1963 """Call the given cmd in a subprocess using os.system
1960 1964
1961 1965 Parameters
1962 1966 ----------
1963 1967 cmd : str
1964 1968 Command to execute.
1965 1969 """
1966 1970 # We explicitly do NOT return the subprocess status code, because
1967 1971 # a non-None value would trigger :func:`sys.displayhook` calls.
1968 1972 # Instead, we store the exit_code in user_ns.
1969 1973 self.user_ns['_exit_code'] = os.system(self.var_expand(cmd, depth=2))
1970 1974
1971 1975 # use piped system by default, because it is better behaved
1972 1976 system = system_piped
1973 1977
1974 1978 def getoutput(self, cmd, split=True):
1975 1979 """Get output (possibly including stderr) from a subprocess.
1976 1980
1977 1981 Parameters
1978 1982 ----------
1979 1983 cmd : str
1980 1984 Command to execute (can not end in '&', as background processes are
1981 1985 not supported.
1982 1986 split : bool, optional
1983 1987
1984 1988 If True, split the output into an IPython SList. Otherwise, an
1985 1989 IPython LSString is returned. These are objects similar to normal
1986 1990 lists and strings, with a few convenience attributes for easier
1987 1991 manipulation of line-based output. You can use '?' on them for
1988 1992 details.
1989 1993 """
1990 1994 if cmd.rstrip().endswith('&'):
1991 1995 # this is *far* from a rigorous test
1992 1996 raise OSError("Background processes not supported.")
1993 1997 out = getoutput(self.var_expand(cmd, depth=2))
1994 1998 if split:
1995 1999 out = SList(out.splitlines())
1996 2000 else:
1997 2001 out = LSString(out)
1998 2002 return out
1999 2003
2000 2004 #-------------------------------------------------------------------------
2001 2005 # Things related to aliases
2002 2006 #-------------------------------------------------------------------------
2003 2007
2004 2008 def init_alias(self):
2005 2009 self.alias_manager = AliasManager(shell=self, config=self.config)
2006 2010 self.ns_table['alias'] = self.alias_manager.alias_table,
2007 2011
2008 2012 #-------------------------------------------------------------------------
2009 2013 # Things related to extensions and plugins
2010 2014 #-------------------------------------------------------------------------
2011 2015
2012 2016 def init_extension_manager(self):
2013 2017 self.extension_manager = ExtensionManager(shell=self, config=self.config)
2014 2018
2015 2019 def init_plugin_manager(self):
2016 2020 self.plugin_manager = PluginManager(config=self.config)
2017 2021
2018 2022 #-------------------------------------------------------------------------
2019 2023 # Things related to payloads
2020 2024 #-------------------------------------------------------------------------
2021 2025
2022 2026 def init_payload(self):
2023 2027 self.payload_manager = PayloadManager(config=self.config)
2024 2028
2025 2029 #-------------------------------------------------------------------------
2026 2030 # Things related to the prefilter
2027 2031 #-------------------------------------------------------------------------
2028 2032
2029 2033 def init_prefilter(self):
2030 2034 self.prefilter_manager = PrefilterManager(shell=self, config=self.config)
2031 2035 # Ultimately this will be refactored in the new interpreter code, but
2032 2036 # for now, we should expose the main prefilter method (there's legacy
2033 2037 # code out there that may rely on this).
2034 2038 self.prefilter = self.prefilter_manager.prefilter_lines
2035 2039
2036 2040 def auto_rewrite_input(self, cmd):
2037 2041 """Print to the screen the rewritten form of the user's command.
2038 2042
2039 2043 This shows visual feedback by rewriting input lines that cause
2040 2044 automatic calling to kick in, like::
2041 2045
2042 2046 /f x
2043 2047
2044 2048 into::
2045 2049
2046 2050 ------> f(x)
2047 2051
2048 2052 after the user's input prompt. This helps the user understand that the
2049 2053 input line was transformed automatically by IPython.
2050 2054 """
2051 2055 rw = self.displayhook.prompt1.auto_rewrite() + cmd
2052 2056
2053 2057 try:
2054 2058 # plain ascii works better w/ pyreadline, on some machines, so
2055 2059 # we use it and only print uncolored rewrite if we have unicode
2056 2060 rw = str(rw)
2057 2061 print >> io.stdout, rw
2058 2062 except UnicodeEncodeError:
2059 2063 print "------> " + cmd
2060 2064
2061 2065 #-------------------------------------------------------------------------
2062 2066 # Things related to extracting values/expressions from kernel and user_ns
2063 2067 #-------------------------------------------------------------------------
2064 2068
2065 2069 def _simple_error(self):
2066 2070 etype, value = sys.exc_info()[:2]
2067 2071 return u'[ERROR] {e.__name__}: {v}'.format(e=etype, v=value)
2068 2072
2069 2073 def user_variables(self, names):
2070 2074 """Get a list of variable names from the user's namespace.
2071 2075
2072 2076 Parameters
2073 2077 ----------
2074 2078 names : list of strings
2075 2079 A list of names of variables to be read from the user namespace.
2076 2080
2077 2081 Returns
2078 2082 -------
2079 2083 A dict, keyed by the input names and with the repr() of each value.
2080 2084 """
2081 2085 out = {}
2082 2086 user_ns = self.user_ns
2083 2087 for varname in names:
2084 2088 try:
2085 2089 value = repr(user_ns[varname])
2086 2090 except:
2087 2091 value = self._simple_error()
2088 2092 out[varname] = value
2089 2093 return out
2090 2094
2091 2095 def user_expressions(self, expressions):
2092 2096 """Evaluate a dict of expressions in the user's namespace.
2093 2097
2094 2098 Parameters
2095 2099 ----------
2096 2100 expressions : dict
2097 2101 A dict with string keys and string values. The expression values
2098 2102 should be valid Python expressions, each of which will be evaluated
2099 2103 in the user namespace.
2100 2104
2101 2105 Returns
2102 2106 -------
2103 2107 A dict, keyed like the input expressions dict, with the repr() of each
2104 2108 value.
2105 2109 """
2106 2110 out = {}
2107 2111 user_ns = self.user_ns
2108 2112 global_ns = self.user_global_ns
2109 2113 for key, expr in expressions.iteritems():
2110 2114 try:
2111 2115 value = repr(eval(expr, global_ns, user_ns))
2112 2116 except:
2113 2117 value = self._simple_error()
2114 2118 out[key] = value
2115 2119 return out
2116 2120
2117 2121 #-------------------------------------------------------------------------
2118 2122 # Things related to the running of code
2119 2123 #-------------------------------------------------------------------------
2120 2124
2121 2125 def ex(self, cmd):
2122 2126 """Execute a normal python statement in user namespace."""
2123 2127 with self.builtin_trap:
2124 2128 exec cmd in self.user_global_ns, self.user_ns
2125 2129
2126 2130 def ev(self, expr):
2127 2131 """Evaluate python expression expr in user namespace.
2128 2132
2129 2133 Returns the result of evaluation
2130 2134 """
2131 2135 with self.builtin_trap:
2132 2136 return eval(expr, self.user_global_ns, self.user_ns)
2133 2137
2134 2138 def safe_execfile(self, fname, *where, **kw):
2135 2139 """A safe version of the builtin execfile().
2136 2140
2137 2141 This version will never throw an exception, but instead print
2138 2142 helpful error messages to the screen. This only works on pure
2139 2143 Python files with the .py extension.
2140 2144
2141 2145 Parameters
2142 2146 ----------
2143 2147 fname : string
2144 2148 The name of the file to be executed.
2145 2149 where : tuple
2146 2150 One or two namespaces, passed to execfile() as (globals,locals).
2147 2151 If only one is given, it is passed as both.
2148 2152 exit_ignore : bool (False)
2149 2153 If True, then silence SystemExit for non-zero status (it is always
2150 2154 silenced for zero status, as it is so common).
2151 2155 """
2152 2156 kw.setdefault('exit_ignore', False)
2153 2157
2154 2158 fname = os.path.abspath(os.path.expanduser(fname))
2155 2159
2156 2160 # Make sure we can open the file
2157 2161 try:
2158 2162 with open(fname) as thefile:
2159 2163 pass
2160 2164 except:
2161 2165 warn('Could not open file <%s> for safe execution.' % fname)
2162 2166 return
2163 2167
2164 2168 # Find things also in current directory. This is needed to mimic the
2165 2169 # behavior of running a script from the system command line, where
2166 2170 # Python inserts the script's directory into sys.path
2167 2171 dname = os.path.dirname(fname)
2168 2172
2169 2173 if isinstance(fname, unicode):
2170 2174 # execfile uses default encoding instead of filesystem encoding
2171 2175 # so unicode filenames will fail
2172 2176 fname = fname.encode(sys.getfilesystemencoding() or sys.getdefaultencoding())
2173 2177
2174 2178 with prepended_to_syspath(dname):
2175 2179 try:
2176 2180 execfile(fname,*where)
2177 2181 except SystemExit, status:
2178 2182 # If the call was made with 0 or None exit status (sys.exit(0)
2179 2183 # or sys.exit() ), don't bother showing a traceback, as both of
2180 2184 # these are considered normal by the OS:
2181 2185 # > python -c'import sys;sys.exit(0)'; echo $?
2182 2186 # 0
2183 2187 # > python -c'import sys;sys.exit()'; echo $?
2184 2188 # 0
2185 2189 # For other exit status, we show the exception unless
2186 2190 # explicitly silenced, but only in short form.
2187 2191 if status.code not in (0, None) and not kw['exit_ignore']:
2188 2192 self.showtraceback(exception_only=True)
2189 2193 except:
2190 2194 self.showtraceback()
2191 2195
2192 2196 def safe_execfile_ipy(self, fname):
2193 2197 """Like safe_execfile, but for .ipy files with IPython syntax.
2194 2198
2195 2199 Parameters
2196 2200 ----------
2197 2201 fname : str
2198 2202 The name of the file to execute. The filename must have a
2199 2203 .ipy extension.
2200 2204 """
2201 2205 fname = os.path.abspath(os.path.expanduser(fname))
2202 2206
2203 2207 # Make sure we can open the file
2204 2208 try:
2205 2209 with open(fname) as thefile:
2206 2210 pass
2207 2211 except:
2208 2212 warn('Could not open file <%s> for safe execution.' % fname)
2209 2213 return
2210 2214
2211 2215 # Find things also in current directory. This is needed to mimic the
2212 2216 # behavior of running a script from the system command line, where
2213 2217 # Python inserts the script's directory into sys.path
2214 2218 dname = os.path.dirname(fname)
2215 2219
2216 2220 with prepended_to_syspath(dname):
2217 2221 try:
2218 2222 with open(fname) as thefile:
2219 2223 # self.run_cell currently captures all exceptions
2220 2224 # raised in user code. It would be nice if there were
2221 2225 # versions of runlines, execfile that did raise, so
2222 2226 # we could catch the errors.
2223 2227 self.run_cell(thefile.read(), store_history=False)
2224 2228 except:
2225 2229 self.showtraceback()
2226 2230 warn('Unknown failure executing file: <%s>' % fname)
2227 2231
2228 2232 def run_cell(self, raw_cell, store_history=True):
2229 2233 """Run a complete IPython cell.
2230 2234
2231 2235 Parameters
2232 2236 ----------
2233 2237 raw_cell : str
2234 2238 The code (including IPython code such as %magic functions) to run.
2235 2239 store_history : bool
2236 2240 If True, the raw and translated cell will be stored in IPython's
2237 2241 history. For user code calling back into IPython's machinery, this
2238 2242 should be set to False.
2239 2243 """
2240 2244 if (not raw_cell) or raw_cell.isspace():
2241 2245 return
2242 2246
2243 2247 for line in raw_cell.splitlines():
2244 2248 self.input_splitter.push(line)
2245 2249 cell = self.input_splitter.source_reset()
2246 2250
2247 2251 with self.builtin_trap:
2248 2252 prefilter_failed = False
2249 2253 if len(cell.splitlines()) == 1:
2250 2254 try:
2251 2255 # use prefilter_lines to handle trailing newlines
2252 2256 # restore trailing newline for ast.parse
2253 2257 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
2254 2258 except AliasError as e:
2255 2259 error(e)
2256 2260 prefilter_failed=True
2257 2261 except Exception:
2258 2262 # don't allow prefilter errors to crash IPython
2259 2263 self.showtraceback()
2260 2264 prefilter_failed = True
2261 2265
2262 2266 # Store raw and processed history
2263 2267 if store_history:
2264 2268 self.history_manager.store_inputs(self.execution_count,
2265 2269 cell, raw_cell)
2266 2270
2267 2271 self.logger.log(cell, raw_cell)
2268 2272
2269 2273 if not prefilter_failed:
2270 2274 # don't run if prefilter failed
2271 2275 cell_name = self.compile.cache(cell, self.execution_count)
2272 2276
2273 2277 with self.display_trap:
2274 2278 try:
2275 2279 code_ast = ast.parse(cell, filename=cell_name)
2276 2280 except IndentationError:
2277 self.showsyntaxerror()
2278 print("If you want to paste code into IPython, try the %paste magic function.")
2281 self.showindentationerror()
2279 2282 self.execution_count += 1
2280 2283 return None
2281 2284 except (OverflowError, SyntaxError, ValueError, TypeError,
2282 2285 MemoryError):
2283 2286 self.showsyntaxerror()
2284 2287 self.execution_count += 1
2285 2288 return None
2286 2289
2287 2290 self.run_ast_nodes(code_ast.body, cell_name,
2288 2291 interactivity="last_expr")
2289 2292
2290 2293 # Execute any registered post-execution functions.
2291 2294 for func, status in self._post_execute.iteritems():
2292 2295 if not status:
2293 2296 continue
2294 2297 try:
2295 2298 func()
2296 2299 except:
2297 2300 self.showtraceback()
2298 2301 # Deactivate failing function
2299 2302 self._post_execute[func] = False
2300 2303
2301 2304 if store_history:
2302 2305 # Write output to the database. Does nothing unless
2303 2306 # history output logging is enabled.
2304 2307 self.history_manager.store_output(self.execution_count)
2305 2308 # Each cell is a *single* input, regardless of how many lines it has
2306 2309 self.execution_count += 1
2307 2310
2308 2311 def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr'):
2309 2312 """Run a sequence of AST nodes. The execution mode depends on the
2310 2313 interactivity parameter.
2311 2314
2312 2315 Parameters
2313 2316 ----------
2314 2317 nodelist : list
2315 2318 A sequence of AST nodes to run.
2316 2319 cell_name : str
2317 2320 Will be passed to the compiler as the filename of the cell. Typically
2318 2321 the value returned by ip.compile.cache(cell).
2319 2322 interactivity : str
2320 2323 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
2321 2324 run interactively (displaying output from expressions). 'last_expr'
2322 2325 will run the last node interactively only if it is an expression (i.e.
2323 2326 expressions in loops or other blocks are not displayed. Other values
2324 2327 for this parameter will raise a ValueError.
2325 2328 """
2326 2329 if not nodelist:
2327 2330 return
2328 2331
2329 2332 if interactivity == 'last_expr':
2330 2333 if isinstance(nodelist[-1], ast.Expr):
2331 2334 interactivity = "last"
2332 2335 else:
2333 2336 interactivity = "none"
2334 2337
2335 2338 if interactivity == 'none':
2336 2339 to_run_exec, to_run_interactive = nodelist, []
2337 2340 elif interactivity == 'last':
2338 2341 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
2339 2342 elif interactivity == 'all':
2340 2343 to_run_exec, to_run_interactive = [], nodelist
2341 2344 else:
2342 2345 raise ValueError("Interactivity was %r" % interactivity)
2343 2346
2344 2347 exec_count = self.execution_count
2345 2348
2346 2349 for i, node in enumerate(to_run_exec):
2347 2350 mod = ast.Module([node])
2348 2351 code = self.compile(mod, cell_name, "exec")
2349 2352 if self.run_code(code):
2350 2353 return True
2351 2354
2352 2355 for i, node in enumerate(to_run_interactive):
2353 2356 mod = ast.Interactive([node])
2354 2357 code = self.compile(mod, cell_name, "single")
2355 2358 if self.run_code(code):
2356 2359 return True
2357 2360
2358 2361 return False
2359 2362
2360 2363 def run_code(self, code_obj):
2361 2364 """Execute a code object.
2362 2365
2363 2366 When an exception occurs, self.showtraceback() is called to display a
2364 2367 traceback.
2365 2368
2366 2369 Parameters
2367 2370 ----------
2368 2371 code_obj : code object
2369 2372 A compiled code object, to be executed
2370 2373 post_execute : bool [default: True]
2371 2374 whether to call post_execute hooks after this particular execution.
2372 2375
2373 2376 Returns
2374 2377 -------
2375 2378 False : successful execution.
2376 2379 True : an error occurred.
2377 2380 """
2378 2381
2379 2382 # Set our own excepthook in case the user code tries to call it
2380 2383 # directly, so that the IPython crash handler doesn't get triggered
2381 2384 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2382 2385
2383 2386 # we save the original sys.excepthook in the instance, in case config
2384 2387 # code (such as magics) needs access to it.
2385 2388 self.sys_excepthook = old_excepthook
2386 2389 outflag = 1 # happens in more places, so it's easier as default
2387 2390 try:
2388 2391 try:
2389 2392 self.hooks.pre_run_code_hook()
2390 2393 #rprint('Running code', repr(code_obj)) # dbg
2391 2394 exec code_obj in self.user_global_ns, self.user_ns
2392 2395 finally:
2393 2396 # Reset our crash handler in place
2394 2397 sys.excepthook = old_excepthook
2395 2398 except SystemExit:
2396 2399 self.showtraceback(exception_only=True)
2397 2400 warn("To exit: use 'exit', 'quit', or Ctrl-D.", level=1)
2398 2401 except self.custom_exceptions:
2399 2402 etype,value,tb = sys.exc_info()
2400 2403 self.CustomTB(etype,value,tb)
2401 2404 except:
2402 2405 self.showtraceback()
2403 2406 else:
2404 2407 outflag = 0
2405 2408 if softspace(sys.stdout, 0):
2406 2409 print
2407 2410
2408 2411 return outflag
2409 2412
2410 2413 # For backwards compatibility
2411 2414 runcode = run_code
2412 2415
2413 2416 #-------------------------------------------------------------------------
2414 2417 # Things related to GUI support and pylab
2415 2418 #-------------------------------------------------------------------------
2416 2419
2417 2420 def enable_pylab(self, gui=None, import_all=True):
2418 2421 raise NotImplementedError('Implement enable_pylab in a subclass')
2419 2422
2420 2423 #-------------------------------------------------------------------------
2421 2424 # Utilities
2422 2425 #-------------------------------------------------------------------------
2423 2426
2424 2427 def var_expand(self,cmd,depth=0):
2425 2428 """Expand python variables in a string.
2426 2429
2427 2430 The depth argument indicates how many frames above the caller should
2428 2431 be walked to look for the local namespace where to expand variables.
2429 2432
2430 2433 The global namespace for expansion is always the user's interactive
2431 2434 namespace.
2432 2435 """
2433 2436 res = ItplNS(cmd, self.user_ns, # globals
2434 2437 # Skip our own frame in searching for locals:
2435 2438 sys._getframe(depth+1).f_locals # locals
2436 2439 )
2437 2440 return str(res).decode(res.codec)
2438 2441
2439 2442 def mktempfile(self, data=None, prefix='ipython_edit_'):
2440 2443 """Make a new tempfile and return its filename.
2441 2444
2442 2445 This makes a call to tempfile.mktemp, but it registers the created
2443 2446 filename internally so ipython cleans it up at exit time.
2444 2447
2445 2448 Optional inputs:
2446 2449
2447 2450 - data(None): if data is given, it gets written out to the temp file
2448 2451 immediately, and the file is closed again."""
2449 2452
2450 2453 filename = tempfile.mktemp('.py', prefix)
2451 2454 self.tempfiles.append(filename)
2452 2455
2453 2456 if data:
2454 2457 tmp_file = open(filename,'w')
2455 2458 tmp_file.write(data)
2456 2459 tmp_file.close()
2457 2460 return filename
2458 2461
2459 2462 # TODO: This should be removed when Term is refactored.
2460 2463 def write(self,data):
2461 2464 """Write a string to the default output"""
2462 2465 io.stdout.write(data)
2463 2466
2464 2467 # TODO: This should be removed when Term is refactored.
2465 2468 def write_err(self,data):
2466 2469 """Write a string to the default error output"""
2467 2470 io.stderr.write(data)
2468 2471
2469 2472 def ask_yes_no(self,prompt,default=True):
2470 2473 if self.quiet:
2471 2474 return True
2472 2475 return ask_yes_no(prompt,default)
2473 2476
2474 2477 def show_usage(self):
2475 2478 """Show a usage message"""
2476 2479 page.page(IPython.core.usage.interactive_usage)
2477 2480
2478 2481 def find_user_code(self, target, raw=True):
2479 2482 """Get a code string from history, file, or a string or macro.
2480 2483
2481 2484 This is mainly used by magic functions.
2482 2485
2483 2486 Parameters
2484 2487 ----------
2485 2488 target : str
2486 2489 A string specifying code to retrieve. This will be tried respectively
2487 2490 as: ranges of input history (see %history for syntax), a filename, or
2488 2491 an expression evaluating to a string or Macro in the user namespace.
2489 2492 raw : bool
2490 2493 If true (default), retrieve raw history. Has no effect on the other
2491 2494 retrieval mechanisms.
2492 2495
2493 2496 Returns
2494 2497 -------
2495 2498 A string of code.
2496 2499
2497 2500 ValueError is raised if nothing is found, and TypeError if it evaluates
2498 2501 to an object of another type. In each case, .args[0] is a printable
2499 2502 message.
2500 2503 """
2501 2504 code = self.extract_input_lines(target, raw=raw) # Grab history
2502 2505 if code:
2503 2506 return code
2504 2507 if os.path.isfile(target): # Read file
2505 2508 return open(target, "r").read()
2506 2509
2507 2510 try: # User namespace
2508 2511 codeobj = eval(target, self.user_ns)
2509 2512 except Exception:
2510 2513 raise ValueError(("'%s' was not found in history, as a file, nor in"
2511 2514 " the user namespace.") % target)
2512 2515 if isinstance(codeobj, basestring):
2513 2516 return codeobj
2514 2517 elif isinstance(codeobj, Macro):
2515 2518 return codeobj.value
2516 2519
2517 2520 raise TypeError("%s is neither a string nor a macro." % target,
2518 2521 codeobj)
2519 2522
2520 2523 #-------------------------------------------------------------------------
2521 2524 # Things related to IPython exiting
2522 2525 #-------------------------------------------------------------------------
2523 2526 def atexit_operations(self):
2524 2527 """This will be executed at the time of exit.
2525 2528
2526 2529 Cleanup operations and saving of persistent data that is done
2527 2530 unconditionally by IPython should be performed here.
2528 2531
2529 2532 For things that may depend on startup flags or platform specifics (such
2530 2533 as having readline or not), register a separate atexit function in the
2531 2534 code that has the appropriate information, rather than trying to
2532 2535 clutter
2533 2536 """
2534 2537 # Cleanup all tempfiles left around
2535 2538 for tfile in self.tempfiles:
2536 2539 try:
2537 2540 os.unlink(tfile)
2538 2541 except OSError:
2539 2542 pass
2540 2543
2541 2544 # Close the history session (this stores the end time and line count)
2542 2545 self.history_manager.end_session()
2543 2546
2544 2547 # Clear all user namespaces to release all references cleanly.
2545 2548 self.reset(new_session=False)
2546 2549
2547 2550 # Run user hooks
2548 2551 self.hooks.shutdown_hook()
2549 2552
2550 2553 def cleanup(self):
2551 2554 self.restore_sys_module_state()
2552 2555
2553 2556
2554 2557 class InteractiveShellABC(object):
2555 2558 """An abstract base class for InteractiveShell."""
2556 2559 __metaclass__ = abc.ABCMeta
2557 2560
2558 2561 InteractiveShellABC.register(InteractiveShell)
@@ -1,593 +1,597
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
242 242 if isinstance(display_banner, basestring):
243 243 self.show_banner(display_banner)
244 244 elif display_banner:
245 245 self.show_banner()
246 246
247 247 more = False
248 248
249 249 # Mark activity in the builtins
250 250 __builtin__.__dict__['__IPYTHON__active'] += 1
251 251
252 252 if self.has_readline:
253 253 self.readline_startup_hook(self.pre_readline)
254 254 # exit_now is set by a call to %Exit or %Quit, through the
255 255 # ask_exit callback.
256 256
257 257 while not self.exit_now:
258 258 self.hooks.pre_prompt_hook()
259 259 if more:
260 260 try:
261 261 prompt = self.hooks.generate_prompt(True)
262 262 except:
263 263 self.showtraceback()
264 264 if self.autoindent:
265 265 self.rl_do_indent = True
266 266
267 267 else:
268 268 try:
269 269 prompt = self.hooks.generate_prompt(False)
270 270 except:
271 271 self.showtraceback()
272 272 try:
273 273 line = self.raw_input(prompt)
274 274 if self.exit_now:
275 275 # quick exit on sys.std[in|out] close
276 276 break
277 277 if self.autoindent:
278 278 self.rl_do_indent = False
279 279
280 280 except KeyboardInterrupt:
281 281 #double-guard against keyboardinterrupts during kbdint handling
282 282 try:
283 283 self.write('\nKeyboardInterrupt\n')
284 284 self.input_splitter.reset()
285 285 more = False
286 286 except KeyboardInterrupt:
287 287 pass
288 288 except EOFError:
289 289 if self.autoindent:
290 290 self.rl_do_indent = False
291 291 if self.has_readline:
292 292 self.readline_startup_hook(None)
293 293 self.write('\n')
294 294 self.exit()
295 295 except bdb.BdbQuit:
296 296 warn('The Python debugger has exited with a BdbQuit exception.\n'
297 297 'Because of how pdb handles the stack, it is impossible\n'
298 298 'for IPython to properly format this particular exception.\n'
299 299 'IPython will resume normal operation.')
300 300 except:
301 301 # exceptions here are VERY RARE, but they can be triggered
302 302 # asynchronously by signal handlers, for example.
303 303 self.showtraceback()
304 304 else:
305 305 self.input_splitter.push(line)
306 306 more = self.input_splitter.push_accepts_more()
307 307 if (self.SyntaxTB.last_syntax_error and
308 308 self.autoedit_syntax):
309 309 self.edit_syntax_error()
310 310 if not more:
311 311 source_raw = self.input_splitter.source_raw_reset()[1]
312 312 self.run_cell(source_raw)
313 313
314 314 # We are off again...
315 315 __builtin__.__dict__['__IPYTHON__active'] -= 1
316 316
317 317 # Turn off the exit flag, so the mainloop can be restarted if desired
318 318 self.exit_now = False
319 319
320 320 def raw_input(self, prompt=''):
321 321 """Write a prompt and read a line.
322 322
323 323 The returned line does not include the trailing newline.
324 324 When the user enters the EOF key sequence, EOFError is raised.
325 325
326 326 Optional inputs:
327 327
328 328 - prompt(''): a string to be printed to prompt the user.
329 329
330 330 - continue_prompt(False): whether this line is the first one or a
331 331 continuation in a sequence of inputs.
332 332 """
333 333 # Code run by the user may have modified the readline completer state.
334 334 # We must ensure that our completer is back in place.
335 335
336 336 if self.has_readline:
337 337 self.set_readline_completer()
338 338
339 339 try:
340 340 line = raw_input_original(prompt).decode(self.stdin_encoding)
341 341 except ValueError:
342 342 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
343 343 " or sys.stdout.close()!\nExiting IPython!")
344 344 self.ask_exit()
345 345 return ""
346 346
347 347 # Try to be reasonably smart about not re-indenting pasted input more
348 348 # than necessary. We do this by trimming out the auto-indent initial
349 349 # spaces, if the user's actual input started itself with whitespace.
350 350 if self.autoindent:
351 351 if num_ini_spaces(line) > self.indent_current_nsp:
352 352 line = line[self.indent_current_nsp:]
353 353 self.indent_current_nsp = 0
354 354
355 355 return line
356 356
357 357 #-------------------------------------------------------------------------
358 358 # Methods to support auto-editing of SyntaxErrors.
359 359 #-------------------------------------------------------------------------
360 360
361 361 def edit_syntax_error(self):
362 362 """The bottom half of the syntax error handler called in the main loop.
363 363
364 364 Loop until syntax error is fixed or user cancels.
365 365 """
366 366
367 367 while self.SyntaxTB.last_syntax_error:
368 368 # copy and clear last_syntax_error
369 369 err = self.SyntaxTB.clear_err_state()
370 370 if not self._should_recompile(err):
371 371 return
372 372 try:
373 373 # may set last_syntax_error again if a SyntaxError is raised
374 374 self.safe_execfile(err.filename,self.user_ns)
375 375 except:
376 376 self.showtraceback()
377 377 else:
378 378 try:
379 379 f = file(err.filename)
380 380 try:
381 381 # This should be inside a display_trap block and I
382 382 # think it is.
383 383 sys.displayhook(f.read())
384 384 finally:
385 385 f.close()
386 386 except:
387 387 self.showtraceback()
388 388
389 389 def _should_recompile(self,e):
390 390 """Utility routine for edit_syntax_error"""
391 391
392 392 if e.filename in ('<ipython console>','<input>','<string>',
393 393 '<console>','<BackgroundJob compilation>',
394 394 None):
395 395
396 396 return False
397 397 try:
398 398 if (self.autoedit_syntax and
399 399 not self.ask_yes_no('Return to editor to correct syntax error? '
400 400 '[Y/n] ','y')):
401 401 return False
402 402 except EOFError:
403 403 return False
404 404
405 405 def int0(x):
406 406 try:
407 407 return int(x)
408 408 except TypeError:
409 409 return 0
410 410 # always pass integer line and offset values to editor hook
411 411 try:
412 412 self.hooks.fix_error_editor(e.filename,
413 413 int0(e.lineno),int0(e.offset),e.msg)
414 414 except TryNext:
415 415 warn('Could not open editor')
416 416 return False
417 417 return True
418 418
419 419 #-------------------------------------------------------------------------
420 420 # Things related to GUI support and pylab
421 421 #-------------------------------------------------------------------------
422 422
423 423 def enable_pylab(self, gui=None, import_all=True):
424 424 """Activate pylab support at runtime.
425 425
426 426 This turns on support for matplotlib, preloads into the interactive
427 427 namespace all of numpy and pylab, and configures IPython to correcdtly
428 428 interact with the GUI event loop. The GUI backend to be used can be
429 429 optionally selected with the optional :param:`gui` argument.
430 430
431 431 Parameters
432 432 ----------
433 433 gui : optional, string
434 434
435 435 If given, dictates the choice of matplotlib GUI backend to use
436 436 (should be one of IPython's supported backends, 'tk', 'qt', 'wx' or
437 437 'gtk'), otherwise we use the default chosen by matplotlib (as
438 438 dictated by the matplotlib build-time options plus the user's
439 439 matplotlibrc configuration file).
440 440 """
441 441 # We want to prevent the loading of pylab to pollute the user's
442 442 # namespace as shown by the %who* magics, so we execute the activation
443 443 # code in an empty namespace, and we update *both* user_ns and
444 444 # user_ns_hidden with this information.
445 445 ns = {}
446 446 gui = pylab_activate(ns, gui, import_all)
447 447 self.user_ns.update(ns)
448 448 self.user_ns_hidden.update(ns)
449 449 # Now we must activate the gui pylab wants to use, and fix %run to take
450 450 # plot updates into account
451 451 enable_gui(gui)
452 452 self.magic_run = self._pylab_magic_run
453 453
454 454 #-------------------------------------------------------------------------
455 455 # Things related to exiting
456 456 #-------------------------------------------------------------------------
457 457
458 458 def ask_exit(self):
459 459 """ Ask the shell to exit. Can be overiden and used as a callback. """
460 460 self.exit_now = True
461 461
462 462 def exit(self):
463 463 """Handle interactive exit.
464 464
465 465 This method calls the ask_exit callback."""
466 466 if self.confirm_exit:
467 467 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
468 468 self.ask_exit()
469 469 else:
470 470 self.ask_exit()
471 471
472 472 #------------------------------------------------------------------------
473 473 # Magic overrides
474 474 #------------------------------------------------------------------------
475 475 # Once the base class stops inheriting from magic, this code needs to be
476 476 # moved into a separate machinery as well. For now, at least isolate here
477 477 # the magics which this class needs to implement differently from the base
478 478 # class, or that are unique to it.
479 479
480 480 def magic_autoindent(self, parameter_s = ''):
481 481 """Toggle autoindent on/off (if available)."""
482 482
483 483 self.shell.set_autoindent()
484 484 print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
485 485
486 486 @skip_doctest
487 487 def magic_cpaste(self, parameter_s=''):
488 488 """Paste & execute a pre-formatted code block from clipboard.
489 489
490 490 You must terminate the block with '--' (two minus-signs) alone on the
491 491 line. You can also provide your own sentinel with '%paste -s %%' ('%%'
492 492 is the new sentinel for this operation)
493 493
494 494 The block is dedented prior to execution to enable execution of method
495 495 definitions. '>' and '+' characters at the beginning of a line are
496 496 ignored, to allow pasting directly from e-mails, diff files and
497 497 doctests (the '...' continuation prompt is also stripped). The
498 498 executed block is also assigned to variable named 'pasted_block' for
499 499 later editing with '%edit pasted_block'.
500 500
501 501 You can also pass a variable name as an argument, e.g. '%cpaste foo'.
502 502 This assigns the pasted block to variable 'foo' as string, without
503 503 dedenting or executing it (preceding >>> and + is still stripped)
504 504
505 505 '%cpaste -r' re-executes the block previously entered by cpaste.
506 506
507 507 Do not be alarmed by garbled output on Windows (it's a readline bug).
508 508 Just press enter and type -- (and press enter again) and the block
509 509 will be what was just pasted.
510 510
511 511 IPython statements (magics, shell escapes) are not supported (yet).
512 512
513 513 See also
514 514 --------
515 515 paste: automatically pull code from clipboard.
516 516
517 517 Examples
518 518 --------
519 519 ::
520 520
521 521 In [8]: %cpaste
522 522 Pasting code; enter '--' alone on the line to stop.
523 523 :>>> a = ["world!", "Hello"]
524 524 :>>> print " ".join(sorted(a))
525 525 :--
526 526 Hello world!
527 527 """
528 528
529 529 opts,args = self.parse_options(parameter_s,'rs:',mode='string')
530 530 par = args.strip()
531 531 if opts.has_key('r'):
532 532 self._rerun_pasted()
533 533 return
534 534
535 535 sentinel = opts.get('s','--')
536 536
537 537 block = self._strip_pasted_lines_for_code(
538 538 self._get_pasted_lines(sentinel))
539 539
540 540 self._execute_block(block, par)
541 541
542 542 def magic_paste(self, parameter_s=''):
543 543 """Paste & execute a pre-formatted code block from clipboard.
544 544
545 545 The text is pulled directly from the clipboard without user
546 546 intervention and printed back on the screen before execution (unless
547 547 the -q flag is given to force quiet mode).
548 548
549 549 The block is dedented prior to execution to enable execution of method
550 550 definitions. '>' and '+' characters at the beginning of a line are
551 551 ignored, to allow pasting directly from e-mails, diff files and
552 552 doctests (the '...' continuation prompt is also stripped). The
553 553 executed block is also assigned to variable named 'pasted_block' for
554 554 later editing with '%edit pasted_block'.
555 555
556 556 You can also pass a variable name as an argument, e.g. '%paste foo'.
557 557 This assigns the pasted block to variable 'foo' as string, without
558 558 dedenting or executing it (preceding >>> and + is still stripped)
559 559
560 560 Options
561 561 -------
562 562
563 563 -r: re-executes the block previously entered by cpaste.
564 564
565 565 -q: quiet mode: do not echo the pasted text back to the terminal.
566 566
567 567 IPython statements (magics, shell escapes) are not supported (yet).
568 568
569 569 See also
570 570 --------
571 571 cpaste: manually paste code into terminal until you mark its end.
572 572 """
573 573 opts,args = self.parse_options(parameter_s,'rq',mode='string')
574 574 par = args.strip()
575 575 if opts.has_key('r'):
576 576 self._rerun_pasted()
577 577 return
578 578
579 579 text = self.shell.hooks.clipboard_get()
580 580 block = self._strip_pasted_lines_for_code(text.splitlines())
581 581
582 582 # By default, echo back to terminal unless quiet mode is requested
583 583 if not opts.has_key('q'):
584 584 write = self.shell.write
585 585 write(self.shell.pycolorize(block))
586 586 if not block.endswith('\n'):
587 587 write('\n')
588 588 write("## -- End pasted text --\n")
589 589
590 590 self._execute_block(block, par)
591 591
592 def showindentationerror(self):
593 super(TerminalInteractiveShell, self).showindentationerror()
594 print("If you want to paste code into IPython, try the %paste magic function.")
595
592 596
593 597 InteractiveShellABC.register(TerminalInteractiveShell)
General Comments 0
You need to be logged in to leave comments. Login now