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