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