##// END OF EJS Templates
Fix so exit is detected as an automagic and exits qtconsole.
Thomas Kluyver -
Show More
@@ -1,2530 +1,2538 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 stdin_encoding = sys.stdin.encoding or "utf-8"
1553 stdin_encoding = sys.stdin.encoding or "utf-8"
1554
1554
1555 # Load the last 1000 lines from history
1555 # Load the last 1000 lines from history
1556 for _, _, cell in self.history_manager.get_tail(1000,
1556 for _, _, cell in self.history_manager.get_tail(1000,
1557 include_latest=True):
1557 include_latest=True):
1558 if cell.strip(): # Ignore blank lines
1558 if cell.strip(): # Ignore blank lines
1559 for line in cell.splitlines():
1559 for line in cell.splitlines():
1560 readline.add_history(line.encode(stdin_encoding))
1560 readline.add_history(line.encode(stdin_encoding))
1561
1561
1562 # Configure auto-indent for all platforms
1562 # Configure auto-indent for all platforms
1563 self.set_autoindent(self.autoindent)
1563 self.set_autoindent(self.autoindent)
1564
1564
1565 def set_next_input(self, s):
1565 def set_next_input(self, s):
1566 """ Sets the 'default' input string for the next command line.
1566 """ Sets the 'default' input string for the next command line.
1567
1567
1568 Requires readline.
1568 Requires readline.
1569
1569
1570 Example:
1570 Example:
1571
1571
1572 [D:\ipython]|1> _ip.set_next_input("Hello Word")
1572 [D:\ipython]|1> _ip.set_next_input("Hello Word")
1573 [D:\ipython]|2> Hello Word_ # cursor is here
1573 [D:\ipython]|2> Hello Word_ # cursor is here
1574 """
1574 """
1575
1575
1576 self.rl_next_input = s
1576 self.rl_next_input = s
1577
1577
1578 # Maybe move this to the terminal subclass?
1578 # Maybe move this to the terminal subclass?
1579 def pre_readline(self):
1579 def pre_readline(self):
1580 """readline hook to be used at the start of each line.
1580 """readline hook to be used at the start of each line.
1581
1581
1582 Currently it handles auto-indent only."""
1582 Currently it handles auto-indent only."""
1583
1583
1584 if self.rl_do_indent:
1584 if self.rl_do_indent:
1585 self.readline.insert_text(self._indent_current_str())
1585 self.readline.insert_text(self._indent_current_str())
1586 if self.rl_next_input is not None:
1586 if self.rl_next_input is not None:
1587 self.readline.insert_text(self.rl_next_input)
1587 self.readline.insert_text(self.rl_next_input)
1588 self.rl_next_input = None
1588 self.rl_next_input = None
1589
1589
1590 def _indent_current_str(self):
1590 def _indent_current_str(self):
1591 """return the current level of indentation as a string"""
1591 """return the current level of indentation as a string"""
1592 return self.input_splitter.indent_spaces * ' '
1592 return self.input_splitter.indent_spaces * ' '
1593
1593
1594 #-------------------------------------------------------------------------
1594 #-------------------------------------------------------------------------
1595 # Things related to text completion
1595 # Things related to text completion
1596 #-------------------------------------------------------------------------
1596 #-------------------------------------------------------------------------
1597
1597
1598 def init_completer(self):
1598 def init_completer(self):
1599 """Initialize the completion machinery.
1599 """Initialize the completion machinery.
1600
1600
1601 This creates completion machinery that can be used by client code,
1601 This creates completion machinery that can be used by client code,
1602 either interactively in-process (typically triggered by the readline
1602 either interactively in-process (typically triggered by the readline
1603 library), programatically (such as in test suites) or out-of-prcess
1603 library), programatically (such as in test suites) or out-of-prcess
1604 (typically over the network by remote frontends).
1604 (typically over the network by remote frontends).
1605 """
1605 """
1606 from IPython.core.completer import IPCompleter
1606 from IPython.core.completer import IPCompleter
1607 from IPython.core.completerlib import (module_completer,
1607 from IPython.core.completerlib import (module_completer,
1608 magic_run_completer, cd_completer)
1608 magic_run_completer, cd_completer)
1609
1609
1610 self.Completer = IPCompleter(self,
1610 self.Completer = IPCompleter(self,
1611 self.user_ns,
1611 self.user_ns,
1612 self.user_global_ns,
1612 self.user_global_ns,
1613 self.readline_omit__names,
1613 self.readline_omit__names,
1614 self.alias_manager.alias_table,
1614 self.alias_manager.alias_table,
1615 self.has_readline)
1615 self.has_readline)
1616
1616
1617 # Add custom completers to the basic ones built into IPCompleter
1617 # Add custom completers to the basic ones built into IPCompleter
1618 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1618 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1619 self.strdispatchers['complete_command'] = sdisp
1619 self.strdispatchers['complete_command'] = sdisp
1620 self.Completer.custom_completers = sdisp
1620 self.Completer.custom_completers = sdisp
1621
1621
1622 self.set_hook('complete_command', module_completer, str_key = 'import')
1622 self.set_hook('complete_command', module_completer, str_key = 'import')
1623 self.set_hook('complete_command', module_completer, str_key = 'from')
1623 self.set_hook('complete_command', module_completer, str_key = 'from')
1624 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
1624 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
1625 self.set_hook('complete_command', cd_completer, str_key = '%cd')
1625 self.set_hook('complete_command', cd_completer, str_key = '%cd')
1626
1626
1627 # Only configure readline if we truly are using readline. IPython can
1627 # Only configure readline if we truly are using readline. IPython can
1628 # do tab-completion over the network, in GUIs, etc, where readline
1628 # do tab-completion over the network, in GUIs, etc, where readline
1629 # itself may be absent
1629 # itself may be absent
1630 if self.has_readline:
1630 if self.has_readline:
1631 self.set_readline_completer()
1631 self.set_readline_completer()
1632
1632
1633 def complete(self, text, line=None, cursor_pos=None):
1633 def complete(self, text, line=None, cursor_pos=None):
1634 """Return the completed text and a list of completions.
1634 """Return the completed text and a list of completions.
1635
1635
1636 Parameters
1636 Parameters
1637 ----------
1637 ----------
1638
1638
1639 text : string
1639 text : string
1640 A string of text to be completed on. It can be given as empty and
1640 A string of text to be completed on. It can be given as empty and
1641 instead a line/position pair are given. In this case, the
1641 instead a line/position pair are given. In this case, the
1642 completer itself will split the line like readline does.
1642 completer itself will split the line like readline does.
1643
1643
1644 line : string, optional
1644 line : string, optional
1645 The complete line that text is part of.
1645 The complete line that text is part of.
1646
1646
1647 cursor_pos : int, optional
1647 cursor_pos : int, optional
1648 The position of the cursor on the input line.
1648 The position of the cursor on the input line.
1649
1649
1650 Returns
1650 Returns
1651 -------
1651 -------
1652 text : string
1652 text : string
1653 The actual text that was completed.
1653 The actual text that was completed.
1654
1654
1655 matches : list
1655 matches : list
1656 A sorted list with all possible completions.
1656 A sorted list with all possible completions.
1657
1657
1658 The optional arguments allow the completion to take more context into
1658 The optional arguments allow the completion to take more context into
1659 account, and are part of the low-level completion API.
1659 account, and are part of the low-level completion API.
1660
1660
1661 This is a wrapper around the completion mechanism, similar to what
1661 This is a wrapper around the completion mechanism, similar to what
1662 readline does at the command line when the TAB key is hit. By
1662 readline does at the command line when the TAB key is hit. By
1663 exposing it as a method, it can be used by other non-readline
1663 exposing it as a method, it can be used by other non-readline
1664 environments (such as GUIs) for text completion.
1664 environments (such as GUIs) for text completion.
1665
1665
1666 Simple usage example:
1666 Simple usage example:
1667
1667
1668 In [1]: x = 'hello'
1668 In [1]: x = 'hello'
1669
1669
1670 In [2]: _ip.complete('x.l')
1670 In [2]: _ip.complete('x.l')
1671 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
1671 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
1672 """
1672 """
1673
1673
1674 # Inject names into __builtin__ so we can complete on the added names.
1674 # Inject names into __builtin__ so we can complete on the added names.
1675 with self.builtin_trap:
1675 with self.builtin_trap:
1676 return self.Completer.complete(text, line, cursor_pos)
1676 return self.Completer.complete(text, line, cursor_pos)
1677
1677
1678 def set_custom_completer(self, completer, pos=0):
1678 def set_custom_completer(self, completer, pos=0):
1679 """Adds a new custom completer function.
1679 """Adds a new custom completer function.
1680
1680
1681 The position argument (defaults to 0) is the index in the completers
1681 The position argument (defaults to 0) is the index in the completers
1682 list where you want the completer to be inserted."""
1682 list where you want the completer to be inserted."""
1683
1683
1684 newcomp = types.MethodType(completer,self.Completer)
1684 newcomp = types.MethodType(completer,self.Completer)
1685 self.Completer.matchers.insert(pos,newcomp)
1685 self.Completer.matchers.insert(pos,newcomp)
1686
1686
1687 def set_readline_completer(self):
1687 def set_readline_completer(self):
1688 """Reset readline's completer to be our own."""
1688 """Reset readline's completer to be our own."""
1689 self.readline.set_completer(self.Completer.rlcomplete)
1689 self.readline.set_completer(self.Completer.rlcomplete)
1690
1690
1691 def set_completer_frame(self, frame=None):
1691 def set_completer_frame(self, frame=None):
1692 """Set the frame of the completer."""
1692 """Set the frame of the completer."""
1693 if frame:
1693 if frame:
1694 self.Completer.namespace = frame.f_locals
1694 self.Completer.namespace = frame.f_locals
1695 self.Completer.global_namespace = frame.f_globals
1695 self.Completer.global_namespace = frame.f_globals
1696 else:
1696 else:
1697 self.Completer.namespace = self.user_ns
1697 self.Completer.namespace = self.user_ns
1698 self.Completer.global_namespace = self.user_global_ns
1698 self.Completer.global_namespace = self.user_global_ns
1699
1699
1700 #-------------------------------------------------------------------------
1700 #-------------------------------------------------------------------------
1701 # Things related to magics
1701 # Things related to magics
1702 #-------------------------------------------------------------------------
1702 #-------------------------------------------------------------------------
1703
1703
1704 def init_magics(self):
1704 def init_magics(self):
1705 # FIXME: Move the color initialization to the DisplayHook, which
1705 # FIXME: Move the color initialization to the DisplayHook, which
1706 # should be split into a prompt manager and displayhook. We probably
1706 # should be split into a prompt manager and displayhook. We probably
1707 # even need a centralize colors management object.
1707 # even need a centralize colors management object.
1708 self.magic_colors(self.colors)
1708 self.magic_colors(self.colors)
1709 # History was moved to a separate module
1709 # History was moved to a separate module
1710 from . import history
1710 from . import history
1711 history.init_ipython(self)
1711 history.init_ipython(self)
1712
1712
1713 def magic(self,arg_s):
1713 def magic(self,arg_s):
1714 """Call a magic function by name.
1714 """Call a magic function by name.
1715
1715
1716 Input: a string containing the name of the magic function to call and
1716 Input: a string containing the name of the magic function to call and
1717 any additional arguments to be passed to the magic.
1717 any additional arguments to be passed to the magic.
1718
1718
1719 magic('name -opt foo bar') is equivalent to typing at the ipython
1719 magic('name -opt foo bar') is equivalent to typing at the ipython
1720 prompt:
1720 prompt:
1721
1721
1722 In[1]: %name -opt foo bar
1722 In[1]: %name -opt foo bar
1723
1723
1724 To call a magic without arguments, simply use magic('name').
1724 To call a magic without arguments, simply use magic('name').
1725
1725
1726 This provides a proper Python function to call IPython's magics in any
1726 This provides a proper Python function to call IPython's magics in any
1727 valid Python code you can type at the interpreter, including loops and
1727 valid Python code you can type at the interpreter, including loops and
1728 compound statements.
1728 compound statements.
1729 """
1729 """
1730 args = arg_s.split(' ',1)
1730 args = arg_s.split(' ',1)
1731 magic_name = args[0]
1731 magic_name = args[0]
1732 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
1732 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
1733
1733
1734 try:
1734 try:
1735 magic_args = args[1]
1735 magic_args = args[1]
1736 except IndexError:
1736 except IndexError:
1737 magic_args = ''
1737 magic_args = ''
1738 fn = getattr(self,'magic_'+magic_name,None)
1738 fn = getattr(self,'magic_'+magic_name,None)
1739 if fn is None:
1739 if fn is None:
1740 error("Magic function `%s` not found." % magic_name)
1740 error("Magic function `%s` not found." % magic_name)
1741 else:
1741 else:
1742 magic_args = self.var_expand(magic_args,1)
1742 magic_args = self.var_expand(magic_args,1)
1743 with nested(self.builtin_trap,):
1743 with nested(self.builtin_trap,):
1744 result = fn(magic_args)
1744 result = fn(magic_args)
1745 return result
1745 return result
1746
1746
1747 def define_magic(self, magicname, func):
1747 def define_magic(self, magicname, func):
1748 """Expose own function as magic function for ipython
1748 """Expose own function as magic function for ipython
1749
1749
1750 def foo_impl(self,parameter_s=''):
1750 def foo_impl(self,parameter_s=''):
1751 'My very own magic!. (Use docstrings, IPython reads them).'
1751 'My very own magic!. (Use docstrings, IPython reads them).'
1752 print 'Magic function. Passed parameter is between < >:'
1752 print 'Magic function. Passed parameter is between < >:'
1753 print '<%s>' % parameter_s
1753 print '<%s>' % parameter_s
1754 print 'The self object is:',self
1754 print 'The self object is:',self
1755
1755
1756 self.define_magic('foo',foo_impl)
1756 self.define_magic('foo',foo_impl)
1757 """
1757 """
1758
1758
1759 import new
1759 import new
1760 im = types.MethodType(func,self)
1760 im = types.MethodType(func,self)
1761 old = getattr(self, "magic_" + magicname, None)
1761 old = getattr(self, "magic_" + magicname, None)
1762 setattr(self, "magic_" + magicname, im)
1762 setattr(self, "magic_" + magicname, im)
1763 return old
1763 return old
1764
1764
1765 #-------------------------------------------------------------------------
1765 #-------------------------------------------------------------------------
1766 # Things related to macros
1766 # Things related to macros
1767 #-------------------------------------------------------------------------
1767 #-------------------------------------------------------------------------
1768
1768
1769 def define_macro(self, name, themacro):
1769 def define_macro(self, name, themacro):
1770 """Define a new macro
1770 """Define a new macro
1771
1771
1772 Parameters
1772 Parameters
1773 ----------
1773 ----------
1774 name : str
1774 name : str
1775 The name of the macro.
1775 The name of the macro.
1776 themacro : str or Macro
1776 themacro : str or Macro
1777 The action to do upon invoking the macro. If a string, a new
1777 The action to do upon invoking the macro. If a string, a new
1778 Macro object is created by passing the string to it.
1778 Macro object is created by passing the string to it.
1779 """
1779 """
1780
1780
1781 from IPython.core import macro
1781 from IPython.core import macro
1782
1782
1783 if isinstance(themacro, basestring):
1783 if isinstance(themacro, basestring):
1784 themacro = macro.Macro(themacro)
1784 themacro = macro.Macro(themacro)
1785 if not isinstance(themacro, macro.Macro):
1785 if not isinstance(themacro, macro.Macro):
1786 raise ValueError('A macro must be a string or a Macro instance.')
1786 raise ValueError('A macro must be a string or a Macro instance.')
1787 self.user_ns[name] = themacro
1787 self.user_ns[name] = themacro
1788
1788
1789 #-------------------------------------------------------------------------
1789 #-------------------------------------------------------------------------
1790 # Things related to the running of system commands
1790 # Things related to the running of system commands
1791 #-------------------------------------------------------------------------
1791 #-------------------------------------------------------------------------
1792
1792
1793 def system(self, cmd):
1793 def system(self, cmd):
1794 """Call the given cmd in a subprocess.
1794 """Call the given cmd in a subprocess.
1795
1795
1796 Parameters
1796 Parameters
1797 ----------
1797 ----------
1798 cmd : str
1798 cmd : str
1799 Command to execute (can not end in '&', as bacground processes are
1799 Command to execute (can not end in '&', as bacground processes are
1800 not supported.
1800 not supported.
1801 """
1801 """
1802 # We do not support backgrounding processes because we either use
1802 # We do not support backgrounding processes because we either use
1803 # pexpect or pipes to read from. Users can always just call
1803 # pexpect or pipes to read from. Users can always just call
1804 # os.system() if they really want a background process.
1804 # os.system() if they really want a background process.
1805 if cmd.endswith('&'):
1805 if cmd.endswith('&'):
1806 raise OSError("Background processes not supported.")
1806 raise OSError("Background processes not supported.")
1807
1807
1808 return system(self.var_expand(cmd, depth=2))
1808 return system(self.var_expand(cmd, depth=2))
1809
1809
1810 def getoutput(self, cmd, split=True):
1810 def getoutput(self, cmd, split=True):
1811 """Get output (possibly including stderr) from a subprocess.
1811 """Get output (possibly including stderr) from a subprocess.
1812
1812
1813 Parameters
1813 Parameters
1814 ----------
1814 ----------
1815 cmd : str
1815 cmd : str
1816 Command to execute (can not end in '&', as background processes are
1816 Command to execute (can not end in '&', as background processes are
1817 not supported.
1817 not supported.
1818 split : bool, optional
1818 split : bool, optional
1819
1819
1820 If True, split the output into an IPython SList. Otherwise, an
1820 If True, split the output into an IPython SList. Otherwise, an
1821 IPython LSString is returned. These are objects similar to normal
1821 IPython LSString is returned. These are objects similar to normal
1822 lists and strings, with a few convenience attributes for easier
1822 lists and strings, with a few convenience attributes for easier
1823 manipulation of line-based output. You can use '?' on them for
1823 manipulation of line-based output. You can use '?' on them for
1824 details.
1824 details.
1825 """
1825 """
1826 if cmd.endswith('&'):
1826 if cmd.endswith('&'):
1827 raise OSError("Background processes not supported.")
1827 raise OSError("Background processes not supported.")
1828 out = getoutput(self.var_expand(cmd, depth=2))
1828 out = getoutput(self.var_expand(cmd, depth=2))
1829 if split:
1829 if split:
1830 out = SList(out.splitlines())
1830 out = SList(out.splitlines())
1831 else:
1831 else:
1832 out = LSString(out)
1832 out = LSString(out)
1833 return out
1833 return out
1834
1834
1835 #-------------------------------------------------------------------------
1835 #-------------------------------------------------------------------------
1836 # Things related to aliases
1836 # Things related to aliases
1837 #-------------------------------------------------------------------------
1837 #-------------------------------------------------------------------------
1838
1838
1839 def init_alias(self):
1839 def init_alias(self):
1840 self.alias_manager = AliasManager(shell=self, config=self.config)
1840 self.alias_manager = AliasManager(shell=self, config=self.config)
1841 self.ns_table['alias'] = self.alias_manager.alias_table,
1841 self.ns_table['alias'] = self.alias_manager.alias_table,
1842
1842
1843 #-------------------------------------------------------------------------
1843 #-------------------------------------------------------------------------
1844 # Things related to extensions and plugins
1844 # Things related to extensions and plugins
1845 #-------------------------------------------------------------------------
1845 #-------------------------------------------------------------------------
1846
1846
1847 def init_extension_manager(self):
1847 def init_extension_manager(self):
1848 self.extension_manager = ExtensionManager(shell=self, config=self.config)
1848 self.extension_manager = ExtensionManager(shell=self, config=self.config)
1849
1849
1850 def init_plugin_manager(self):
1850 def init_plugin_manager(self):
1851 self.plugin_manager = PluginManager(config=self.config)
1851 self.plugin_manager = PluginManager(config=self.config)
1852
1852
1853 #-------------------------------------------------------------------------
1853 #-------------------------------------------------------------------------
1854 # Things related to payloads
1854 # Things related to payloads
1855 #-------------------------------------------------------------------------
1855 #-------------------------------------------------------------------------
1856
1856
1857 def init_payload(self):
1857 def init_payload(self):
1858 self.payload_manager = PayloadManager(config=self.config)
1858 self.payload_manager = PayloadManager(config=self.config)
1859
1859
1860 #-------------------------------------------------------------------------
1860 #-------------------------------------------------------------------------
1861 # Things related to the prefilter
1861 # Things related to the prefilter
1862 #-------------------------------------------------------------------------
1862 #-------------------------------------------------------------------------
1863
1863
1864 def init_prefilter(self):
1864 def init_prefilter(self):
1865 self.prefilter_manager = PrefilterManager(shell=self, config=self.config)
1865 self.prefilter_manager = PrefilterManager(shell=self, config=self.config)
1866 # Ultimately this will be refactored in the new interpreter code, but
1866 # Ultimately this will be refactored in the new interpreter code, but
1867 # for now, we should expose the main prefilter method (there's legacy
1867 # for now, we should expose the main prefilter method (there's legacy
1868 # code out there that may rely on this).
1868 # code out there that may rely on this).
1869 self.prefilter = self.prefilter_manager.prefilter_lines
1869 self.prefilter = self.prefilter_manager.prefilter_lines
1870
1870
1871 def auto_rewrite_input(self, cmd):
1871 def auto_rewrite_input(self, cmd):
1872 """Print to the screen the rewritten form of the user's command.
1872 """Print to the screen the rewritten form of the user's command.
1873
1873
1874 This shows visual feedback by rewriting input lines that cause
1874 This shows visual feedback by rewriting input lines that cause
1875 automatic calling to kick in, like::
1875 automatic calling to kick in, like::
1876
1876
1877 /f x
1877 /f x
1878
1878
1879 into::
1879 into::
1880
1880
1881 ------> f(x)
1881 ------> f(x)
1882
1882
1883 after the user's input prompt. This helps the user understand that the
1883 after the user's input prompt. This helps the user understand that the
1884 input line was transformed automatically by IPython.
1884 input line was transformed automatically by IPython.
1885 """
1885 """
1886 rw = self.displayhook.prompt1.auto_rewrite() + cmd
1886 rw = self.displayhook.prompt1.auto_rewrite() + cmd
1887
1887
1888 try:
1888 try:
1889 # plain ascii works better w/ pyreadline, on some machines, so
1889 # plain ascii works better w/ pyreadline, on some machines, so
1890 # we use it and only print uncolored rewrite if we have unicode
1890 # we use it and only print uncolored rewrite if we have unicode
1891 rw = str(rw)
1891 rw = str(rw)
1892 print >> IPython.utils.io.Term.cout, rw
1892 print >> IPython.utils.io.Term.cout, rw
1893 except UnicodeEncodeError:
1893 except UnicodeEncodeError:
1894 print "------> " + cmd
1894 print "------> " + cmd
1895
1895
1896 #-------------------------------------------------------------------------
1896 #-------------------------------------------------------------------------
1897 # Things related to extracting values/expressions from kernel and user_ns
1897 # Things related to extracting values/expressions from kernel and user_ns
1898 #-------------------------------------------------------------------------
1898 #-------------------------------------------------------------------------
1899
1899
1900 def _simple_error(self):
1900 def _simple_error(self):
1901 etype, value = sys.exc_info()[:2]
1901 etype, value = sys.exc_info()[:2]
1902 return u'[ERROR] {e.__name__}: {v}'.format(e=etype, v=value)
1902 return u'[ERROR] {e.__name__}: {v}'.format(e=etype, v=value)
1903
1903
1904 def user_variables(self, names):
1904 def user_variables(self, names):
1905 """Get a list of variable names from the user's namespace.
1905 """Get a list of variable names from the user's namespace.
1906
1906
1907 Parameters
1907 Parameters
1908 ----------
1908 ----------
1909 names : list of strings
1909 names : list of strings
1910 A list of names of variables to be read from the user namespace.
1910 A list of names of variables to be read from the user namespace.
1911
1911
1912 Returns
1912 Returns
1913 -------
1913 -------
1914 A dict, keyed by the input names and with the repr() of each value.
1914 A dict, keyed by the input names and with the repr() of each value.
1915 """
1915 """
1916 out = {}
1916 out = {}
1917 user_ns = self.user_ns
1917 user_ns = self.user_ns
1918 for varname in names:
1918 for varname in names:
1919 try:
1919 try:
1920 value = repr(user_ns[varname])
1920 value = repr(user_ns[varname])
1921 except:
1921 except:
1922 value = self._simple_error()
1922 value = self._simple_error()
1923 out[varname] = value
1923 out[varname] = value
1924 return out
1924 return out
1925
1925
1926 def user_expressions(self, expressions):
1926 def user_expressions(self, expressions):
1927 """Evaluate a dict of expressions in the user's namespace.
1927 """Evaluate a dict of expressions in the user's namespace.
1928
1928
1929 Parameters
1929 Parameters
1930 ----------
1930 ----------
1931 expressions : dict
1931 expressions : dict
1932 A dict with string keys and string values. The expression values
1932 A dict with string keys and string values. The expression values
1933 should be valid Python expressions, each of which will be evaluated
1933 should be valid Python expressions, each of which will be evaluated
1934 in the user namespace.
1934 in the user namespace.
1935
1935
1936 Returns
1936 Returns
1937 -------
1937 -------
1938 A dict, keyed like the input expressions dict, with the repr() of each
1938 A dict, keyed like the input expressions dict, with the repr() of each
1939 value.
1939 value.
1940 """
1940 """
1941 out = {}
1941 out = {}
1942 user_ns = self.user_ns
1942 user_ns = self.user_ns
1943 global_ns = self.user_global_ns
1943 global_ns = self.user_global_ns
1944 for key, expr in expressions.iteritems():
1944 for key, expr in expressions.iteritems():
1945 try:
1945 try:
1946 value = repr(eval(expr, global_ns, user_ns))
1946 value = repr(eval(expr, global_ns, user_ns))
1947 except:
1947 except:
1948 value = self._simple_error()
1948 value = self._simple_error()
1949 out[key] = value
1949 out[key] = value
1950 return out
1950 return out
1951
1951
1952 #-------------------------------------------------------------------------
1952 #-------------------------------------------------------------------------
1953 # Things related to the running of code
1953 # Things related to the running of code
1954 #-------------------------------------------------------------------------
1954 #-------------------------------------------------------------------------
1955
1955
1956 def ex(self, cmd):
1956 def ex(self, cmd):
1957 """Execute a normal python statement in user namespace."""
1957 """Execute a normal python statement in user namespace."""
1958 with nested(self.builtin_trap,):
1958 with nested(self.builtin_trap,):
1959 exec cmd in self.user_global_ns, self.user_ns
1959 exec cmd in self.user_global_ns, self.user_ns
1960
1960
1961 def ev(self, expr):
1961 def ev(self, expr):
1962 """Evaluate python expression expr in user namespace.
1962 """Evaluate python expression expr in user namespace.
1963
1963
1964 Returns the result of evaluation
1964 Returns the result of evaluation
1965 """
1965 """
1966 with nested(self.builtin_trap,):
1966 with nested(self.builtin_trap,):
1967 return eval(expr, self.user_global_ns, self.user_ns)
1967 return eval(expr, self.user_global_ns, self.user_ns)
1968
1968
1969 def safe_execfile(self, fname, *where, **kw):
1969 def safe_execfile(self, fname, *where, **kw):
1970 """A safe version of the builtin execfile().
1970 """A safe version of the builtin execfile().
1971
1971
1972 This version will never throw an exception, but instead print
1972 This version will never throw an exception, but instead print
1973 helpful error messages to the screen. This only works on pure
1973 helpful error messages to the screen. This only works on pure
1974 Python files with the .py extension.
1974 Python files with the .py extension.
1975
1975
1976 Parameters
1976 Parameters
1977 ----------
1977 ----------
1978 fname : string
1978 fname : string
1979 The name of the file to be executed.
1979 The name of the file to be executed.
1980 where : tuple
1980 where : tuple
1981 One or two namespaces, passed to execfile() as (globals,locals).
1981 One or two namespaces, passed to execfile() as (globals,locals).
1982 If only one is given, it is passed as both.
1982 If only one is given, it is passed as both.
1983 exit_ignore : bool (False)
1983 exit_ignore : bool (False)
1984 If True, then silence SystemExit for non-zero status (it is always
1984 If True, then silence SystemExit for non-zero status (it is always
1985 silenced for zero status, as it is so common).
1985 silenced for zero status, as it is so common).
1986 """
1986 """
1987 kw.setdefault('exit_ignore', False)
1987 kw.setdefault('exit_ignore', False)
1988
1988
1989 fname = os.path.abspath(os.path.expanduser(fname))
1989 fname = os.path.abspath(os.path.expanduser(fname))
1990
1990
1991 # Make sure we have a .py file
1991 # Make sure we have a .py file
1992 if not fname.endswith('.py'):
1992 if not fname.endswith('.py'):
1993 warn('File must end with .py to be run using execfile: <%s>' % fname)
1993 warn('File must end with .py to be run using execfile: <%s>' % fname)
1994
1994
1995 # Make sure we can open the file
1995 # Make sure we can open the file
1996 try:
1996 try:
1997 with open(fname) as thefile:
1997 with open(fname) as thefile:
1998 pass
1998 pass
1999 except:
1999 except:
2000 warn('Could not open file <%s> for safe execution.' % fname)
2000 warn('Could not open file <%s> for safe execution.' % fname)
2001 return
2001 return
2002
2002
2003 # Find things also in current directory. This is needed to mimic the
2003 # Find things also in current directory. This is needed to mimic the
2004 # behavior of running a script from the system command line, where
2004 # behavior of running a script from the system command line, where
2005 # Python inserts the script's directory into sys.path
2005 # Python inserts the script's directory into sys.path
2006 dname = os.path.dirname(fname)
2006 dname = os.path.dirname(fname)
2007
2007
2008 with prepended_to_syspath(dname):
2008 with prepended_to_syspath(dname):
2009 try:
2009 try:
2010 execfile(fname,*where)
2010 execfile(fname,*where)
2011 except SystemExit, status:
2011 except SystemExit, status:
2012 # If the call was made with 0 or None exit status (sys.exit(0)
2012 # If the call was made with 0 or None exit status (sys.exit(0)
2013 # or sys.exit() ), don't bother showing a traceback, as both of
2013 # or sys.exit() ), don't bother showing a traceback, as both of
2014 # these are considered normal by the OS:
2014 # these are considered normal by the OS:
2015 # > python -c'import sys;sys.exit(0)'; echo $?
2015 # > python -c'import sys;sys.exit(0)'; echo $?
2016 # 0
2016 # 0
2017 # > python -c'import sys;sys.exit()'; echo $?
2017 # > python -c'import sys;sys.exit()'; echo $?
2018 # 0
2018 # 0
2019 # For other exit status, we show the exception unless
2019 # For other exit status, we show the exception unless
2020 # explicitly silenced, but only in short form.
2020 # explicitly silenced, but only in short form.
2021 if status.code not in (0, None) and not kw['exit_ignore']:
2021 if status.code not in (0, None) and not kw['exit_ignore']:
2022 self.showtraceback(exception_only=True)
2022 self.showtraceback(exception_only=True)
2023 except:
2023 except:
2024 self.showtraceback()
2024 self.showtraceback()
2025
2025
2026 def safe_execfile_ipy(self, fname):
2026 def safe_execfile_ipy(self, fname):
2027 """Like safe_execfile, but for .ipy files with IPython syntax.
2027 """Like safe_execfile, but for .ipy files with IPython syntax.
2028
2028
2029 Parameters
2029 Parameters
2030 ----------
2030 ----------
2031 fname : str
2031 fname : str
2032 The name of the file to execute. The filename must have a
2032 The name of the file to execute. The filename must have a
2033 .ipy extension.
2033 .ipy extension.
2034 """
2034 """
2035 fname = os.path.abspath(os.path.expanduser(fname))
2035 fname = os.path.abspath(os.path.expanduser(fname))
2036
2036
2037 # Make sure we have a .py file
2037 # Make sure we have a .py file
2038 if not fname.endswith('.ipy'):
2038 if not fname.endswith('.ipy'):
2039 warn('File must end with .py to be run using execfile: <%s>' % fname)
2039 warn('File must end with .py to be run using execfile: <%s>' % fname)
2040
2040
2041 # Make sure we can open the file
2041 # Make sure we can open the file
2042 try:
2042 try:
2043 with open(fname) as thefile:
2043 with open(fname) as thefile:
2044 pass
2044 pass
2045 except:
2045 except:
2046 warn('Could not open file <%s> for safe execution.' % fname)
2046 warn('Could not open file <%s> for safe execution.' % fname)
2047 return
2047 return
2048
2048
2049 # Find things also in current directory. This is needed to mimic the
2049 # Find things also in current directory. This is needed to mimic the
2050 # behavior of running a script from the system command line, where
2050 # behavior of running a script from the system command line, where
2051 # Python inserts the script's directory into sys.path
2051 # Python inserts the script's directory into sys.path
2052 dname = os.path.dirname(fname)
2052 dname = os.path.dirname(fname)
2053
2053
2054 with prepended_to_syspath(dname):
2054 with prepended_to_syspath(dname):
2055 try:
2055 try:
2056 with open(fname) as thefile:
2056 with open(fname) as thefile:
2057 # self.run_cell currently captures all exceptions
2057 # self.run_cell currently captures all exceptions
2058 # raised in user code. It would be nice if there were
2058 # raised in user code. It would be nice if there were
2059 # versions of runlines, execfile that did raise, so
2059 # versions of runlines, execfile that did raise, so
2060 # we could catch the errors.
2060 # we could catch the errors.
2061 self.run_cell(thefile.read())
2061 self.run_cell(thefile.read())
2062 except:
2062 except:
2063 self.showtraceback()
2063 self.showtraceback()
2064 warn('Unknown failure executing file: <%s>' % fname)
2064 warn('Unknown failure executing file: <%s>' % fname)
2065
2065
2066 def run_cell(self, cell, store_history=True):
2066 def run_cell(self, cell, store_history=True):
2067 """Run the contents of an entire multiline 'cell' of code, and store it
2067 """Run the contents of an entire multiline 'cell' of code, and store it
2068 in the history.
2068 in the history.
2069
2069
2070 The cell is split into separate blocks which can be executed
2070 The cell is split into separate blocks which can be executed
2071 individually. Then, based on how many blocks there are, they are
2071 individually. Then, based on how many blocks there are, they are
2072 executed as follows:
2072 executed as follows:
2073
2073
2074 - A single block: 'single' mode. If it is also a single line, dynamic
2074 - A single block: 'single' mode. If it is also a single line, dynamic
2075 transformations, including automagic and macros, will be applied.
2075 transformations, including automagic and macros, will be applied.
2076
2076
2077 If there's more than one block, it depends:
2077 If there's more than one block, it depends:
2078
2078
2079 - if the last one is no more than two lines long, run all but the last
2079 - if the last one is no more than two lines long, run all but the last
2080 in 'exec' mode and the very last one in 'single' mode. This makes it
2080 in 'exec' mode and the very last one in 'single' mode. This makes it
2081 easy to type simple expressions at the end to see computed values. -
2081 easy to type simple expressions at the end to see computed values. -
2082 otherwise (last one is also multiline), run all in 'exec' mode
2082 otherwise (last one is also multiline), run all in 'exec' mode
2083
2083
2084 When code is executed in 'single' mode, :func:`sys.displayhook` fires,
2084 When code is executed in 'single' mode, :func:`sys.displayhook` fires,
2085 results are displayed and output prompts are computed. In 'exec' mode,
2085 results are displayed and output prompts are computed. In 'exec' mode,
2086 no results are displayed unless :func:`print` is called explicitly;
2086 no results are displayed unless :func:`print` is called explicitly;
2087 this mode is more akin to running a script.
2087 this mode is more akin to running a script.
2088
2088
2089 Parameters
2089 Parameters
2090 ----------
2090 ----------
2091 cell : str
2091 cell : str
2092 A single or multiline string.
2092 A single or multiline string.
2093 """
2093 """
2094 # Store the untransformed code
2094 # Store the untransformed code
2095 raw_cell = cell
2095 raw_cell = cell
2096
2096
2097 # We need to break up the input into executable blocks that can be run
2098 # in 'single' mode, to provide comfortable user behavior.
2099 blocks = self.input_splitter.split_blocks(cell)
2100
2097
2101 if not blocks: # Blank cell
2098 # Code transformation and execution must take place with our
2102 return
2099 # modifications to builtins.
2103
2100 with self.builtin_trap:
2104 # We only do dynamic transforms on a single line. But a macro can
2101
2105 # be expanded to several lines, so we need to split it into input
2102 # We need to break up the input into executable blocks that can
2106 # blocks again.
2103 # be runin 'single' mode, to provide comfortable user behavior.
2107 if len(cell.splitlines()) <= 1:
2108 cell = self.prefilter_manager.prefilter_line(blocks[0])
2109 blocks = self.input_splitter.split_blocks(cell)
2104 blocks = self.input_splitter.split_blocks(cell)
2110
2111 # Store the 'ipython' version of the cell as well, since that's what
2112 # needs to go into the translated history and get executed (the
2113 # original cell may contain non-python syntax).
2114 cell = ''.join(blocks)
2115
2116 # Store raw and processed history
2117 if store_history:
2118 self.history_manager.store_inputs(self.execution_count,
2119 cell, raw_cell)
2120
2121 self.logger.log(cell, raw_cell)
2122
2123 # All user code execution must happen with our context managers active
2124 with nested(self.builtin_trap, self.display_trap):
2125
2126 # Single-block input should behave like an interactive prompt
2127 if len(blocks) == 1:
2128 out = self.run_source(blocks[0])
2129 # Write output to the database. Does nothing unless
2130 # history output logging is enabled.
2131 if store_history:
2132 self.history_manager.store_output(self.execution_count)
2133 # since we return here, we need to update the execution count
2134 self.execution_count += 1
2135 return out
2136
2137 # In multi-block input, if the last block is a simple (one-two
2138 # lines) expression, run it in single mode so it produces output.
2139 # Otherwise just run it all in 'exec' mode. This seems like a
2140 # reasonable usability design.
2141 last = blocks[-1]
2142 last_nlines = len(last.splitlines())
2143
2105
2144 if last_nlines < 2:
2106 if not blocks: # Blank cell
2145 # Here we consider the cell split between 'body' and 'last',
2107 return
2146 # store all history and execute 'body', and if successful, then
2108
2147 # proceed to execute 'last'.
2109 # We only do dynamic transforms on a single line. But a macro
2148
2110 # can be expanded to several lines, so we need to split it
2149 # Get the main body to run as a cell
2111 # into input blocks again.
2150 ipy_body = ''.join(blocks[:-1])
2112 if len(cell.splitlines()) <= 1:
2151 retcode = self.run_source(ipy_body, symbol='exec',
2113 cell = self.prefilter_manager.prefilter_line(blocks[0])
2152 post_execute=False)
2114 blocks = self.input_splitter.split_blocks(cell)
2153 if retcode==0:
2115
2154 # Last expression compiled as 'single' so it produces output
2116 # Store the 'ipython' version of the cell as well, since
2155 self.run_source(last)
2117 # that's what needs to go into the translated history and get
2156 else:
2118 # executed (the original cell may contain non-python syntax).
2157 # Run the whole cell as one entity, storing both raw and
2119 cell = ''.join(blocks)
2158 # processed input in history
2120
2159 self.run_source(ipy_cell, symbol='exec')
2121 # Store raw and processed history
2122 if store_history:
2123 self.history_manager.store_inputs(self.execution_count,
2124 cell, raw_cell)
2125
2126 self.logger.log(cell, raw_cell)
2127
2128 # All user code execution should take place with our
2129 # modified displayhook.
2130 with self.display_trap:
2131
2132 # Single-block input should behave like an interactive prompt
2133 if len(blocks) == 1:
2134 out = self.run_source(blocks[0])
2135 # Write output to the database. Does nothing unless
2136 # history output logging is enabled.
2137 if store_history:
2138 self.history_manager.store_output(self.execution_count)
2139 # Since we return here, we need to update the
2140 # execution count
2141 self.execution_count += 1
2142 return out
2143
2144 # In multi-block input, if the last block is a simple (one-two
2145 # lines) expression, run it in single mode so it produces output.
2146 # Otherwise just run it all in 'exec' mode. This seems like a
2147 # reasonable usability design.
2148 last = blocks[-1]
2149 last_nlines = len(last.splitlines())
2150
2151 if last_nlines < 2:
2152 # Here we consider the cell split between 'body' and 'last',
2153 # store all history and execute 'body', and if successful, then
2154 # proceed to execute 'last'.
2155
2156 # Get the main body to run as a cell
2157 ipy_body = ''.join(blocks[:-1])
2158 retcode = self.run_source(ipy_body, symbol='exec',
2159 post_execute=False)
2160 if retcode==0:
2161 # Last expression compiled as 'single' so it
2162 # produces output
2163 self.run_source(last)
2164 else:
2165 # Run the whole cell as one entity, storing both raw and
2166 # processed input in history
2167 self.run_source(ipy_cell, symbol='exec')
2160
2168
2161 # Write output to the database. Does nothing unless
2169 # Write output to the database. Does nothing unless
2162 # history output logging is enabled.
2170 # history output logging is enabled.
2163 if store_history:
2171 if store_history:
2164 self.history_manager.store_output(self.execution_count)
2172 self.history_manager.store_output(self.execution_count)
2165 # Each cell is a *single* input, regardless of how many lines it has
2173 # Each cell is a *single* input, regardless of how many lines it has
2166 self.execution_count += 1
2174 self.execution_count += 1
2167
2175
2168 # PENDING REMOVAL: this method is slated for deletion, once our new
2176 # PENDING REMOVAL: this method is slated for deletion, once our new
2169 # input logic has been 100% moved to frontends and is stable.
2177 # input logic has been 100% moved to frontends and is stable.
2170 def runlines(self, lines, clean=False):
2178 def runlines(self, lines, clean=False):
2171 """Run a string of one or more lines of source.
2179 """Run a string of one or more lines of source.
2172
2180
2173 This method is capable of running a string containing multiple source
2181 This method is capable of running a string containing multiple source
2174 lines, as if they had been entered at the IPython prompt. Since it
2182 lines, as if they had been entered at the IPython prompt. Since it
2175 exposes IPython's processing machinery, the given strings can contain
2183 exposes IPython's processing machinery, the given strings can contain
2176 magic calls (%magic), special shell access (!cmd), etc.
2184 magic calls (%magic), special shell access (!cmd), etc.
2177 """
2185 """
2178
2186
2179 if not isinstance(lines, (list, tuple)):
2187 if not isinstance(lines, (list, tuple)):
2180 lines = lines.splitlines()
2188 lines = lines.splitlines()
2181
2189
2182 if clean:
2190 if clean:
2183 lines = self._cleanup_ipy_script(lines)
2191 lines = self._cleanup_ipy_script(lines)
2184
2192
2185 # We must start with a clean buffer, in case this is run from an
2193 # We must start with a clean buffer, in case this is run from an
2186 # interactive IPython session (via a magic, for example).
2194 # interactive IPython session (via a magic, for example).
2187 self.reset_buffer()
2195 self.reset_buffer()
2188
2196
2189 # Since we will prefilter all lines, store the user's raw input too
2197 # Since we will prefilter all lines, store the user's raw input too
2190 # before we apply any transformations
2198 # before we apply any transformations
2191 self.buffer_raw[:] = [ l+'\n' for l in lines]
2199 self.buffer_raw[:] = [ l+'\n' for l in lines]
2192
2200
2193 more = False
2201 more = False
2194 prefilter_lines = self.prefilter_manager.prefilter_lines
2202 prefilter_lines = self.prefilter_manager.prefilter_lines
2195 with nested(self.builtin_trap, self.display_trap):
2203 with nested(self.builtin_trap, self.display_trap):
2196 for line in lines:
2204 for line in lines:
2197 # skip blank lines so we don't mess up the prompt counter, but
2205 # skip blank lines so we don't mess up the prompt counter, but
2198 # do NOT skip even a blank line if we are in a code block (more
2206 # do NOT skip even a blank line if we are in a code block (more
2199 # is true)
2207 # is true)
2200
2208
2201 if line or more:
2209 if line or more:
2202 more = self.push_line(prefilter_lines(line, more))
2210 more = self.push_line(prefilter_lines(line, more))
2203 # IPython's run_source returns None if there was an error
2211 # IPython's run_source returns None if there was an error
2204 # compiling the code. This allows us to stop processing
2212 # compiling the code. This allows us to stop processing
2205 # right away, so the user gets the error message at the
2213 # right away, so the user gets the error message at the
2206 # right place.
2214 # right place.
2207 if more is None:
2215 if more is None:
2208 break
2216 break
2209 # final newline in case the input didn't have it, so that the code
2217 # final newline in case the input didn't have it, so that the code
2210 # actually does get executed
2218 # actually does get executed
2211 if more:
2219 if more:
2212 self.push_line('\n')
2220 self.push_line('\n')
2213
2221
2214 def run_source(self, source, filename=None,
2222 def run_source(self, source, filename=None,
2215 symbol='single', post_execute=True):
2223 symbol='single', post_execute=True):
2216 """Compile and run some source in the interpreter.
2224 """Compile and run some source in the interpreter.
2217
2225
2218 Arguments are as for compile_command().
2226 Arguments are as for compile_command().
2219
2227
2220 One several things can happen:
2228 One several things can happen:
2221
2229
2222 1) The input is incorrect; compile_command() raised an
2230 1) The input is incorrect; compile_command() raised an
2223 exception (SyntaxError or OverflowError). A syntax traceback
2231 exception (SyntaxError or OverflowError). A syntax traceback
2224 will be printed by calling the showsyntaxerror() method.
2232 will be printed by calling the showsyntaxerror() method.
2225
2233
2226 2) The input is incomplete, and more input is required;
2234 2) The input is incomplete, and more input is required;
2227 compile_command() returned None. Nothing happens.
2235 compile_command() returned None. Nothing happens.
2228
2236
2229 3) The input is complete; compile_command() returned a code
2237 3) The input is complete; compile_command() returned a code
2230 object. The code is executed by calling self.run_code() (which
2238 object. The code is executed by calling self.run_code() (which
2231 also handles run-time exceptions, except for SystemExit).
2239 also handles run-time exceptions, except for SystemExit).
2232
2240
2233 The return value is:
2241 The return value is:
2234
2242
2235 - True in case 2
2243 - True in case 2
2236
2244
2237 - False in the other cases, unless an exception is raised, where
2245 - False in the other cases, unless an exception is raised, where
2238 None is returned instead. This can be used by external callers to
2246 None is returned instead. This can be used by external callers to
2239 know whether to continue feeding input or not.
2247 know whether to continue feeding input or not.
2240
2248
2241 The return value can be used to decide whether to use sys.ps1 or
2249 The return value can be used to decide whether to use sys.ps1 or
2242 sys.ps2 to prompt the next line."""
2250 sys.ps2 to prompt the next line."""
2243
2251
2244 # We need to ensure that the source is unicode from here on.
2252 # We need to ensure that the source is unicode from here on.
2245 if type(source)==str:
2253 if type(source)==str:
2246 usource = source.decode(self.stdin_encoding)
2254 usource = source.decode(self.stdin_encoding)
2247 else:
2255 else:
2248 usource = source
2256 usource = source
2249
2257
2250 if False: # dbg
2258 if False: # dbg
2251 print 'Source:', repr(source) # dbg
2259 print 'Source:', repr(source) # dbg
2252 print 'USource:', repr(usource) # dbg
2260 print 'USource:', repr(usource) # dbg
2253 print 'type:', type(source) # dbg
2261 print 'type:', type(source) # dbg
2254 print 'encoding', self.stdin_encoding # dbg
2262 print 'encoding', self.stdin_encoding # dbg
2255
2263
2256 try:
2264 try:
2257 code = self.compile(usource, symbol, self.execution_count)
2265 code = self.compile(usource, symbol, self.execution_count)
2258 except (OverflowError, SyntaxError, ValueError, TypeError, MemoryError):
2266 except (OverflowError, SyntaxError, ValueError, TypeError, MemoryError):
2259 # Case 1
2267 # Case 1
2260 self.showsyntaxerror(filename)
2268 self.showsyntaxerror(filename)
2261 return None
2269 return None
2262
2270
2263 if code is None:
2271 if code is None:
2264 # Case 2
2272 # Case 2
2265 return True
2273 return True
2266
2274
2267 # Case 3
2275 # Case 3
2268 # We store the code object so that threaded shells and
2276 # We store the code object so that threaded shells and
2269 # custom exception handlers can access all this info if needed.
2277 # custom exception handlers can access all this info if needed.
2270 # The source corresponding to this can be obtained from the
2278 # The source corresponding to this can be obtained from the
2271 # buffer attribute as '\n'.join(self.buffer).
2279 # buffer attribute as '\n'.join(self.buffer).
2272 self.code_to_run = code
2280 self.code_to_run = code
2273 # now actually execute the code object
2281 # now actually execute the code object
2274 if self.run_code(code, post_execute) == 0:
2282 if self.run_code(code, post_execute) == 0:
2275 return False
2283 return False
2276 else:
2284 else:
2277 return None
2285 return None
2278
2286
2279 # For backwards compatibility
2287 # For backwards compatibility
2280 runsource = run_source
2288 runsource = run_source
2281
2289
2282 def run_code(self, code_obj, post_execute=True):
2290 def run_code(self, code_obj, post_execute=True):
2283 """Execute a code object.
2291 """Execute a code object.
2284
2292
2285 When an exception occurs, self.showtraceback() is called to display a
2293 When an exception occurs, self.showtraceback() is called to display a
2286 traceback.
2294 traceback.
2287
2295
2288 Return value: a flag indicating whether the code to be run completed
2296 Return value: a flag indicating whether the code to be run completed
2289 successfully:
2297 successfully:
2290
2298
2291 - 0: successful execution.
2299 - 0: successful execution.
2292 - 1: an error occurred.
2300 - 1: an error occurred.
2293 """
2301 """
2294
2302
2295 # Set our own excepthook in case the user code tries to call it
2303 # Set our own excepthook in case the user code tries to call it
2296 # directly, so that the IPython crash handler doesn't get triggered
2304 # directly, so that the IPython crash handler doesn't get triggered
2297 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2305 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2298
2306
2299 # we save the original sys.excepthook in the instance, in case config
2307 # we save the original sys.excepthook in the instance, in case config
2300 # code (such as magics) needs access to it.
2308 # code (such as magics) needs access to it.
2301 self.sys_excepthook = old_excepthook
2309 self.sys_excepthook = old_excepthook
2302 outflag = 1 # happens in more places, so it's easier as default
2310 outflag = 1 # happens in more places, so it's easier as default
2303 try:
2311 try:
2304 try:
2312 try:
2305 self.hooks.pre_run_code_hook()
2313 self.hooks.pre_run_code_hook()
2306 #rprint('Running code', repr(code_obj)) # dbg
2314 #rprint('Running code', repr(code_obj)) # dbg
2307 exec code_obj in self.user_global_ns, self.user_ns
2315 exec code_obj in self.user_global_ns, self.user_ns
2308 finally:
2316 finally:
2309 # Reset our crash handler in place
2317 # Reset our crash handler in place
2310 sys.excepthook = old_excepthook
2318 sys.excepthook = old_excepthook
2311 except SystemExit:
2319 except SystemExit:
2312 self.reset_buffer()
2320 self.reset_buffer()
2313 self.showtraceback(exception_only=True)
2321 self.showtraceback(exception_only=True)
2314 warn("To exit: use any of 'exit', 'quit', %Exit or Ctrl-D.", level=1)
2322 warn("To exit: use any of 'exit', 'quit', %Exit or Ctrl-D.", level=1)
2315 except self.custom_exceptions:
2323 except self.custom_exceptions:
2316 etype,value,tb = sys.exc_info()
2324 etype,value,tb = sys.exc_info()
2317 self.CustomTB(etype,value,tb)
2325 self.CustomTB(etype,value,tb)
2318 except:
2326 except:
2319 self.showtraceback()
2327 self.showtraceback()
2320 else:
2328 else:
2321 outflag = 0
2329 outflag = 0
2322 if softspace(sys.stdout, 0):
2330 if softspace(sys.stdout, 0):
2323 print
2331 print
2324
2332
2325 # Execute any registered post-execution functions. Here, any errors
2333 # Execute any registered post-execution functions. Here, any errors
2326 # are reported only minimally and just on the terminal, because the
2334 # are reported only minimally and just on the terminal, because the
2327 # main exception channel may be occupied with a user traceback.
2335 # main exception channel may be occupied with a user traceback.
2328 # FIXME: we need to think this mechanism a little more carefully.
2336 # FIXME: we need to think this mechanism a little more carefully.
2329 if post_execute:
2337 if post_execute:
2330 for func in self._post_execute:
2338 for func in self._post_execute:
2331 try:
2339 try:
2332 func()
2340 func()
2333 except:
2341 except:
2334 head = '[ ERROR ] Evaluating post_execute function: %s' % \
2342 head = '[ ERROR ] Evaluating post_execute function: %s' % \
2335 func
2343 func
2336 print >> io.Term.cout, head
2344 print >> io.Term.cout, head
2337 print >> io.Term.cout, self._simple_error()
2345 print >> io.Term.cout, self._simple_error()
2338 print >> io.Term.cout, 'Removing from post_execute'
2346 print >> io.Term.cout, 'Removing from post_execute'
2339 self._post_execute.remove(func)
2347 self._post_execute.remove(func)
2340
2348
2341 # Flush out code object which has been run (and source)
2349 # Flush out code object which has been run (and source)
2342 self.code_to_run = None
2350 self.code_to_run = None
2343 return outflag
2351 return outflag
2344
2352
2345 # For backwards compatibility
2353 # For backwards compatibility
2346 runcode = run_code
2354 runcode = run_code
2347
2355
2348 # PENDING REMOVAL: this method is slated for deletion, once our new
2356 # PENDING REMOVAL: this method is slated for deletion, once our new
2349 # input logic has been 100% moved to frontends and is stable.
2357 # input logic has been 100% moved to frontends and is stable.
2350 def push_line(self, line):
2358 def push_line(self, line):
2351 """Push a line to the interpreter.
2359 """Push a line to the interpreter.
2352
2360
2353 The line should not have a trailing newline; it may have
2361 The line should not have a trailing newline; it may have
2354 internal newlines. The line is appended to a buffer and the
2362 internal newlines. The line is appended to a buffer and the
2355 interpreter's run_source() method is called with the
2363 interpreter's run_source() method is called with the
2356 concatenated contents of the buffer as source. If this
2364 concatenated contents of the buffer as source. If this
2357 indicates that the command was executed or invalid, the buffer
2365 indicates that the command was executed or invalid, the buffer
2358 is reset; otherwise, the command is incomplete, and the buffer
2366 is reset; otherwise, the command is incomplete, and the buffer
2359 is left as it was after the line was appended. The return
2367 is left as it was after the line was appended. The return
2360 value is 1 if more input is required, 0 if the line was dealt
2368 value is 1 if more input is required, 0 if the line was dealt
2361 with in some way (this is the same as run_source()).
2369 with in some way (this is the same as run_source()).
2362 """
2370 """
2363
2371
2364 # autoindent management should be done here, and not in the
2372 # autoindent management should be done here, and not in the
2365 # interactive loop, since that one is only seen by keyboard input. We
2373 # interactive loop, since that one is only seen by keyboard input. We
2366 # need this done correctly even for code run via runlines (which uses
2374 # need this done correctly even for code run via runlines (which uses
2367 # push).
2375 # push).
2368
2376
2369 #print 'push line: <%s>' % line # dbg
2377 #print 'push line: <%s>' % line # dbg
2370 self.buffer.append(line)
2378 self.buffer.append(line)
2371 full_source = '\n'.join(self.buffer)
2379 full_source = '\n'.join(self.buffer)
2372 more = self.run_source(full_source, self.filename)
2380 more = self.run_source(full_source, self.filename)
2373 if not more:
2381 if not more:
2374 self.history_manager.store_inputs(self.execution_count,
2382 self.history_manager.store_inputs(self.execution_count,
2375 '\n'.join(self.buffer_raw), full_source)
2383 '\n'.join(self.buffer_raw), full_source)
2376 self.reset_buffer()
2384 self.reset_buffer()
2377 self.execution_count += 1
2385 self.execution_count += 1
2378 return more
2386 return more
2379
2387
2380 def reset_buffer(self):
2388 def reset_buffer(self):
2381 """Reset the input buffer."""
2389 """Reset the input buffer."""
2382 self.buffer[:] = []
2390 self.buffer[:] = []
2383 self.buffer_raw[:] = []
2391 self.buffer_raw[:] = []
2384 self.input_splitter.reset()
2392 self.input_splitter.reset()
2385
2393
2386 # For backwards compatibility
2394 # For backwards compatibility
2387 resetbuffer = reset_buffer
2395 resetbuffer = reset_buffer
2388
2396
2389 def _is_secondary_block_start(self, s):
2397 def _is_secondary_block_start(self, s):
2390 if not s.endswith(':'):
2398 if not s.endswith(':'):
2391 return False
2399 return False
2392 if (s.startswith('elif') or
2400 if (s.startswith('elif') or
2393 s.startswith('else') or
2401 s.startswith('else') or
2394 s.startswith('except') or
2402 s.startswith('except') or
2395 s.startswith('finally')):
2403 s.startswith('finally')):
2396 return True
2404 return True
2397
2405
2398 def _cleanup_ipy_script(self, script):
2406 def _cleanup_ipy_script(self, script):
2399 """Make a script safe for self.runlines()
2407 """Make a script safe for self.runlines()
2400
2408
2401 Currently, IPython is lines based, with blocks being detected by
2409 Currently, IPython is lines based, with blocks being detected by
2402 empty lines. This is a problem for block based scripts that may
2410 empty lines. This is a problem for block based scripts that may
2403 not have empty lines after blocks. This script adds those empty
2411 not have empty lines after blocks. This script adds those empty
2404 lines to make scripts safe for running in the current line based
2412 lines to make scripts safe for running in the current line based
2405 IPython.
2413 IPython.
2406 """
2414 """
2407 res = []
2415 res = []
2408 lines = script.splitlines()
2416 lines = script.splitlines()
2409 level = 0
2417 level = 0
2410
2418
2411 for l in lines:
2419 for l in lines:
2412 lstripped = l.lstrip()
2420 lstripped = l.lstrip()
2413 stripped = l.strip()
2421 stripped = l.strip()
2414 if not stripped:
2422 if not stripped:
2415 continue
2423 continue
2416 newlevel = len(l) - len(lstripped)
2424 newlevel = len(l) - len(lstripped)
2417 if level > 0 and newlevel == 0 and \
2425 if level > 0 and newlevel == 0 and \
2418 not self._is_secondary_block_start(stripped):
2426 not self._is_secondary_block_start(stripped):
2419 # add empty line
2427 # add empty line
2420 res.append('')
2428 res.append('')
2421 res.append(l)
2429 res.append(l)
2422 level = newlevel
2430 level = newlevel
2423
2431
2424 return '\n'.join(res) + '\n'
2432 return '\n'.join(res) + '\n'
2425
2433
2426 #-------------------------------------------------------------------------
2434 #-------------------------------------------------------------------------
2427 # Things related to GUI support and pylab
2435 # Things related to GUI support and pylab
2428 #-------------------------------------------------------------------------
2436 #-------------------------------------------------------------------------
2429
2437
2430 def enable_pylab(self, gui=None):
2438 def enable_pylab(self, gui=None):
2431 raise NotImplementedError('Implement enable_pylab in a subclass')
2439 raise NotImplementedError('Implement enable_pylab in a subclass')
2432
2440
2433 #-------------------------------------------------------------------------
2441 #-------------------------------------------------------------------------
2434 # Utilities
2442 # Utilities
2435 #-------------------------------------------------------------------------
2443 #-------------------------------------------------------------------------
2436
2444
2437 def var_expand(self,cmd,depth=0):
2445 def var_expand(self,cmd,depth=0):
2438 """Expand python variables in a string.
2446 """Expand python variables in a string.
2439
2447
2440 The depth argument indicates how many frames above the caller should
2448 The depth argument indicates how many frames above the caller should
2441 be walked to look for the local namespace where to expand variables.
2449 be walked to look for the local namespace where to expand variables.
2442
2450
2443 The global namespace for expansion is always the user's interactive
2451 The global namespace for expansion is always the user's interactive
2444 namespace.
2452 namespace.
2445 """
2453 """
2446
2454
2447 return str(ItplNS(cmd,
2455 return str(ItplNS(cmd,
2448 self.user_ns, # globals
2456 self.user_ns, # globals
2449 # Skip our own frame in searching for locals:
2457 # Skip our own frame in searching for locals:
2450 sys._getframe(depth+1).f_locals # locals
2458 sys._getframe(depth+1).f_locals # locals
2451 ))
2459 ))
2452
2460
2453 def mktempfile(self, data=None, prefix='ipython_edit_'):
2461 def mktempfile(self, data=None, prefix='ipython_edit_'):
2454 """Make a new tempfile and return its filename.
2462 """Make a new tempfile and return its filename.
2455
2463
2456 This makes a call to tempfile.mktemp, but it registers the created
2464 This makes a call to tempfile.mktemp, but it registers the created
2457 filename internally so ipython cleans it up at exit time.
2465 filename internally so ipython cleans it up at exit time.
2458
2466
2459 Optional inputs:
2467 Optional inputs:
2460
2468
2461 - data(None): if data is given, it gets written out to the temp file
2469 - data(None): if data is given, it gets written out to the temp file
2462 immediately, and the file is closed again."""
2470 immediately, and the file is closed again."""
2463
2471
2464 filename = tempfile.mktemp('.py', prefix)
2472 filename = tempfile.mktemp('.py', prefix)
2465 self.tempfiles.append(filename)
2473 self.tempfiles.append(filename)
2466
2474
2467 if data:
2475 if data:
2468 tmp_file = open(filename,'w')
2476 tmp_file = open(filename,'w')
2469 tmp_file.write(data)
2477 tmp_file.write(data)
2470 tmp_file.close()
2478 tmp_file.close()
2471 return filename
2479 return filename
2472
2480
2473 # TODO: This should be removed when Term is refactored.
2481 # TODO: This should be removed when Term is refactored.
2474 def write(self,data):
2482 def write(self,data):
2475 """Write a string to the default output"""
2483 """Write a string to the default output"""
2476 io.Term.cout.write(data)
2484 io.Term.cout.write(data)
2477
2485
2478 # TODO: This should be removed when Term is refactored.
2486 # TODO: This should be removed when Term is refactored.
2479 def write_err(self,data):
2487 def write_err(self,data):
2480 """Write a string to the default error output"""
2488 """Write a string to the default error output"""
2481 io.Term.cerr.write(data)
2489 io.Term.cerr.write(data)
2482
2490
2483 def ask_yes_no(self,prompt,default=True):
2491 def ask_yes_no(self,prompt,default=True):
2484 if self.quiet:
2492 if self.quiet:
2485 return True
2493 return True
2486 return ask_yes_no(prompt,default)
2494 return ask_yes_no(prompt,default)
2487
2495
2488 def show_usage(self):
2496 def show_usage(self):
2489 """Show a usage message"""
2497 """Show a usage message"""
2490 page.page(IPython.core.usage.interactive_usage)
2498 page.page(IPython.core.usage.interactive_usage)
2491
2499
2492 #-------------------------------------------------------------------------
2500 #-------------------------------------------------------------------------
2493 # Things related to IPython exiting
2501 # Things related to IPython exiting
2494 #-------------------------------------------------------------------------
2502 #-------------------------------------------------------------------------
2495 def atexit_operations(self):
2503 def atexit_operations(self):
2496 """This will be executed at the time of exit.
2504 """This will be executed at the time of exit.
2497
2505
2498 Cleanup operations and saving of persistent data that is done
2506 Cleanup operations and saving of persistent data that is done
2499 unconditionally by IPython should be performed here.
2507 unconditionally by IPython should be performed here.
2500
2508
2501 For things that may depend on startup flags or platform specifics (such
2509 For things that may depend on startup flags or platform specifics (such
2502 as having readline or not), register a separate atexit function in the
2510 as having readline or not), register a separate atexit function in the
2503 code that has the appropriate information, rather than trying to
2511 code that has the appropriate information, rather than trying to
2504 clutter
2512 clutter
2505 """
2513 """
2506 # Cleanup all tempfiles left around
2514 # Cleanup all tempfiles left around
2507 for tfile in self.tempfiles:
2515 for tfile in self.tempfiles:
2508 try:
2516 try:
2509 os.unlink(tfile)
2517 os.unlink(tfile)
2510 except OSError:
2518 except OSError:
2511 pass
2519 pass
2512
2520
2513 # Close the history session (this stores the end time and line count)
2521 # Close the history session (this stores the end time and line count)
2514 self.history_manager.end_session()
2522 self.history_manager.end_session()
2515
2523
2516 # Clear all user namespaces to release all references cleanly.
2524 # Clear all user namespaces to release all references cleanly.
2517 self.reset(new_session=False)
2525 self.reset(new_session=False)
2518
2526
2519 # Run user hooks
2527 # Run user hooks
2520 self.hooks.shutdown_hook()
2528 self.hooks.shutdown_hook()
2521
2529
2522 def cleanup(self):
2530 def cleanup(self):
2523 self.restore_sys_module_state()
2531 self.restore_sys_module_state()
2524
2532
2525
2533
2526 class InteractiveShellABC(object):
2534 class InteractiveShellABC(object):
2527 """An abstract base class for InteractiveShell."""
2535 """An abstract base class for InteractiveShell."""
2528 __metaclass__ = abc.ABCMeta
2536 __metaclass__ = abc.ABCMeta
2529
2537
2530 InteractiveShellABC.register(InteractiveShell)
2538 InteractiveShellABC.register(InteractiveShell)
General Comments 0
You need to be logged in to leave comments. Login now