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