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