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