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