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