##// END OF EJS Templates
Remove check for custom_exceptions from showtraceback; it's checked in run_code.
Thomas Kluyver -
Show More
@@ -1,2979 +1,2976 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Main IPython class."""
2 """Main IPython class."""
3
3
4 #-----------------------------------------------------------------------------
4 #-----------------------------------------------------------------------------
5 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
5 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
6 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
6 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
7 # Copyright (C) 2008-2011 The IPython Development Team
7 # Copyright (C) 2008-2011 The IPython Development Team
8 #
8 #
9 # Distributed under the terms of the BSD License. The full license is in
9 # Distributed under the terms of the BSD License. The full license is in
10 # the file COPYING, distributed as part of this software.
10 # the file COPYING, distributed as part of this software.
11 #-----------------------------------------------------------------------------
11 #-----------------------------------------------------------------------------
12
12
13 #-----------------------------------------------------------------------------
13 #-----------------------------------------------------------------------------
14 # Imports
14 # Imports
15 #-----------------------------------------------------------------------------
15 #-----------------------------------------------------------------------------
16
16
17 from __future__ import with_statement
17 from __future__ import with_statement
18 from __future__ import absolute_import
18 from __future__ import absolute_import
19
19
20 import __builtin__ as builtin_mod
20 import __builtin__ as builtin_mod
21 import __future__
21 import __future__
22 import abc
22 import abc
23 import ast
23 import ast
24 import atexit
24 import atexit
25 import os
25 import os
26 import re
26 import re
27 import runpy
27 import runpy
28 import sys
28 import sys
29 import tempfile
29 import tempfile
30 import types
30 import types
31
31
32 # We need to use nested to support python 2.6, once we move to >=2.7, we can
32 # We need to use nested to support python 2.6, once we move to >=2.7, we can
33 # use the with keyword's new builtin support for nested managers
33 # use the with keyword's new builtin support for nested managers
34 try:
34 try:
35 from contextlib import nested
35 from contextlib import nested
36 except:
36 except:
37 from IPython.utils.nested_context import nested
37 from IPython.utils.nested_context import nested
38
38
39 from IPython.config.configurable import SingletonConfigurable
39 from IPython.config.configurable import SingletonConfigurable
40 from IPython.core import debugger, oinspect
40 from IPython.core import debugger, oinspect
41 from IPython.core import history as ipcorehist
41 from IPython.core import history as ipcorehist
42 from IPython.core import magic
42 from IPython.core import magic
43 from IPython.core import page
43 from IPython.core import page
44 from IPython.core import prefilter
44 from IPython.core import prefilter
45 from IPython.core import shadowns
45 from IPython.core import shadowns
46 from IPython.core import ultratb
46 from IPython.core import ultratb
47 from IPython.core.alias import AliasManager, AliasError
47 from IPython.core.alias import AliasManager, AliasError
48 from IPython.core.autocall import ExitAutocall
48 from IPython.core.autocall import ExitAutocall
49 from IPython.core.builtin_trap import BuiltinTrap
49 from IPython.core.builtin_trap import BuiltinTrap
50 from IPython.core.compilerop import CachingCompiler
50 from IPython.core.compilerop import CachingCompiler
51 from IPython.core.display_trap import DisplayTrap
51 from IPython.core.display_trap import DisplayTrap
52 from IPython.core.displayhook import DisplayHook
52 from IPython.core.displayhook import DisplayHook
53 from IPython.core.displaypub import DisplayPublisher
53 from IPython.core.displaypub import DisplayPublisher
54 from IPython.core.error import UsageError
54 from IPython.core.error import UsageError
55 from IPython.core.extensions import ExtensionManager
55 from IPython.core.extensions import ExtensionManager
56 from IPython.core.fakemodule import FakeModule, init_fakemod_dict
56 from IPython.core.fakemodule import FakeModule, init_fakemod_dict
57 from IPython.core.formatters import DisplayFormatter
57 from IPython.core.formatters import DisplayFormatter
58 from IPython.core.history import HistoryManager
58 from IPython.core.history import HistoryManager
59 from IPython.core.inputsplitter import IPythonInputSplitter
59 from IPython.core.inputsplitter import IPythonInputSplitter
60 from IPython.core.logger import Logger
60 from IPython.core.logger import Logger
61 from IPython.core.macro import Macro
61 from IPython.core.macro import Macro
62 from IPython.core.payload import PayloadManager
62 from IPython.core.payload import PayloadManager
63 from IPython.core.plugin import PluginManager
63 from IPython.core.plugin import PluginManager
64 from IPython.core.prefilter import PrefilterManager, ESC_MAGIC
64 from IPython.core.prefilter import PrefilterManager, ESC_MAGIC
65 from IPython.core.profiledir import ProfileDir
65 from IPython.core.profiledir import ProfileDir
66 from IPython.core.pylabtools import pylab_activate
66 from IPython.core.pylabtools import pylab_activate
67 from IPython.core.prompts import PromptManager
67 from IPython.core.prompts import PromptManager
68 from IPython.utils import PyColorize
68 from IPython.utils import PyColorize
69 from IPython.utils import io
69 from IPython.utils import io
70 from IPython.utils import py3compat
70 from IPython.utils import py3compat
71 from IPython.utils import openpy
71 from IPython.utils import openpy
72 from IPython.utils.doctestreload import doctest_reload
72 from IPython.utils.doctestreload import doctest_reload
73 from IPython.utils.io import ask_yes_no
73 from IPython.utils.io import ask_yes_no
74 from IPython.utils.ipstruct import Struct
74 from IPython.utils.ipstruct import Struct
75 from IPython.utils.path import get_home_dir, get_ipython_dir, get_py_filename, unquote_filename
75 from IPython.utils.path import get_home_dir, get_ipython_dir, get_py_filename, unquote_filename
76 from IPython.utils.pickleshare import PickleShareDB
76 from IPython.utils.pickleshare import PickleShareDB
77 from IPython.utils.process import system, getoutput
77 from IPython.utils.process import system, getoutput
78 from IPython.utils.strdispatch import StrDispatch
78 from IPython.utils.strdispatch import StrDispatch
79 from IPython.utils.syspathcontext import prepended_to_syspath
79 from IPython.utils.syspathcontext import prepended_to_syspath
80 from IPython.utils.text import (format_screen, LSString, SList,
80 from IPython.utils.text import (format_screen, LSString, SList,
81 DollarFormatter)
81 DollarFormatter)
82 from IPython.utils.traitlets import (Integer, CBool, CaselessStrEnum, Enum,
82 from IPython.utils.traitlets import (Integer, CBool, CaselessStrEnum, Enum,
83 List, Unicode, Instance, Type)
83 List, Unicode, Instance, Type)
84 from IPython.utils.warn import warn, error
84 from IPython.utils.warn import warn, error
85 import IPython.core.hooks
85 import IPython.core.hooks
86
86
87 #-----------------------------------------------------------------------------
87 #-----------------------------------------------------------------------------
88 # Globals
88 # Globals
89 #-----------------------------------------------------------------------------
89 #-----------------------------------------------------------------------------
90
90
91 # compiled regexps for autoindent management
91 # compiled regexps for autoindent management
92 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
92 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
93
93
94 #-----------------------------------------------------------------------------
94 #-----------------------------------------------------------------------------
95 # Utilities
95 # Utilities
96 #-----------------------------------------------------------------------------
96 #-----------------------------------------------------------------------------
97
97
98 def softspace(file, newvalue):
98 def softspace(file, newvalue):
99 """Copied from code.py, to remove the dependency"""
99 """Copied from code.py, to remove the dependency"""
100
100
101 oldvalue = 0
101 oldvalue = 0
102 try:
102 try:
103 oldvalue = file.softspace
103 oldvalue = file.softspace
104 except AttributeError:
104 except AttributeError:
105 pass
105 pass
106 try:
106 try:
107 file.softspace = newvalue
107 file.softspace = newvalue
108 except (AttributeError, TypeError):
108 except (AttributeError, TypeError):
109 # "attribute-less object" or "read-only attributes"
109 # "attribute-less object" or "read-only attributes"
110 pass
110 pass
111 return oldvalue
111 return oldvalue
112
112
113
113
114 def no_op(*a, **kw): pass
114 def no_op(*a, **kw): pass
115
115
116 class NoOpContext(object):
116 class NoOpContext(object):
117 def __enter__(self): pass
117 def __enter__(self): pass
118 def __exit__(self, type, value, traceback): pass
118 def __exit__(self, type, value, traceback): pass
119 no_op_context = NoOpContext()
119 no_op_context = NoOpContext()
120
120
121 class SpaceInInput(Exception): pass
121 class SpaceInInput(Exception): pass
122
122
123 class Bunch: pass
123 class Bunch: pass
124
124
125
125
126 def get_default_colors():
126 def get_default_colors():
127 if sys.platform=='darwin':
127 if sys.platform=='darwin':
128 return "LightBG"
128 return "LightBG"
129 elif os.name=='nt':
129 elif os.name=='nt':
130 return 'Linux'
130 return 'Linux'
131 else:
131 else:
132 return 'Linux'
132 return 'Linux'
133
133
134
134
135 class SeparateUnicode(Unicode):
135 class SeparateUnicode(Unicode):
136 """A Unicode subclass to validate separate_in, separate_out, etc.
136 """A Unicode subclass to validate separate_in, separate_out, etc.
137
137
138 This is a Unicode based trait that converts '0'->'' and '\\n'->'\n'.
138 This is a Unicode based trait that converts '0'->'' and '\\n'->'\n'.
139 """
139 """
140
140
141 def validate(self, obj, value):
141 def validate(self, obj, value):
142 if value == '0': value = ''
142 if value == '0': value = ''
143 value = value.replace('\\n','\n')
143 value = value.replace('\\n','\n')
144 return super(SeparateUnicode, self).validate(obj, value)
144 return super(SeparateUnicode, self).validate(obj, value)
145
145
146
146
147 class ReadlineNoRecord(object):
147 class ReadlineNoRecord(object):
148 """Context manager to execute some code, then reload readline history
148 """Context manager to execute some code, then reload readline history
149 so that interactive input to the code doesn't appear when pressing up."""
149 so that interactive input to the code doesn't appear when pressing up."""
150 def __init__(self, shell):
150 def __init__(self, shell):
151 self.shell = shell
151 self.shell = shell
152 self._nested_level = 0
152 self._nested_level = 0
153
153
154 def __enter__(self):
154 def __enter__(self):
155 if self._nested_level == 0:
155 if self._nested_level == 0:
156 try:
156 try:
157 self.orig_length = self.current_length()
157 self.orig_length = self.current_length()
158 self.readline_tail = self.get_readline_tail()
158 self.readline_tail = self.get_readline_tail()
159 except (AttributeError, IndexError): # Can fail with pyreadline
159 except (AttributeError, IndexError): # Can fail with pyreadline
160 self.orig_length, self.readline_tail = 999999, []
160 self.orig_length, self.readline_tail = 999999, []
161 self._nested_level += 1
161 self._nested_level += 1
162
162
163 def __exit__(self, type, value, traceback):
163 def __exit__(self, type, value, traceback):
164 self._nested_level -= 1
164 self._nested_level -= 1
165 if self._nested_level == 0:
165 if self._nested_level == 0:
166 # Try clipping the end if it's got longer
166 # Try clipping the end if it's got longer
167 try:
167 try:
168 e = self.current_length() - self.orig_length
168 e = self.current_length() - self.orig_length
169 if e > 0:
169 if e > 0:
170 for _ in range(e):
170 for _ in range(e):
171 self.shell.readline.remove_history_item(self.orig_length)
171 self.shell.readline.remove_history_item(self.orig_length)
172
172
173 # If it still doesn't match, just reload readline history.
173 # If it still doesn't match, just reload readline history.
174 if self.current_length() != self.orig_length \
174 if self.current_length() != self.orig_length \
175 or self.get_readline_tail() != self.readline_tail:
175 or self.get_readline_tail() != self.readline_tail:
176 self.shell.refill_readline_hist()
176 self.shell.refill_readline_hist()
177 except (AttributeError, IndexError):
177 except (AttributeError, IndexError):
178 pass
178 pass
179 # Returning False will cause exceptions to propagate
179 # Returning False will cause exceptions to propagate
180 return False
180 return False
181
181
182 def current_length(self):
182 def current_length(self):
183 return self.shell.readline.get_current_history_length()
183 return self.shell.readline.get_current_history_length()
184
184
185 def get_readline_tail(self, n=10):
185 def get_readline_tail(self, n=10):
186 """Get the last n items in readline history."""
186 """Get the last n items in readline history."""
187 end = self.shell.readline.get_current_history_length() + 1
187 end = self.shell.readline.get_current_history_length() + 1
188 start = max(end-n, 1)
188 start = max(end-n, 1)
189 ghi = self.shell.readline.get_history_item
189 ghi = self.shell.readline.get_history_item
190 return [ghi(x) for x in range(start, end)]
190 return [ghi(x) for x in range(start, end)]
191
191
192 #-----------------------------------------------------------------------------
192 #-----------------------------------------------------------------------------
193 # Main IPython class
193 # Main IPython class
194 #-----------------------------------------------------------------------------
194 #-----------------------------------------------------------------------------
195
195
196 class InteractiveShell(SingletonConfigurable):
196 class InteractiveShell(SingletonConfigurable):
197 """An enhanced, interactive shell for Python."""
197 """An enhanced, interactive shell for Python."""
198
198
199 _instance = None
199 _instance = None
200
200
201 autocall = Enum((0,1,2), default_value=0, config=True, help=
201 autocall = Enum((0,1,2), default_value=0, config=True, help=
202 """
202 """
203 Make IPython automatically call any callable object even if you didn't
203 Make IPython automatically call any callable object even if you didn't
204 type explicit parentheses. For example, 'str 43' becomes 'str(43)'
204 type explicit parentheses. For example, 'str 43' becomes 'str(43)'
205 automatically. The value can be '0' to disable the feature, '1' for
205 automatically. The value can be '0' to disable the feature, '1' for
206 'smart' autocall, where it is not applied if there are no more
206 'smart' autocall, where it is not applied if there are no more
207 arguments on the line, and '2' for 'full' autocall, where all callable
207 arguments on the line, and '2' for 'full' autocall, where all callable
208 objects are automatically called (even if no arguments are present).
208 objects are automatically called (even if no arguments are present).
209 """
209 """
210 )
210 )
211 # TODO: remove all autoindent logic and put into frontends.
211 # TODO: remove all autoindent logic and put into frontends.
212 # We can't do this yet because even runlines uses the autoindent.
212 # We can't do this yet because even runlines uses the autoindent.
213 autoindent = CBool(True, config=True, help=
213 autoindent = CBool(True, config=True, help=
214 """
214 """
215 Autoindent IPython code entered interactively.
215 Autoindent IPython code entered interactively.
216 """
216 """
217 )
217 )
218 automagic = CBool(True, config=True, help=
218 automagic = CBool(True, config=True, help=
219 """
219 """
220 Enable magic commands to be called without the leading %.
220 Enable magic commands to be called without the leading %.
221 """
221 """
222 )
222 )
223 cache_size = Integer(1000, config=True, help=
223 cache_size = Integer(1000, config=True, help=
224 """
224 """
225 Set the size of the output cache. The default is 1000, you can
225 Set the size of the output cache. The default is 1000, you can
226 change it permanently in your config file. Setting it to 0 completely
226 change it permanently in your config file. Setting it to 0 completely
227 disables the caching system, and the minimum value accepted is 20 (if
227 disables the caching system, and the minimum value accepted is 20 (if
228 you provide a value less than 20, it is reset to 0 and a warning is
228 you provide a value less than 20, it is reset to 0 and a warning is
229 issued). This limit is defined because otherwise you'll spend more
229 issued). This limit is defined because otherwise you'll spend more
230 time re-flushing a too small cache than working
230 time re-flushing a too small cache than working
231 """
231 """
232 )
232 )
233 color_info = CBool(True, config=True, help=
233 color_info = CBool(True, config=True, help=
234 """
234 """
235 Use colors for displaying information about objects. Because this
235 Use colors for displaying information about objects. Because this
236 information is passed through a pager (like 'less'), and some pagers
236 information is passed through a pager (like 'less'), and some pagers
237 get confused with color codes, this capability can be turned off.
237 get confused with color codes, this capability can be turned off.
238 """
238 """
239 )
239 )
240 colors = CaselessStrEnum(('NoColor','LightBG','Linux'),
240 colors = CaselessStrEnum(('NoColor','LightBG','Linux'),
241 default_value=get_default_colors(), config=True,
241 default_value=get_default_colors(), config=True,
242 help="Set the color scheme (NoColor, Linux, or LightBG)."
242 help="Set the color scheme (NoColor, Linux, or LightBG)."
243 )
243 )
244 colors_force = CBool(False, help=
244 colors_force = CBool(False, help=
245 """
245 """
246 Force use of ANSI color codes, regardless of OS and readline
246 Force use of ANSI color codes, regardless of OS and readline
247 availability.
247 availability.
248 """
248 """
249 # FIXME: This is essentially a hack to allow ZMQShell to show colors
249 # FIXME: This is essentially a hack to allow ZMQShell to show colors
250 # without readline on Win32. When the ZMQ formatting system is
250 # without readline on Win32. When the ZMQ formatting system is
251 # refactored, this should be removed.
251 # refactored, this should be removed.
252 )
252 )
253 debug = CBool(False, config=True)
253 debug = CBool(False, config=True)
254 deep_reload = CBool(False, config=True, help=
254 deep_reload = CBool(False, config=True, help=
255 """
255 """
256 Enable deep (recursive) reloading by default. IPython can use the
256 Enable deep (recursive) reloading by default. IPython can use the
257 deep_reload module which reloads changes in modules recursively (it
257 deep_reload module which reloads changes in modules recursively (it
258 replaces the reload() function, so you don't need to change anything to
258 replaces the reload() function, so you don't need to change anything to
259 use it). deep_reload() forces a full reload of modules whose code may
259 use it). deep_reload() forces a full reload of modules whose code may
260 have changed, which the default reload() function does not. When
260 have changed, which the default reload() function does not. When
261 deep_reload is off, IPython will use the normal reload(), but
261 deep_reload is off, IPython will use the normal reload(), but
262 deep_reload will still be available as dreload().
262 deep_reload will still be available as dreload().
263 """
263 """
264 )
264 )
265 disable_failing_post_execute = CBool(False, config=True,
265 disable_failing_post_execute = CBool(False, config=True,
266 help="Don't call post-execute functions that have failed in the past."""
266 help="Don't call post-execute functions that have failed in the past."""
267 )
267 )
268 display_formatter = Instance(DisplayFormatter)
268 display_formatter = Instance(DisplayFormatter)
269 displayhook_class = Type(DisplayHook)
269 displayhook_class = Type(DisplayHook)
270 display_pub_class = Type(DisplayPublisher)
270 display_pub_class = Type(DisplayPublisher)
271
271
272 exit_now = CBool(False)
272 exit_now = CBool(False)
273 exiter = Instance(ExitAutocall)
273 exiter = Instance(ExitAutocall)
274 def _exiter_default(self):
274 def _exiter_default(self):
275 return ExitAutocall(self)
275 return ExitAutocall(self)
276 # Monotonically increasing execution counter
276 # Monotonically increasing execution counter
277 execution_count = Integer(1)
277 execution_count = Integer(1)
278 filename = Unicode("<ipython console>")
278 filename = Unicode("<ipython console>")
279 ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__
279 ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__
280
280
281 # Input splitter, to split entire cells of input into either individual
281 # Input splitter, to split entire cells of input into either individual
282 # interactive statements or whole blocks.
282 # interactive statements or whole blocks.
283 input_splitter = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
283 input_splitter = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
284 (), {})
284 (), {})
285 logstart = CBool(False, config=True, help=
285 logstart = CBool(False, config=True, help=
286 """
286 """
287 Start logging to the default log file.
287 Start logging to the default log file.
288 """
288 """
289 )
289 )
290 logfile = Unicode('', config=True, help=
290 logfile = Unicode('', config=True, help=
291 """
291 """
292 The name of the logfile to use.
292 The name of the logfile to use.
293 """
293 """
294 )
294 )
295 logappend = Unicode('', config=True, help=
295 logappend = Unicode('', config=True, help=
296 """
296 """
297 Start logging to the given file in append mode.
297 Start logging to the given file in append mode.
298 """
298 """
299 )
299 )
300 object_info_string_level = Enum((0,1,2), default_value=0,
300 object_info_string_level = Enum((0,1,2), default_value=0,
301 config=True)
301 config=True)
302 pdb = CBool(False, config=True, help=
302 pdb = CBool(False, config=True, help=
303 """
303 """
304 Automatically call the pdb debugger after every exception.
304 Automatically call the pdb debugger after every exception.
305 """
305 """
306 )
306 )
307 multiline_history = CBool(sys.platform != 'win32', config=True,
307 multiline_history = CBool(sys.platform != 'win32', config=True,
308 help="Save multi-line entries as one entry in readline history"
308 help="Save multi-line entries as one entry in readline history"
309 )
309 )
310
310
311 # deprecated prompt traits:
311 # deprecated prompt traits:
312
312
313 prompt_in1 = Unicode('In [\\#]: ', config=True,
313 prompt_in1 = Unicode('In [\\#]: ', config=True,
314 help="Deprecated, use PromptManager.in_template")
314 help="Deprecated, use PromptManager.in_template")
315 prompt_in2 = Unicode(' .\\D.: ', config=True,
315 prompt_in2 = Unicode(' .\\D.: ', config=True,
316 help="Deprecated, use PromptManager.in2_template")
316 help="Deprecated, use PromptManager.in2_template")
317 prompt_out = Unicode('Out[\\#]: ', config=True,
317 prompt_out = Unicode('Out[\\#]: ', config=True,
318 help="Deprecated, use PromptManager.out_template")
318 help="Deprecated, use PromptManager.out_template")
319 prompts_pad_left = CBool(True, config=True,
319 prompts_pad_left = CBool(True, config=True,
320 help="Deprecated, use PromptManager.justify")
320 help="Deprecated, use PromptManager.justify")
321
321
322 def _prompt_trait_changed(self, name, old, new):
322 def _prompt_trait_changed(self, name, old, new):
323 table = {
323 table = {
324 'prompt_in1' : 'in_template',
324 'prompt_in1' : 'in_template',
325 'prompt_in2' : 'in2_template',
325 'prompt_in2' : 'in2_template',
326 'prompt_out' : 'out_template',
326 'prompt_out' : 'out_template',
327 'prompts_pad_left' : 'justify',
327 'prompts_pad_left' : 'justify',
328 }
328 }
329 warn("InteractiveShell.{name} is deprecated, use PromptManager.{newname}\n".format(
329 warn("InteractiveShell.{name} is deprecated, use PromptManager.{newname}\n".format(
330 name=name, newname=table[name])
330 name=name, newname=table[name])
331 )
331 )
332 # protect against weird cases where self.config may not exist:
332 # protect against weird cases where self.config may not exist:
333 if self.config is not None:
333 if self.config is not None:
334 # propagate to corresponding PromptManager trait
334 # propagate to corresponding PromptManager trait
335 setattr(self.config.PromptManager, table[name], new)
335 setattr(self.config.PromptManager, table[name], new)
336
336
337 _prompt_in1_changed = _prompt_trait_changed
337 _prompt_in1_changed = _prompt_trait_changed
338 _prompt_in2_changed = _prompt_trait_changed
338 _prompt_in2_changed = _prompt_trait_changed
339 _prompt_out_changed = _prompt_trait_changed
339 _prompt_out_changed = _prompt_trait_changed
340 _prompt_pad_left_changed = _prompt_trait_changed
340 _prompt_pad_left_changed = _prompt_trait_changed
341
341
342 show_rewritten_input = CBool(True, config=True,
342 show_rewritten_input = CBool(True, config=True,
343 help="Show rewritten input, e.g. for autocall."
343 help="Show rewritten input, e.g. for autocall."
344 )
344 )
345
345
346 quiet = CBool(False, config=True)
346 quiet = CBool(False, config=True)
347
347
348 history_length = Integer(10000, config=True)
348 history_length = Integer(10000, config=True)
349
349
350 # The readline stuff will eventually be moved to the terminal subclass
350 # The readline stuff will eventually be moved to the terminal subclass
351 # but for now, we can't do that as readline is welded in everywhere.
351 # but for now, we can't do that as readline is welded in everywhere.
352 readline_use = CBool(True, config=True)
352 readline_use = CBool(True, config=True)
353 readline_remove_delims = Unicode('-/~', config=True)
353 readline_remove_delims = Unicode('-/~', config=True)
354 # don't use \M- bindings by default, because they
354 # don't use \M- bindings by default, because they
355 # conflict with 8-bit encodings. See gh-58,gh-88
355 # conflict with 8-bit encodings. See gh-58,gh-88
356 readline_parse_and_bind = List([
356 readline_parse_and_bind = List([
357 'tab: complete',
357 'tab: complete',
358 '"\C-l": clear-screen',
358 '"\C-l": clear-screen',
359 'set show-all-if-ambiguous on',
359 'set show-all-if-ambiguous on',
360 '"\C-o": tab-insert',
360 '"\C-o": tab-insert',
361 '"\C-r": reverse-search-history',
361 '"\C-r": reverse-search-history',
362 '"\C-s": forward-search-history',
362 '"\C-s": forward-search-history',
363 '"\C-p": history-search-backward',
363 '"\C-p": history-search-backward',
364 '"\C-n": history-search-forward',
364 '"\C-n": history-search-forward',
365 '"\e[A": history-search-backward',
365 '"\e[A": history-search-backward',
366 '"\e[B": history-search-forward',
366 '"\e[B": history-search-forward',
367 '"\C-k": kill-line',
367 '"\C-k": kill-line',
368 '"\C-u": unix-line-discard',
368 '"\C-u": unix-line-discard',
369 ], allow_none=False, config=True)
369 ], allow_none=False, config=True)
370
370
371 ast_node_interactivity = Enum(['all', 'last', 'last_expr', 'none'],
371 ast_node_interactivity = Enum(['all', 'last', 'last_expr', 'none'],
372 default_value='last_expr', config=True,
372 default_value='last_expr', config=True,
373 help="""
373 help="""
374 'all', 'last', 'last_expr' or 'none'," specifying which nodes should be
374 'all', 'last', 'last_expr' or 'none'," specifying which nodes should be
375 run interactively (displaying output from expressions).""")
375 run interactively (displaying output from expressions).""")
376
376
377 # TODO: this part of prompt management should be moved to the frontends.
377 # TODO: this part of prompt management should be moved to the frontends.
378 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
378 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
379 separate_in = SeparateUnicode('\n', config=True)
379 separate_in = SeparateUnicode('\n', config=True)
380 separate_out = SeparateUnicode('', config=True)
380 separate_out = SeparateUnicode('', config=True)
381 separate_out2 = SeparateUnicode('', config=True)
381 separate_out2 = SeparateUnicode('', config=True)
382 wildcards_case_sensitive = CBool(True, config=True)
382 wildcards_case_sensitive = CBool(True, config=True)
383 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
383 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
384 default_value='Context', config=True)
384 default_value='Context', config=True)
385
385
386 # Subcomponents of InteractiveShell
386 # Subcomponents of InteractiveShell
387 alias_manager = Instance('IPython.core.alias.AliasManager')
387 alias_manager = Instance('IPython.core.alias.AliasManager')
388 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
388 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
389 builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap')
389 builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap')
390 display_trap = Instance('IPython.core.display_trap.DisplayTrap')
390 display_trap = Instance('IPython.core.display_trap.DisplayTrap')
391 extension_manager = Instance('IPython.core.extensions.ExtensionManager')
391 extension_manager = Instance('IPython.core.extensions.ExtensionManager')
392 plugin_manager = Instance('IPython.core.plugin.PluginManager')
392 plugin_manager = Instance('IPython.core.plugin.PluginManager')
393 payload_manager = Instance('IPython.core.payload.PayloadManager')
393 payload_manager = Instance('IPython.core.payload.PayloadManager')
394 history_manager = Instance('IPython.core.history.HistoryManager')
394 history_manager = Instance('IPython.core.history.HistoryManager')
395 magics_manager = Instance('IPython.core.magic.MagicsManager')
395 magics_manager = Instance('IPython.core.magic.MagicsManager')
396
396
397 profile_dir = Instance('IPython.core.application.ProfileDir')
397 profile_dir = Instance('IPython.core.application.ProfileDir')
398 @property
398 @property
399 def profile(self):
399 def profile(self):
400 if self.profile_dir is not None:
400 if self.profile_dir is not None:
401 name = os.path.basename(self.profile_dir.location)
401 name = os.path.basename(self.profile_dir.location)
402 return name.replace('profile_','')
402 return name.replace('profile_','')
403
403
404
404
405 # Private interface
405 # Private interface
406 _post_execute = Instance(dict)
406 _post_execute = Instance(dict)
407
407
408 def __init__(self, config=None, ipython_dir=None, profile_dir=None,
408 def __init__(self, config=None, ipython_dir=None, profile_dir=None,
409 user_module=None, user_ns=None,
409 user_module=None, user_ns=None,
410 custom_exceptions=((), None)):
410 custom_exceptions=((), None)):
411
411
412 # This is where traits with a config_key argument are updated
412 # This is where traits with a config_key argument are updated
413 # from the values on config.
413 # from the values on config.
414 super(InteractiveShell, self).__init__(config=config)
414 super(InteractiveShell, self).__init__(config=config)
415 self.configurables = [self]
415 self.configurables = [self]
416
416
417 # These are relatively independent and stateless
417 # These are relatively independent and stateless
418 self.init_ipython_dir(ipython_dir)
418 self.init_ipython_dir(ipython_dir)
419 self.init_profile_dir(profile_dir)
419 self.init_profile_dir(profile_dir)
420 self.init_instance_attrs()
420 self.init_instance_attrs()
421 self.init_environment()
421 self.init_environment()
422
422
423 # Check if we're in a virtualenv, and set up sys.path.
423 # Check if we're in a virtualenv, and set up sys.path.
424 self.init_virtualenv()
424 self.init_virtualenv()
425
425
426 # Create namespaces (user_ns, user_global_ns, etc.)
426 # Create namespaces (user_ns, user_global_ns, etc.)
427 self.init_create_namespaces(user_module, user_ns)
427 self.init_create_namespaces(user_module, user_ns)
428 # This has to be done after init_create_namespaces because it uses
428 # This has to be done after init_create_namespaces because it uses
429 # something in self.user_ns, but before init_sys_modules, which
429 # something in self.user_ns, but before init_sys_modules, which
430 # is the first thing to modify sys.
430 # is the first thing to modify sys.
431 # TODO: When we override sys.stdout and sys.stderr before this class
431 # TODO: When we override sys.stdout and sys.stderr before this class
432 # is created, we are saving the overridden ones here. Not sure if this
432 # is created, we are saving the overridden ones here. Not sure if this
433 # is what we want to do.
433 # is what we want to do.
434 self.save_sys_module_state()
434 self.save_sys_module_state()
435 self.init_sys_modules()
435 self.init_sys_modules()
436
436
437 # While we're trying to have each part of the code directly access what
437 # While we're trying to have each part of the code directly access what
438 # it needs without keeping redundant references to objects, we have too
438 # it needs without keeping redundant references to objects, we have too
439 # much legacy code that expects ip.db to exist.
439 # much legacy code that expects ip.db to exist.
440 self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))
440 self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))
441
441
442 self.init_history()
442 self.init_history()
443 self.init_encoding()
443 self.init_encoding()
444 self.init_prefilter()
444 self.init_prefilter()
445
445
446 self.init_syntax_highlighting()
446 self.init_syntax_highlighting()
447 self.init_hooks()
447 self.init_hooks()
448 self.init_pushd_popd_magic()
448 self.init_pushd_popd_magic()
449 # self.init_traceback_handlers use to be here, but we moved it below
449 # self.init_traceback_handlers use to be here, but we moved it below
450 # because it and init_io have to come after init_readline.
450 # because it and init_io have to come after init_readline.
451 self.init_user_ns()
451 self.init_user_ns()
452 self.init_logger()
452 self.init_logger()
453 self.init_alias()
453 self.init_alias()
454 self.init_builtins()
454 self.init_builtins()
455
455
456 # pre_config_initialization
456 # pre_config_initialization
457
457
458 # The next section should contain everything that was in ipmaker.
458 # The next section should contain everything that was in ipmaker.
459 self.init_logstart()
459 self.init_logstart()
460
460
461 # The following was in post_config_initialization
461 # The following was in post_config_initialization
462 self.init_inspector()
462 self.init_inspector()
463 # init_readline() must come before init_io(), because init_io uses
463 # init_readline() must come before init_io(), because init_io uses
464 # readline related things.
464 # readline related things.
465 self.init_readline()
465 self.init_readline()
466 # We save this here in case user code replaces raw_input, but it needs
466 # We save this here in case user code replaces raw_input, but it needs
467 # to be after init_readline(), because PyPy's readline works by replacing
467 # to be after init_readline(), because PyPy's readline works by replacing
468 # raw_input.
468 # raw_input.
469 if py3compat.PY3:
469 if py3compat.PY3:
470 self.raw_input_original = input
470 self.raw_input_original = input
471 else:
471 else:
472 self.raw_input_original = raw_input
472 self.raw_input_original = raw_input
473 # init_completer must come after init_readline, because it needs to
473 # init_completer must come after init_readline, because it needs to
474 # know whether readline is present or not system-wide to configure the
474 # know whether readline is present or not system-wide to configure the
475 # completers, since the completion machinery can now operate
475 # completers, since the completion machinery can now operate
476 # independently of readline (e.g. over the network)
476 # independently of readline (e.g. over the network)
477 self.init_completer()
477 self.init_completer()
478 # TODO: init_io() needs to happen before init_traceback handlers
478 # TODO: init_io() needs to happen before init_traceback handlers
479 # because the traceback handlers hardcode the stdout/stderr streams.
479 # because the traceback handlers hardcode the stdout/stderr streams.
480 # This logic in in debugger.Pdb and should eventually be changed.
480 # This logic in in debugger.Pdb and should eventually be changed.
481 self.init_io()
481 self.init_io()
482 self.init_traceback_handlers(custom_exceptions)
482 self.init_traceback_handlers(custom_exceptions)
483 self.init_prompts()
483 self.init_prompts()
484 self.init_display_formatter()
484 self.init_display_formatter()
485 self.init_display_pub()
485 self.init_display_pub()
486 self.init_displayhook()
486 self.init_displayhook()
487 self.init_reload_doctest()
487 self.init_reload_doctest()
488 self.init_magics()
488 self.init_magics()
489 self.init_pdb()
489 self.init_pdb()
490 self.init_extension_manager()
490 self.init_extension_manager()
491 self.init_plugin_manager()
491 self.init_plugin_manager()
492 self.init_payload()
492 self.init_payload()
493 self.hooks.late_startup_hook()
493 self.hooks.late_startup_hook()
494 atexit.register(self.atexit_operations)
494 atexit.register(self.atexit_operations)
495
495
496 def get_ipython(self):
496 def get_ipython(self):
497 """Return the currently running IPython instance."""
497 """Return the currently running IPython instance."""
498 return self
498 return self
499
499
500 #-------------------------------------------------------------------------
500 #-------------------------------------------------------------------------
501 # Trait changed handlers
501 # Trait changed handlers
502 #-------------------------------------------------------------------------
502 #-------------------------------------------------------------------------
503
503
504 def _ipython_dir_changed(self, name, new):
504 def _ipython_dir_changed(self, name, new):
505 if not os.path.isdir(new):
505 if not os.path.isdir(new):
506 os.makedirs(new, mode = 0777)
506 os.makedirs(new, mode = 0777)
507
507
508 def set_autoindent(self,value=None):
508 def set_autoindent(self,value=None):
509 """Set the autoindent flag, checking for readline support.
509 """Set the autoindent flag, checking for readline support.
510
510
511 If called with no arguments, it acts as a toggle."""
511 If called with no arguments, it acts as a toggle."""
512
512
513 if value != 0 and not self.has_readline:
513 if value != 0 and not self.has_readline:
514 if os.name == 'posix':
514 if os.name == 'posix':
515 warn("The auto-indent feature requires the readline library")
515 warn("The auto-indent feature requires the readline library")
516 self.autoindent = 0
516 self.autoindent = 0
517 return
517 return
518 if value is None:
518 if value is None:
519 self.autoindent = not self.autoindent
519 self.autoindent = not self.autoindent
520 else:
520 else:
521 self.autoindent = value
521 self.autoindent = value
522
522
523 #-------------------------------------------------------------------------
523 #-------------------------------------------------------------------------
524 # init_* methods called by __init__
524 # init_* methods called by __init__
525 #-------------------------------------------------------------------------
525 #-------------------------------------------------------------------------
526
526
527 def init_ipython_dir(self, ipython_dir):
527 def init_ipython_dir(self, ipython_dir):
528 if ipython_dir is not None:
528 if ipython_dir is not None:
529 self.ipython_dir = ipython_dir
529 self.ipython_dir = ipython_dir
530 return
530 return
531
531
532 self.ipython_dir = get_ipython_dir()
532 self.ipython_dir = get_ipython_dir()
533
533
534 def init_profile_dir(self, profile_dir):
534 def init_profile_dir(self, profile_dir):
535 if profile_dir is not None:
535 if profile_dir is not None:
536 self.profile_dir = profile_dir
536 self.profile_dir = profile_dir
537 return
537 return
538 self.profile_dir =\
538 self.profile_dir =\
539 ProfileDir.create_profile_dir_by_name(self.ipython_dir, 'default')
539 ProfileDir.create_profile_dir_by_name(self.ipython_dir, 'default')
540
540
541 def init_instance_attrs(self):
541 def init_instance_attrs(self):
542 self.more = False
542 self.more = False
543
543
544 # command compiler
544 # command compiler
545 self.compile = CachingCompiler()
545 self.compile = CachingCompiler()
546
546
547 # Make an empty namespace, which extension writers can rely on both
547 # Make an empty namespace, which extension writers can rely on both
548 # existing and NEVER being used by ipython itself. This gives them a
548 # existing and NEVER being used by ipython itself. This gives them a
549 # convenient location for storing additional information and state
549 # convenient location for storing additional information and state
550 # their extensions may require, without fear of collisions with other
550 # their extensions may require, without fear of collisions with other
551 # ipython names that may develop later.
551 # ipython names that may develop later.
552 self.meta = Struct()
552 self.meta = Struct()
553
553
554 # Temporary files used for various purposes. Deleted at exit.
554 # Temporary files used for various purposes. Deleted at exit.
555 self.tempfiles = []
555 self.tempfiles = []
556
556
557 # Keep track of readline usage (later set by init_readline)
557 # Keep track of readline usage (later set by init_readline)
558 self.has_readline = False
558 self.has_readline = False
559
559
560 # keep track of where we started running (mainly for crash post-mortem)
560 # keep track of where we started running (mainly for crash post-mortem)
561 # This is not being used anywhere currently.
561 # This is not being used anywhere currently.
562 self.starting_dir = os.getcwdu()
562 self.starting_dir = os.getcwdu()
563
563
564 # Indentation management
564 # Indentation management
565 self.indent_current_nsp = 0
565 self.indent_current_nsp = 0
566
566
567 # Dict to track post-execution functions that have been registered
567 # Dict to track post-execution functions that have been registered
568 self._post_execute = {}
568 self._post_execute = {}
569
569
570 def init_environment(self):
570 def init_environment(self):
571 """Any changes we need to make to the user's environment."""
571 """Any changes we need to make to the user's environment."""
572 pass
572 pass
573
573
574 def init_encoding(self):
574 def init_encoding(self):
575 # Get system encoding at startup time. Certain terminals (like Emacs
575 # Get system encoding at startup time. Certain terminals (like Emacs
576 # under Win32 have it set to None, and we need to have a known valid
576 # under Win32 have it set to None, and we need to have a known valid
577 # encoding to use in the raw_input() method
577 # encoding to use in the raw_input() method
578 try:
578 try:
579 self.stdin_encoding = sys.stdin.encoding or 'ascii'
579 self.stdin_encoding = sys.stdin.encoding or 'ascii'
580 except AttributeError:
580 except AttributeError:
581 self.stdin_encoding = 'ascii'
581 self.stdin_encoding = 'ascii'
582
582
583 def init_syntax_highlighting(self):
583 def init_syntax_highlighting(self):
584 # Python source parser/formatter for syntax highlighting
584 # Python source parser/formatter for syntax highlighting
585 pyformat = PyColorize.Parser().format
585 pyformat = PyColorize.Parser().format
586 self.pycolorize = lambda src: pyformat(src,'str',self.colors)
586 self.pycolorize = lambda src: pyformat(src,'str',self.colors)
587
587
588 def init_pushd_popd_magic(self):
588 def init_pushd_popd_magic(self):
589 # for pushd/popd management
589 # for pushd/popd management
590 self.home_dir = get_home_dir()
590 self.home_dir = get_home_dir()
591
591
592 self.dir_stack = []
592 self.dir_stack = []
593
593
594 def init_logger(self):
594 def init_logger(self):
595 self.logger = Logger(self.home_dir, logfname='ipython_log.py',
595 self.logger = Logger(self.home_dir, logfname='ipython_log.py',
596 logmode='rotate')
596 logmode='rotate')
597
597
598 def init_logstart(self):
598 def init_logstart(self):
599 """Initialize logging in case it was requested at the command line.
599 """Initialize logging in case it was requested at the command line.
600 """
600 """
601 if self.logappend:
601 if self.logappend:
602 self.magic('logstart %s append' % self.logappend)
602 self.magic('logstart %s append' % self.logappend)
603 elif self.logfile:
603 elif self.logfile:
604 self.magic('logstart %' % self.logfile)
604 self.magic('logstart %' % self.logfile)
605 elif self.logstart:
605 elif self.logstart:
606 self.magic('logstart')
606 self.magic('logstart')
607
607
608 def init_builtins(self):
608 def init_builtins(self):
609 # A single, static flag that we set to True. Its presence indicates
609 # A single, static flag that we set to True. Its presence indicates
610 # that an IPython shell has been created, and we make no attempts at
610 # that an IPython shell has been created, and we make no attempts at
611 # removing on exit or representing the existence of more than one
611 # removing on exit or representing the existence of more than one
612 # IPython at a time.
612 # IPython at a time.
613 builtin_mod.__dict__['__IPYTHON__'] = True
613 builtin_mod.__dict__['__IPYTHON__'] = True
614
614
615 # In 0.11 we introduced '__IPYTHON__active' as an integer we'd try to
615 # In 0.11 we introduced '__IPYTHON__active' as an integer we'd try to
616 # manage on enter/exit, but with all our shells it's virtually
616 # manage on enter/exit, but with all our shells it's virtually
617 # impossible to get all the cases right. We're leaving the name in for
617 # impossible to get all the cases right. We're leaving the name in for
618 # those who adapted their codes to check for this flag, but will
618 # those who adapted their codes to check for this flag, but will
619 # eventually remove it after a few more releases.
619 # eventually remove it after a few more releases.
620 builtin_mod.__dict__['__IPYTHON__active'] = \
620 builtin_mod.__dict__['__IPYTHON__active'] = \
621 'Deprecated, check for __IPYTHON__'
621 'Deprecated, check for __IPYTHON__'
622
622
623 self.builtin_trap = BuiltinTrap(shell=self)
623 self.builtin_trap = BuiltinTrap(shell=self)
624
624
625 def init_inspector(self):
625 def init_inspector(self):
626 # Object inspector
626 # Object inspector
627 self.inspector = oinspect.Inspector(oinspect.InspectColors,
627 self.inspector = oinspect.Inspector(oinspect.InspectColors,
628 PyColorize.ANSICodeColors,
628 PyColorize.ANSICodeColors,
629 'NoColor',
629 'NoColor',
630 self.object_info_string_level)
630 self.object_info_string_level)
631
631
632 def init_io(self):
632 def init_io(self):
633 # This will just use sys.stdout and sys.stderr. If you want to
633 # This will just use sys.stdout and sys.stderr. If you want to
634 # override sys.stdout and sys.stderr themselves, you need to do that
634 # override sys.stdout and sys.stderr themselves, you need to do that
635 # *before* instantiating this class, because io holds onto
635 # *before* instantiating this class, because io holds onto
636 # references to the underlying streams.
636 # references to the underlying streams.
637 if sys.platform == 'win32' and self.has_readline:
637 if sys.platform == 'win32' and self.has_readline:
638 io.stdout = io.stderr = io.IOStream(self.readline._outputfile)
638 io.stdout = io.stderr = io.IOStream(self.readline._outputfile)
639 else:
639 else:
640 io.stdout = io.IOStream(sys.stdout)
640 io.stdout = io.IOStream(sys.stdout)
641 io.stderr = io.IOStream(sys.stderr)
641 io.stderr = io.IOStream(sys.stderr)
642
642
643 def init_prompts(self):
643 def init_prompts(self):
644 self.prompt_manager = PromptManager(shell=self, config=self.config)
644 self.prompt_manager = PromptManager(shell=self, config=self.config)
645 self.configurables.append(self.prompt_manager)
645 self.configurables.append(self.prompt_manager)
646 # Set system prompts, so that scripts can decide if they are running
646 # Set system prompts, so that scripts can decide if they are running
647 # interactively.
647 # interactively.
648 sys.ps1 = 'In : '
648 sys.ps1 = 'In : '
649 sys.ps2 = '...: '
649 sys.ps2 = '...: '
650 sys.ps3 = 'Out: '
650 sys.ps3 = 'Out: '
651
651
652 def init_display_formatter(self):
652 def init_display_formatter(self):
653 self.display_formatter = DisplayFormatter(config=self.config)
653 self.display_formatter = DisplayFormatter(config=self.config)
654 self.configurables.append(self.display_formatter)
654 self.configurables.append(self.display_formatter)
655
655
656 def init_display_pub(self):
656 def init_display_pub(self):
657 self.display_pub = self.display_pub_class(config=self.config)
657 self.display_pub = self.display_pub_class(config=self.config)
658 self.configurables.append(self.display_pub)
658 self.configurables.append(self.display_pub)
659
659
660 def init_displayhook(self):
660 def init_displayhook(self):
661 # Initialize displayhook, set in/out prompts and printing system
661 # Initialize displayhook, set in/out prompts and printing system
662 self.displayhook = self.displayhook_class(
662 self.displayhook = self.displayhook_class(
663 config=self.config,
663 config=self.config,
664 shell=self,
664 shell=self,
665 cache_size=self.cache_size,
665 cache_size=self.cache_size,
666 )
666 )
667 self.configurables.append(self.displayhook)
667 self.configurables.append(self.displayhook)
668 # This is a context manager that installs/revmoes the displayhook at
668 # This is a context manager that installs/revmoes the displayhook at
669 # the appropriate time.
669 # the appropriate time.
670 self.display_trap = DisplayTrap(hook=self.displayhook)
670 self.display_trap = DisplayTrap(hook=self.displayhook)
671
671
672 def init_reload_doctest(self):
672 def init_reload_doctest(self):
673 # Do a proper resetting of doctest, including the necessary displayhook
673 # Do a proper resetting of doctest, including the necessary displayhook
674 # monkeypatching
674 # monkeypatching
675 try:
675 try:
676 doctest_reload()
676 doctest_reload()
677 except ImportError:
677 except ImportError:
678 warn("doctest module does not exist.")
678 warn("doctest module does not exist.")
679
679
680 def init_virtualenv(self):
680 def init_virtualenv(self):
681 """Add a virtualenv to sys.path so the user can import modules from it.
681 """Add a virtualenv to sys.path so the user can import modules from it.
682 This isn't perfect: it doesn't use the Python interpreter with which the
682 This isn't perfect: it doesn't use the Python interpreter with which the
683 virtualenv was built, and it ignores the --no-site-packages option. A
683 virtualenv was built, and it ignores the --no-site-packages option. A
684 warning will appear suggesting the user installs IPython in the
684 warning will appear suggesting the user installs IPython in the
685 virtualenv, but for many cases, it probably works well enough.
685 virtualenv, but for many cases, it probably works well enough.
686
686
687 Adapted from code snippets online.
687 Adapted from code snippets online.
688
688
689 http://blog.ufsoft.org/2009/1/29/ipython-and-virtualenv
689 http://blog.ufsoft.org/2009/1/29/ipython-and-virtualenv
690 """
690 """
691 if 'VIRTUAL_ENV' not in os.environ:
691 if 'VIRTUAL_ENV' not in os.environ:
692 # Not in a virtualenv
692 # Not in a virtualenv
693 return
693 return
694
694
695 if sys.executable.startswith(os.environ['VIRTUAL_ENV']):
695 if sys.executable.startswith(os.environ['VIRTUAL_ENV']):
696 # Running properly in the virtualenv, don't need to do anything
696 # Running properly in the virtualenv, don't need to do anything
697 return
697 return
698
698
699 warn("Attempting to work in a virtualenv. If you encounter problems, please "
699 warn("Attempting to work in a virtualenv. If you encounter problems, please "
700 "install IPython inside the virtualenv.\n")
700 "install IPython inside the virtualenv.\n")
701 if sys.platform == "win32":
701 if sys.platform == "win32":
702 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'Lib', 'site-packages')
702 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'Lib', 'site-packages')
703 else:
703 else:
704 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'lib',
704 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'lib',
705 'python%d.%d' % sys.version_info[:2], 'site-packages')
705 'python%d.%d' % sys.version_info[:2], 'site-packages')
706
706
707 import site
707 import site
708 sys.path.insert(0, virtual_env)
708 sys.path.insert(0, virtual_env)
709 site.addsitedir(virtual_env)
709 site.addsitedir(virtual_env)
710
710
711 #-------------------------------------------------------------------------
711 #-------------------------------------------------------------------------
712 # Things related to injections into the sys module
712 # Things related to injections into the sys module
713 #-------------------------------------------------------------------------
713 #-------------------------------------------------------------------------
714
714
715 def save_sys_module_state(self):
715 def save_sys_module_state(self):
716 """Save the state of hooks in the sys module.
716 """Save the state of hooks in the sys module.
717
717
718 This has to be called after self.user_module is created.
718 This has to be called after self.user_module is created.
719 """
719 """
720 self._orig_sys_module_state = {}
720 self._orig_sys_module_state = {}
721 self._orig_sys_module_state['stdin'] = sys.stdin
721 self._orig_sys_module_state['stdin'] = sys.stdin
722 self._orig_sys_module_state['stdout'] = sys.stdout
722 self._orig_sys_module_state['stdout'] = sys.stdout
723 self._orig_sys_module_state['stderr'] = sys.stderr
723 self._orig_sys_module_state['stderr'] = sys.stderr
724 self._orig_sys_module_state['excepthook'] = sys.excepthook
724 self._orig_sys_module_state['excepthook'] = sys.excepthook
725 self._orig_sys_modules_main_name = self.user_module.__name__
725 self._orig_sys_modules_main_name = self.user_module.__name__
726 self._orig_sys_modules_main_mod = sys.modules.get(self.user_module.__name__)
726 self._orig_sys_modules_main_mod = sys.modules.get(self.user_module.__name__)
727
727
728 def restore_sys_module_state(self):
728 def restore_sys_module_state(self):
729 """Restore the state of the sys module."""
729 """Restore the state of the sys module."""
730 try:
730 try:
731 for k, v in self._orig_sys_module_state.iteritems():
731 for k, v in self._orig_sys_module_state.iteritems():
732 setattr(sys, k, v)
732 setattr(sys, k, v)
733 except AttributeError:
733 except AttributeError:
734 pass
734 pass
735 # Reset what what done in self.init_sys_modules
735 # Reset what what done in self.init_sys_modules
736 if self._orig_sys_modules_main_mod is not None:
736 if self._orig_sys_modules_main_mod is not None:
737 sys.modules[self._orig_sys_modules_main_name] = self._orig_sys_modules_main_mod
737 sys.modules[self._orig_sys_modules_main_name] = self._orig_sys_modules_main_mod
738
738
739 #-------------------------------------------------------------------------
739 #-------------------------------------------------------------------------
740 # Things related to hooks
740 # Things related to hooks
741 #-------------------------------------------------------------------------
741 #-------------------------------------------------------------------------
742
742
743 def init_hooks(self):
743 def init_hooks(self):
744 # hooks holds pointers used for user-side customizations
744 # hooks holds pointers used for user-side customizations
745 self.hooks = Struct()
745 self.hooks = Struct()
746
746
747 self.strdispatchers = {}
747 self.strdispatchers = {}
748
748
749 # Set all default hooks, defined in the IPython.hooks module.
749 # Set all default hooks, defined in the IPython.hooks module.
750 hooks = IPython.core.hooks
750 hooks = IPython.core.hooks
751 for hook_name in hooks.__all__:
751 for hook_name in hooks.__all__:
752 # default hooks have priority 100, i.e. low; user hooks should have
752 # default hooks have priority 100, i.e. low; user hooks should have
753 # 0-100 priority
753 # 0-100 priority
754 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
754 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
755
755
756 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
756 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
757 """set_hook(name,hook) -> sets an internal IPython hook.
757 """set_hook(name,hook) -> sets an internal IPython hook.
758
758
759 IPython exposes some of its internal API as user-modifiable hooks. By
759 IPython exposes some of its internal API as user-modifiable hooks. By
760 adding your function to one of these hooks, you can modify IPython's
760 adding your function to one of these hooks, you can modify IPython's
761 behavior to call at runtime your own routines."""
761 behavior to call at runtime your own routines."""
762
762
763 # At some point in the future, this should validate the hook before it
763 # At some point in the future, this should validate the hook before it
764 # accepts it. Probably at least check that the hook takes the number
764 # accepts it. Probably at least check that the hook takes the number
765 # of args it's supposed to.
765 # of args it's supposed to.
766
766
767 f = types.MethodType(hook,self)
767 f = types.MethodType(hook,self)
768
768
769 # check if the hook is for strdispatcher first
769 # check if the hook is for strdispatcher first
770 if str_key is not None:
770 if str_key is not None:
771 sdp = self.strdispatchers.get(name, StrDispatch())
771 sdp = self.strdispatchers.get(name, StrDispatch())
772 sdp.add_s(str_key, f, priority )
772 sdp.add_s(str_key, f, priority )
773 self.strdispatchers[name] = sdp
773 self.strdispatchers[name] = sdp
774 return
774 return
775 if re_key is not None:
775 if re_key is not None:
776 sdp = self.strdispatchers.get(name, StrDispatch())
776 sdp = self.strdispatchers.get(name, StrDispatch())
777 sdp.add_re(re.compile(re_key), f, priority )
777 sdp.add_re(re.compile(re_key), f, priority )
778 self.strdispatchers[name] = sdp
778 self.strdispatchers[name] = sdp
779 return
779 return
780
780
781 dp = getattr(self.hooks, name, None)
781 dp = getattr(self.hooks, name, None)
782 if name not in IPython.core.hooks.__all__:
782 if name not in IPython.core.hooks.__all__:
783 print "Warning! Hook '%s' is not one of %s" % \
783 print "Warning! Hook '%s' is not one of %s" % \
784 (name, IPython.core.hooks.__all__ )
784 (name, IPython.core.hooks.__all__ )
785 if not dp:
785 if not dp:
786 dp = IPython.core.hooks.CommandChainDispatcher()
786 dp = IPython.core.hooks.CommandChainDispatcher()
787
787
788 try:
788 try:
789 dp.add(f,priority)
789 dp.add(f,priority)
790 except AttributeError:
790 except AttributeError:
791 # it was not commandchain, plain old func - replace
791 # it was not commandchain, plain old func - replace
792 dp = f
792 dp = f
793
793
794 setattr(self.hooks,name, dp)
794 setattr(self.hooks,name, dp)
795
795
796 def register_post_execute(self, func):
796 def register_post_execute(self, func):
797 """Register a function for calling after code execution.
797 """Register a function for calling after code execution.
798 """
798 """
799 if not callable(func):
799 if not callable(func):
800 raise ValueError('argument %s must be callable' % func)
800 raise ValueError('argument %s must be callable' % func)
801 self._post_execute[func] = True
801 self._post_execute[func] = True
802
802
803 #-------------------------------------------------------------------------
803 #-------------------------------------------------------------------------
804 # Things related to the "main" module
804 # Things related to the "main" module
805 #-------------------------------------------------------------------------
805 #-------------------------------------------------------------------------
806
806
807 def new_main_mod(self,ns=None):
807 def new_main_mod(self,ns=None):
808 """Return a new 'main' module object for user code execution.
808 """Return a new 'main' module object for user code execution.
809 """
809 """
810 main_mod = self._user_main_module
810 main_mod = self._user_main_module
811 init_fakemod_dict(main_mod,ns)
811 init_fakemod_dict(main_mod,ns)
812 return main_mod
812 return main_mod
813
813
814 def cache_main_mod(self,ns,fname):
814 def cache_main_mod(self,ns,fname):
815 """Cache a main module's namespace.
815 """Cache a main module's namespace.
816
816
817 When scripts are executed via %run, we must keep a reference to the
817 When scripts are executed via %run, we must keep a reference to the
818 namespace of their __main__ module (a FakeModule instance) around so
818 namespace of their __main__ module (a FakeModule instance) around so
819 that Python doesn't clear it, rendering objects defined therein
819 that Python doesn't clear it, rendering objects defined therein
820 useless.
820 useless.
821
821
822 This method keeps said reference in a private dict, keyed by the
822 This method keeps said reference in a private dict, keyed by the
823 absolute path of the module object (which corresponds to the script
823 absolute path of the module object (which corresponds to the script
824 path). This way, for multiple executions of the same script we only
824 path). This way, for multiple executions of the same script we only
825 keep one copy of the namespace (the last one), thus preventing memory
825 keep one copy of the namespace (the last one), thus preventing memory
826 leaks from old references while allowing the objects from the last
826 leaks from old references while allowing the objects from the last
827 execution to be accessible.
827 execution to be accessible.
828
828
829 Note: we can not allow the actual FakeModule instances to be deleted,
829 Note: we can not allow the actual FakeModule instances to be deleted,
830 because of how Python tears down modules (it hard-sets all their
830 because of how Python tears down modules (it hard-sets all their
831 references to None without regard for reference counts). This method
831 references to None without regard for reference counts). This method
832 must therefore make a *copy* of the given namespace, to allow the
832 must therefore make a *copy* of the given namespace, to allow the
833 original module's __dict__ to be cleared and reused.
833 original module's __dict__ to be cleared and reused.
834
834
835
835
836 Parameters
836 Parameters
837 ----------
837 ----------
838 ns : a namespace (a dict, typically)
838 ns : a namespace (a dict, typically)
839
839
840 fname : str
840 fname : str
841 Filename associated with the namespace.
841 Filename associated with the namespace.
842
842
843 Examples
843 Examples
844 --------
844 --------
845
845
846 In [10]: import IPython
846 In [10]: import IPython
847
847
848 In [11]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
848 In [11]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
849
849
850 In [12]: IPython.__file__ in _ip._main_ns_cache
850 In [12]: IPython.__file__ in _ip._main_ns_cache
851 Out[12]: True
851 Out[12]: True
852 """
852 """
853 self._main_ns_cache[os.path.abspath(fname)] = ns.copy()
853 self._main_ns_cache[os.path.abspath(fname)] = ns.copy()
854
854
855 def clear_main_mod_cache(self):
855 def clear_main_mod_cache(self):
856 """Clear the cache of main modules.
856 """Clear the cache of main modules.
857
857
858 Mainly for use by utilities like %reset.
858 Mainly for use by utilities like %reset.
859
859
860 Examples
860 Examples
861 --------
861 --------
862
862
863 In [15]: import IPython
863 In [15]: import IPython
864
864
865 In [16]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
865 In [16]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
866
866
867 In [17]: len(_ip._main_ns_cache) > 0
867 In [17]: len(_ip._main_ns_cache) > 0
868 Out[17]: True
868 Out[17]: True
869
869
870 In [18]: _ip.clear_main_mod_cache()
870 In [18]: _ip.clear_main_mod_cache()
871
871
872 In [19]: len(_ip._main_ns_cache) == 0
872 In [19]: len(_ip._main_ns_cache) == 0
873 Out[19]: True
873 Out[19]: True
874 """
874 """
875 self._main_ns_cache.clear()
875 self._main_ns_cache.clear()
876
876
877 #-------------------------------------------------------------------------
877 #-------------------------------------------------------------------------
878 # Things related to debugging
878 # Things related to debugging
879 #-------------------------------------------------------------------------
879 #-------------------------------------------------------------------------
880
880
881 def init_pdb(self):
881 def init_pdb(self):
882 # Set calling of pdb on exceptions
882 # Set calling of pdb on exceptions
883 # self.call_pdb is a property
883 # self.call_pdb is a property
884 self.call_pdb = self.pdb
884 self.call_pdb = self.pdb
885
885
886 def _get_call_pdb(self):
886 def _get_call_pdb(self):
887 return self._call_pdb
887 return self._call_pdb
888
888
889 def _set_call_pdb(self,val):
889 def _set_call_pdb(self,val):
890
890
891 if val not in (0,1,False,True):
891 if val not in (0,1,False,True):
892 raise ValueError,'new call_pdb value must be boolean'
892 raise ValueError,'new call_pdb value must be boolean'
893
893
894 # store value in instance
894 # store value in instance
895 self._call_pdb = val
895 self._call_pdb = val
896
896
897 # notify the actual exception handlers
897 # notify the actual exception handlers
898 self.InteractiveTB.call_pdb = val
898 self.InteractiveTB.call_pdb = val
899
899
900 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
900 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
901 'Control auto-activation of pdb at exceptions')
901 'Control auto-activation of pdb at exceptions')
902
902
903 def debugger(self,force=False):
903 def debugger(self,force=False):
904 """Call the pydb/pdb debugger.
904 """Call the pydb/pdb debugger.
905
905
906 Keywords:
906 Keywords:
907
907
908 - force(False): by default, this routine checks the instance call_pdb
908 - force(False): by default, this routine checks the instance call_pdb
909 flag and does not actually invoke the debugger if the flag is false.
909 flag and does not actually invoke the debugger if the flag is false.
910 The 'force' option forces the debugger to activate even if the flag
910 The 'force' option forces the debugger to activate even if the flag
911 is false.
911 is false.
912 """
912 """
913
913
914 if not (force or self.call_pdb):
914 if not (force or self.call_pdb):
915 return
915 return
916
916
917 if not hasattr(sys,'last_traceback'):
917 if not hasattr(sys,'last_traceback'):
918 error('No traceback has been produced, nothing to debug.')
918 error('No traceback has been produced, nothing to debug.')
919 return
919 return
920
920
921 # use pydb if available
921 # use pydb if available
922 if debugger.has_pydb:
922 if debugger.has_pydb:
923 from pydb import pm
923 from pydb import pm
924 else:
924 else:
925 # fallback to our internal debugger
925 # fallback to our internal debugger
926 pm = lambda : self.InteractiveTB.debugger(force=True)
926 pm = lambda : self.InteractiveTB.debugger(force=True)
927
927
928 with self.readline_no_record:
928 with self.readline_no_record:
929 pm()
929 pm()
930
930
931 #-------------------------------------------------------------------------
931 #-------------------------------------------------------------------------
932 # Things related to IPython's various namespaces
932 # Things related to IPython's various namespaces
933 #-------------------------------------------------------------------------
933 #-------------------------------------------------------------------------
934 default_user_namespaces = True
934 default_user_namespaces = True
935
935
936 def init_create_namespaces(self, user_module=None, user_ns=None):
936 def init_create_namespaces(self, user_module=None, user_ns=None):
937 # Create the namespace where the user will operate. user_ns is
937 # Create the namespace where the user will operate. user_ns is
938 # normally the only one used, and it is passed to the exec calls as
938 # normally the only one used, and it is passed to the exec calls as
939 # the locals argument. But we do carry a user_global_ns namespace
939 # the locals argument. But we do carry a user_global_ns namespace
940 # given as the exec 'globals' argument, This is useful in embedding
940 # given as the exec 'globals' argument, This is useful in embedding
941 # situations where the ipython shell opens in a context where the
941 # situations where the ipython shell opens in a context where the
942 # distinction between locals and globals is meaningful. For
942 # distinction between locals and globals is meaningful. For
943 # non-embedded contexts, it is just the same object as the user_ns dict.
943 # non-embedded contexts, it is just the same object as the user_ns dict.
944
944
945 # FIXME. For some strange reason, __builtins__ is showing up at user
945 # FIXME. For some strange reason, __builtins__ is showing up at user
946 # level as a dict instead of a module. This is a manual fix, but I
946 # level as a dict instead of a module. This is a manual fix, but I
947 # should really track down where the problem is coming from. Alex
947 # should really track down where the problem is coming from. Alex
948 # Schmolck reported this problem first.
948 # Schmolck reported this problem first.
949
949
950 # A useful post by Alex Martelli on this topic:
950 # A useful post by Alex Martelli on this topic:
951 # Re: inconsistent value from __builtins__
951 # Re: inconsistent value from __builtins__
952 # Von: Alex Martelli <aleaxit@yahoo.com>
952 # Von: Alex Martelli <aleaxit@yahoo.com>
953 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
953 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
954 # Gruppen: comp.lang.python
954 # Gruppen: comp.lang.python
955
955
956 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
956 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
957 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
957 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
958 # > <type 'dict'>
958 # > <type 'dict'>
959 # > >>> print type(__builtins__)
959 # > >>> print type(__builtins__)
960 # > <type 'module'>
960 # > <type 'module'>
961 # > Is this difference in return value intentional?
961 # > Is this difference in return value intentional?
962
962
963 # Well, it's documented that '__builtins__' can be either a dictionary
963 # Well, it's documented that '__builtins__' can be either a dictionary
964 # or a module, and it's been that way for a long time. Whether it's
964 # or a module, and it's been that way for a long time. Whether it's
965 # intentional (or sensible), I don't know. In any case, the idea is
965 # intentional (or sensible), I don't know. In any case, the idea is
966 # that if you need to access the built-in namespace directly, you
966 # that if you need to access the built-in namespace directly, you
967 # should start with "import __builtin__" (note, no 's') which will
967 # should start with "import __builtin__" (note, no 's') which will
968 # definitely give you a module. Yeah, it's somewhat confusing:-(.
968 # definitely give you a module. Yeah, it's somewhat confusing:-(.
969
969
970 # These routines return a properly built module and dict as needed by
970 # These routines return a properly built module and dict as needed by
971 # the rest of the code, and can also be used by extension writers to
971 # the rest of the code, and can also be used by extension writers to
972 # generate properly initialized namespaces.
972 # generate properly initialized namespaces.
973 if (user_ns is not None) or (user_module is not None):
973 if (user_ns is not None) or (user_module is not None):
974 self.default_user_namespaces = False
974 self.default_user_namespaces = False
975 self.user_module, self.user_ns = self.prepare_user_module(user_module, user_ns)
975 self.user_module, self.user_ns = self.prepare_user_module(user_module, user_ns)
976
976
977 # A record of hidden variables we have added to the user namespace, so
977 # A record of hidden variables we have added to the user namespace, so
978 # we can list later only variables defined in actual interactive use.
978 # we can list later only variables defined in actual interactive use.
979 self.user_ns_hidden = set()
979 self.user_ns_hidden = set()
980
980
981 # Now that FakeModule produces a real module, we've run into a nasty
981 # Now that FakeModule produces a real module, we've run into a nasty
982 # problem: after script execution (via %run), the module where the user
982 # problem: after script execution (via %run), the module where the user
983 # code ran is deleted. Now that this object is a true module (needed
983 # code ran is deleted. Now that this object is a true module (needed
984 # so docetst and other tools work correctly), the Python module
984 # so docetst and other tools work correctly), the Python module
985 # teardown mechanism runs over it, and sets to None every variable
985 # teardown mechanism runs over it, and sets to None every variable
986 # present in that module. Top-level references to objects from the
986 # present in that module. Top-level references to objects from the
987 # script survive, because the user_ns is updated with them. However,
987 # script survive, because the user_ns is updated with them. However,
988 # calling functions defined in the script that use other things from
988 # calling functions defined in the script that use other things from
989 # the script will fail, because the function's closure had references
989 # the script will fail, because the function's closure had references
990 # to the original objects, which are now all None. So we must protect
990 # to the original objects, which are now all None. So we must protect
991 # these modules from deletion by keeping a cache.
991 # these modules from deletion by keeping a cache.
992 #
992 #
993 # To avoid keeping stale modules around (we only need the one from the
993 # To avoid keeping stale modules around (we only need the one from the
994 # last run), we use a dict keyed with the full path to the script, so
994 # last run), we use a dict keyed with the full path to the script, so
995 # only the last version of the module is held in the cache. Note,
995 # only the last version of the module is held in the cache. Note,
996 # however, that we must cache the module *namespace contents* (their
996 # however, that we must cache the module *namespace contents* (their
997 # __dict__). Because if we try to cache the actual modules, old ones
997 # __dict__). Because if we try to cache the actual modules, old ones
998 # (uncached) could be destroyed while still holding references (such as
998 # (uncached) could be destroyed while still holding references (such as
999 # those held by GUI objects that tend to be long-lived)>
999 # those held by GUI objects that tend to be long-lived)>
1000 #
1000 #
1001 # The %reset command will flush this cache. See the cache_main_mod()
1001 # The %reset command will flush this cache. See the cache_main_mod()
1002 # and clear_main_mod_cache() methods for details on use.
1002 # and clear_main_mod_cache() methods for details on use.
1003
1003
1004 # This is the cache used for 'main' namespaces
1004 # This is the cache used for 'main' namespaces
1005 self._main_ns_cache = {}
1005 self._main_ns_cache = {}
1006 # And this is the single instance of FakeModule whose __dict__ we keep
1006 # And this is the single instance of FakeModule whose __dict__ we keep
1007 # copying and clearing for reuse on each %run
1007 # copying and clearing for reuse on each %run
1008 self._user_main_module = FakeModule()
1008 self._user_main_module = FakeModule()
1009
1009
1010 # A table holding all the namespaces IPython deals with, so that
1010 # A table holding all the namespaces IPython deals with, so that
1011 # introspection facilities can search easily.
1011 # introspection facilities can search easily.
1012 self.ns_table = {'user_global':self.user_module.__dict__,
1012 self.ns_table = {'user_global':self.user_module.__dict__,
1013 'user_local':self.user_ns,
1013 'user_local':self.user_ns,
1014 'builtin':builtin_mod.__dict__
1014 'builtin':builtin_mod.__dict__
1015 }
1015 }
1016
1016
1017 @property
1017 @property
1018 def user_global_ns(self):
1018 def user_global_ns(self):
1019 return self.user_module.__dict__
1019 return self.user_module.__dict__
1020
1020
1021 def prepare_user_module(self, user_module=None, user_ns=None):
1021 def prepare_user_module(self, user_module=None, user_ns=None):
1022 """Prepare the module and namespace in which user code will be run.
1022 """Prepare the module and namespace in which user code will be run.
1023
1023
1024 When IPython is started normally, both parameters are None: a new module
1024 When IPython is started normally, both parameters are None: a new module
1025 is created automatically, and its __dict__ used as the namespace.
1025 is created automatically, and its __dict__ used as the namespace.
1026
1026
1027 If only user_module is provided, its __dict__ is used as the namespace.
1027 If only user_module is provided, its __dict__ is used as the namespace.
1028 If only user_ns is provided, a dummy module is created, and user_ns
1028 If only user_ns is provided, a dummy module is created, and user_ns
1029 becomes the global namespace. If both are provided (as they may be
1029 becomes the global namespace. If both are provided (as they may be
1030 when embedding), user_ns is the local namespace, and user_module
1030 when embedding), user_ns is the local namespace, and user_module
1031 provides the global namespace.
1031 provides the global namespace.
1032
1032
1033 Parameters
1033 Parameters
1034 ----------
1034 ----------
1035 user_module : module, optional
1035 user_module : module, optional
1036 The current user module in which IPython is being run. If None,
1036 The current user module in which IPython is being run. If None,
1037 a clean module will be created.
1037 a clean module will be created.
1038 user_ns : dict, optional
1038 user_ns : dict, optional
1039 A namespace in which to run interactive commands.
1039 A namespace in which to run interactive commands.
1040
1040
1041 Returns
1041 Returns
1042 -------
1042 -------
1043 A tuple of user_module and user_ns, each properly initialised.
1043 A tuple of user_module and user_ns, each properly initialised.
1044 """
1044 """
1045 if user_module is None and user_ns is not None:
1045 if user_module is None and user_ns is not None:
1046 user_ns.setdefault("__name__", "__main__")
1046 user_ns.setdefault("__name__", "__main__")
1047 class DummyMod(object):
1047 class DummyMod(object):
1048 "A dummy module used for IPython's interactive namespace."
1048 "A dummy module used for IPython's interactive namespace."
1049 pass
1049 pass
1050 user_module = DummyMod()
1050 user_module = DummyMod()
1051 user_module.__dict__ = user_ns
1051 user_module.__dict__ = user_ns
1052
1052
1053 if user_module is None:
1053 if user_module is None:
1054 user_module = types.ModuleType("__main__",
1054 user_module = types.ModuleType("__main__",
1055 doc="Automatically created module for IPython interactive environment")
1055 doc="Automatically created module for IPython interactive environment")
1056
1056
1057 # We must ensure that __builtin__ (without the final 's') is always
1057 # We must ensure that __builtin__ (without the final 's') is always
1058 # available and pointing to the __builtin__ *module*. For more details:
1058 # available and pointing to the __builtin__ *module*. For more details:
1059 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1059 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1060 user_module.__dict__.setdefault('__builtin__', builtin_mod)
1060 user_module.__dict__.setdefault('__builtin__', builtin_mod)
1061 user_module.__dict__.setdefault('__builtins__', builtin_mod)
1061 user_module.__dict__.setdefault('__builtins__', builtin_mod)
1062
1062
1063 if user_ns is None:
1063 if user_ns is None:
1064 user_ns = user_module.__dict__
1064 user_ns = user_module.__dict__
1065
1065
1066 return user_module, user_ns
1066 return user_module, user_ns
1067
1067
1068 def init_sys_modules(self):
1068 def init_sys_modules(self):
1069 # We need to insert into sys.modules something that looks like a
1069 # We need to insert into sys.modules something that looks like a
1070 # module but which accesses the IPython namespace, for shelve and
1070 # module but which accesses the IPython namespace, for shelve and
1071 # pickle to work interactively. Normally they rely on getting
1071 # pickle to work interactively. Normally they rely on getting
1072 # everything out of __main__, but for embedding purposes each IPython
1072 # everything out of __main__, but for embedding purposes each IPython
1073 # instance has its own private namespace, so we can't go shoving
1073 # instance has its own private namespace, so we can't go shoving
1074 # everything into __main__.
1074 # everything into __main__.
1075
1075
1076 # note, however, that we should only do this for non-embedded
1076 # note, however, that we should only do this for non-embedded
1077 # ipythons, which really mimic the __main__.__dict__ with their own
1077 # ipythons, which really mimic the __main__.__dict__ with their own
1078 # namespace. Embedded instances, on the other hand, should not do
1078 # namespace. Embedded instances, on the other hand, should not do
1079 # this because they need to manage the user local/global namespaces
1079 # this because they need to manage the user local/global namespaces
1080 # only, but they live within a 'normal' __main__ (meaning, they
1080 # only, but they live within a 'normal' __main__ (meaning, they
1081 # shouldn't overtake the execution environment of the script they're
1081 # shouldn't overtake the execution environment of the script they're
1082 # embedded in).
1082 # embedded in).
1083
1083
1084 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
1084 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
1085 main_name = self.user_module.__name__
1085 main_name = self.user_module.__name__
1086 sys.modules[main_name] = self.user_module
1086 sys.modules[main_name] = self.user_module
1087
1087
1088 def init_user_ns(self):
1088 def init_user_ns(self):
1089 """Initialize all user-visible namespaces to their minimum defaults.
1089 """Initialize all user-visible namespaces to their minimum defaults.
1090
1090
1091 Certain history lists are also initialized here, as they effectively
1091 Certain history lists are also initialized here, as they effectively
1092 act as user namespaces.
1092 act as user namespaces.
1093
1093
1094 Notes
1094 Notes
1095 -----
1095 -----
1096 All data structures here are only filled in, they are NOT reset by this
1096 All data structures here are only filled in, they are NOT reset by this
1097 method. If they were not empty before, data will simply be added to
1097 method. If they were not empty before, data will simply be added to
1098 therm.
1098 therm.
1099 """
1099 """
1100 # This function works in two parts: first we put a few things in
1100 # This function works in two parts: first we put a few things in
1101 # user_ns, and we sync that contents into user_ns_hidden so that these
1101 # user_ns, and we sync that contents into user_ns_hidden so that these
1102 # initial variables aren't shown by %who. After the sync, we add the
1102 # initial variables aren't shown by %who. After the sync, we add the
1103 # rest of what we *do* want the user to see with %who even on a new
1103 # rest of what we *do* want the user to see with %who even on a new
1104 # session (probably nothing, so theye really only see their own stuff)
1104 # session (probably nothing, so theye really only see their own stuff)
1105
1105
1106 # The user dict must *always* have a __builtin__ reference to the
1106 # The user dict must *always* have a __builtin__ reference to the
1107 # Python standard __builtin__ namespace, which must be imported.
1107 # Python standard __builtin__ namespace, which must be imported.
1108 # This is so that certain operations in prompt evaluation can be
1108 # This is so that certain operations in prompt evaluation can be
1109 # reliably executed with builtins. Note that we can NOT use
1109 # reliably executed with builtins. Note that we can NOT use
1110 # __builtins__ (note the 's'), because that can either be a dict or a
1110 # __builtins__ (note the 's'), because that can either be a dict or a
1111 # module, and can even mutate at runtime, depending on the context
1111 # module, and can even mutate at runtime, depending on the context
1112 # (Python makes no guarantees on it). In contrast, __builtin__ is
1112 # (Python makes no guarantees on it). In contrast, __builtin__ is
1113 # always a module object, though it must be explicitly imported.
1113 # always a module object, though it must be explicitly imported.
1114
1114
1115 # For more details:
1115 # For more details:
1116 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1116 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1117 ns = dict()
1117 ns = dict()
1118
1118
1119 # Put 'help' in the user namespace
1119 # Put 'help' in the user namespace
1120 try:
1120 try:
1121 from site import _Helper
1121 from site import _Helper
1122 ns['help'] = _Helper()
1122 ns['help'] = _Helper()
1123 except ImportError:
1123 except ImportError:
1124 warn('help() not available - check site.py')
1124 warn('help() not available - check site.py')
1125
1125
1126 # make global variables for user access to the histories
1126 # make global variables for user access to the histories
1127 ns['_ih'] = self.history_manager.input_hist_parsed
1127 ns['_ih'] = self.history_manager.input_hist_parsed
1128 ns['_oh'] = self.history_manager.output_hist
1128 ns['_oh'] = self.history_manager.output_hist
1129 ns['_dh'] = self.history_manager.dir_hist
1129 ns['_dh'] = self.history_manager.dir_hist
1130
1130
1131 ns['_sh'] = shadowns
1131 ns['_sh'] = shadowns
1132
1132
1133 # user aliases to input and output histories. These shouldn't show up
1133 # user aliases to input and output histories. These shouldn't show up
1134 # in %who, as they can have very large reprs.
1134 # in %who, as they can have very large reprs.
1135 ns['In'] = self.history_manager.input_hist_parsed
1135 ns['In'] = self.history_manager.input_hist_parsed
1136 ns['Out'] = self.history_manager.output_hist
1136 ns['Out'] = self.history_manager.output_hist
1137
1137
1138 # Store myself as the public api!!!
1138 # Store myself as the public api!!!
1139 ns['get_ipython'] = self.get_ipython
1139 ns['get_ipython'] = self.get_ipython
1140
1140
1141 ns['exit'] = self.exiter
1141 ns['exit'] = self.exiter
1142 ns['quit'] = self.exiter
1142 ns['quit'] = self.exiter
1143
1143
1144 # Sync what we've added so far to user_ns_hidden so these aren't seen
1144 # Sync what we've added so far to user_ns_hidden so these aren't seen
1145 # by %who
1145 # by %who
1146 self.user_ns_hidden.update(ns)
1146 self.user_ns_hidden.update(ns)
1147
1147
1148 # Anything put into ns now would show up in %who. Think twice before
1148 # Anything put into ns now would show up in %who. Think twice before
1149 # putting anything here, as we really want %who to show the user their
1149 # putting anything here, as we really want %who to show the user their
1150 # stuff, not our variables.
1150 # stuff, not our variables.
1151
1151
1152 # Finally, update the real user's namespace
1152 # Finally, update the real user's namespace
1153 self.user_ns.update(ns)
1153 self.user_ns.update(ns)
1154
1154
1155 @property
1155 @property
1156 def all_ns_refs(self):
1156 def all_ns_refs(self):
1157 """Get a list of references to all the namespace dictionaries in which
1157 """Get a list of references to all the namespace dictionaries in which
1158 IPython might store a user-created object.
1158 IPython might store a user-created object.
1159
1159
1160 Note that this does not include the displayhook, which also caches
1160 Note that this does not include the displayhook, which also caches
1161 objects from the output."""
1161 objects from the output."""
1162 return [self.user_ns, self.user_global_ns,
1162 return [self.user_ns, self.user_global_ns,
1163 self._user_main_module.__dict__] + self._main_ns_cache.values()
1163 self._user_main_module.__dict__] + self._main_ns_cache.values()
1164
1164
1165 def reset(self, new_session=True):
1165 def reset(self, new_session=True):
1166 """Clear all internal namespaces, and attempt to release references to
1166 """Clear all internal namespaces, and attempt to release references to
1167 user objects.
1167 user objects.
1168
1168
1169 If new_session is True, a new history session will be opened.
1169 If new_session is True, a new history session will be opened.
1170 """
1170 """
1171 # Clear histories
1171 # Clear histories
1172 self.history_manager.reset(new_session)
1172 self.history_manager.reset(new_session)
1173 # Reset counter used to index all histories
1173 # Reset counter used to index all histories
1174 if new_session:
1174 if new_session:
1175 self.execution_count = 1
1175 self.execution_count = 1
1176
1176
1177 # Flush cached output items
1177 # Flush cached output items
1178 if self.displayhook.do_full_cache:
1178 if self.displayhook.do_full_cache:
1179 self.displayhook.flush()
1179 self.displayhook.flush()
1180
1180
1181 # The main execution namespaces must be cleared very carefully,
1181 # The main execution namespaces must be cleared very carefully,
1182 # skipping the deletion of the builtin-related keys, because doing so
1182 # skipping the deletion of the builtin-related keys, because doing so
1183 # would cause errors in many object's __del__ methods.
1183 # would cause errors in many object's __del__ methods.
1184 if self.user_ns is not self.user_global_ns:
1184 if self.user_ns is not self.user_global_ns:
1185 self.user_ns.clear()
1185 self.user_ns.clear()
1186 ns = self.user_global_ns
1186 ns = self.user_global_ns
1187 drop_keys = set(ns.keys())
1187 drop_keys = set(ns.keys())
1188 drop_keys.discard('__builtin__')
1188 drop_keys.discard('__builtin__')
1189 drop_keys.discard('__builtins__')
1189 drop_keys.discard('__builtins__')
1190 drop_keys.discard('__name__')
1190 drop_keys.discard('__name__')
1191 for k in drop_keys:
1191 for k in drop_keys:
1192 del ns[k]
1192 del ns[k]
1193
1193
1194 self.user_ns_hidden.clear()
1194 self.user_ns_hidden.clear()
1195
1195
1196 # Restore the user namespaces to minimal usability
1196 # Restore the user namespaces to minimal usability
1197 self.init_user_ns()
1197 self.init_user_ns()
1198
1198
1199 # Restore the default and user aliases
1199 # Restore the default and user aliases
1200 self.alias_manager.clear_aliases()
1200 self.alias_manager.clear_aliases()
1201 self.alias_manager.init_aliases()
1201 self.alias_manager.init_aliases()
1202
1202
1203 # Flush the private list of module references kept for script
1203 # Flush the private list of module references kept for script
1204 # execution protection
1204 # execution protection
1205 self.clear_main_mod_cache()
1205 self.clear_main_mod_cache()
1206
1206
1207 # Clear out the namespace from the last %run
1207 # Clear out the namespace from the last %run
1208 self.new_main_mod()
1208 self.new_main_mod()
1209
1209
1210 def del_var(self, varname, by_name=False):
1210 def del_var(self, varname, by_name=False):
1211 """Delete a variable from the various namespaces, so that, as
1211 """Delete a variable from the various namespaces, so that, as
1212 far as possible, we're not keeping any hidden references to it.
1212 far as possible, we're not keeping any hidden references to it.
1213
1213
1214 Parameters
1214 Parameters
1215 ----------
1215 ----------
1216 varname : str
1216 varname : str
1217 The name of the variable to delete.
1217 The name of the variable to delete.
1218 by_name : bool
1218 by_name : bool
1219 If True, delete variables with the given name in each
1219 If True, delete variables with the given name in each
1220 namespace. If False (default), find the variable in the user
1220 namespace. If False (default), find the variable in the user
1221 namespace, and delete references to it.
1221 namespace, and delete references to it.
1222 """
1222 """
1223 if varname in ('__builtin__', '__builtins__'):
1223 if varname in ('__builtin__', '__builtins__'):
1224 raise ValueError("Refusing to delete %s" % varname)
1224 raise ValueError("Refusing to delete %s" % varname)
1225
1225
1226 ns_refs = self.all_ns_refs
1226 ns_refs = self.all_ns_refs
1227
1227
1228 if by_name: # Delete by name
1228 if by_name: # Delete by name
1229 for ns in ns_refs:
1229 for ns in ns_refs:
1230 try:
1230 try:
1231 del ns[varname]
1231 del ns[varname]
1232 except KeyError:
1232 except KeyError:
1233 pass
1233 pass
1234 else: # Delete by object
1234 else: # Delete by object
1235 try:
1235 try:
1236 obj = self.user_ns[varname]
1236 obj = self.user_ns[varname]
1237 except KeyError:
1237 except KeyError:
1238 raise NameError("name '%s' is not defined" % varname)
1238 raise NameError("name '%s' is not defined" % varname)
1239 # Also check in output history
1239 # Also check in output history
1240 ns_refs.append(self.history_manager.output_hist)
1240 ns_refs.append(self.history_manager.output_hist)
1241 for ns in ns_refs:
1241 for ns in ns_refs:
1242 to_delete = [n for n, o in ns.iteritems() if o is obj]
1242 to_delete = [n for n, o in ns.iteritems() if o is obj]
1243 for name in to_delete:
1243 for name in to_delete:
1244 del ns[name]
1244 del ns[name]
1245
1245
1246 # displayhook keeps extra references, but not in a dictionary
1246 # displayhook keeps extra references, but not in a dictionary
1247 for name in ('_', '__', '___'):
1247 for name in ('_', '__', '___'):
1248 if getattr(self.displayhook, name) is obj:
1248 if getattr(self.displayhook, name) is obj:
1249 setattr(self.displayhook, name, None)
1249 setattr(self.displayhook, name, None)
1250
1250
1251 def reset_selective(self, regex=None):
1251 def reset_selective(self, regex=None):
1252 """Clear selective variables from internal namespaces based on a
1252 """Clear selective variables from internal namespaces based on a
1253 specified regular expression.
1253 specified regular expression.
1254
1254
1255 Parameters
1255 Parameters
1256 ----------
1256 ----------
1257 regex : string or compiled pattern, optional
1257 regex : string or compiled pattern, optional
1258 A regular expression pattern that will be used in searching
1258 A regular expression pattern that will be used in searching
1259 variable names in the users namespaces.
1259 variable names in the users namespaces.
1260 """
1260 """
1261 if regex is not None:
1261 if regex is not None:
1262 try:
1262 try:
1263 m = re.compile(regex)
1263 m = re.compile(regex)
1264 except TypeError:
1264 except TypeError:
1265 raise TypeError('regex must be a string or compiled pattern')
1265 raise TypeError('regex must be a string or compiled pattern')
1266 # Search for keys in each namespace that match the given regex
1266 # Search for keys in each namespace that match the given regex
1267 # If a match is found, delete the key/value pair.
1267 # If a match is found, delete the key/value pair.
1268 for ns in self.all_ns_refs:
1268 for ns in self.all_ns_refs:
1269 for var in ns:
1269 for var in ns:
1270 if m.search(var):
1270 if m.search(var):
1271 del ns[var]
1271 del ns[var]
1272
1272
1273 def push(self, variables, interactive=True):
1273 def push(self, variables, interactive=True):
1274 """Inject a group of variables into the IPython user namespace.
1274 """Inject a group of variables into the IPython user namespace.
1275
1275
1276 Parameters
1276 Parameters
1277 ----------
1277 ----------
1278 variables : dict, str or list/tuple of str
1278 variables : dict, str or list/tuple of str
1279 The variables to inject into the user's namespace. If a dict, a
1279 The variables to inject into the user's namespace. If a dict, a
1280 simple update is done. If a str, the string is assumed to have
1280 simple update is done. If a str, the string is assumed to have
1281 variable names separated by spaces. A list/tuple of str can also
1281 variable names separated by spaces. A list/tuple of str can also
1282 be used to give the variable names. If just the variable names are
1282 be used to give the variable names. If just the variable names are
1283 give (list/tuple/str) then the variable values looked up in the
1283 give (list/tuple/str) then the variable values looked up in the
1284 callers frame.
1284 callers frame.
1285 interactive : bool
1285 interactive : bool
1286 If True (default), the variables will be listed with the ``who``
1286 If True (default), the variables will be listed with the ``who``
1287 magic.
1287 magic.
1288 """
1288 """
1289 vdict = None
1289 vdict = None
1290
1290
1291 # We need a dict of name/value pairs to do namespace updates.
1291 # We need a dict of name/value pairs to do namespace updates.
1292 if isinstance(variables, dict):
1292 if isinstance(variables, dict):
1293 vdict = variables
1293 vdict = variables
1294 elif isinstance(variables, (basestring, list, tuple)):
1294 elif isinstance(variables, (basestring, list, tuple)):
1295 if isinstance(variables, basestring):
1295 if isinstance(variables, basestring):
1296 vlist = variables.split()
1296 vlist = variables.split()
1297 else:
1297 else:
1298 vlist = variables
1298 vlist = variables
1299 vdict = {}
1299 vdict = {}
1300 cf = sys._getframe(1)
1300 cf = sys._getframe(1)
1301 for name in vlist:
1301 for name in vlist:
1302 try:
1302 try:
1303 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1303 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1304 except:
1304 except:
1305 print ('Could not get variable %s from %s' %
1305 print ('Could not get variable %s from %s' %
1306 (name,cf.f_code.co_name))
1306 (name,cf.f_code.co_name))
1307 else:
1307 else:
1308 raise ValueError('variables must be a dict/str/list/tuple')
1308 raise ValueError('variables must be a dict/str/list/tuple')
1309
1309
1310 # Propagate variables to user namespace
1310 # Propagate variables to user namespace
1311 self.user_ns.update(vdict)
1311 self.user_ns.update(vdict)
1312
1312
1313 # And configure interactive visibility
1313 # And configure interactive visibility
1314 user_ns_hidden = self.user_ns_hidden
1314 user_ns_hidden = self.user_ns_hidden
1315 if interactive:
1315 if interactive:
1316 user_ns_hidden.difference_update(vdict)
1316 user_ns_hidden.difference_update(vdict)
1317 else:
1317 else:
1318 user_ns_hidden.update(vdict)
1318 user_ns_hidden.update(vdict)
1319
1319
1320 def drop_by_id(self, variables):
1320 def drop_by_id(self, variables):
1321 """Remove a dict of variables from the user namespace, if they are the
1321 """Remove a dict of variables from the user namespace, if they are the
1322 same as the values in the dictionary.
1322 same as the values in the dictionary.
1323
1323
1324 This is intended for use by extensions: variables that they've added can
1324 This is intended for use by extensions: variables that they've added can
1325 be taken back out if they are unloaded, without removing any that the
1325 be taken back out if they are unloaded, without removing any that the
1326 user has overwritten.
1326 user has overwritten.
1327
1327
1328 Parameters
1328 Parameters
1329 ----------
1329 ----------
1330 variables : dict
1330 variables : dict
1331 A dictionary mapping object names (as strings) to the objects.
1331 A dictionary mapping object names (as strings) to the objects.
1332 """
1332 """
1333 for name, obj in variables.iteritems():
1333 for name, obj in variables.iteritems():
1334 if name in self.user_ns and self.user_ns[name] is obj:
1334 if name in self.user_ns and self.user_ns[name] is obj:
1335 del self.user_ns[name]
1335 del self.user_ns[name]
1336 self.user_ns_hidden.discard(name)
1336 self.user_ns_hidden.discard(name)
1337
1337
1338 #-------------------------------------------------------------------------
1338 #-------------------------------------------------------------------------
1339 # Things related to object introspection
1339 # Things related to object introspection
1340 #-------------------------------------------------------------------------
1340 #-------------------------------------------------------------------------
1341
1341
1342 def _ofind(self, oname, namespaces=None):
1342 def _ofind(self, oname, namespaces=None):
1343 """Find an object in the available namespaces.
1343 """Find an object in the available namespaces.
1344
1344
1345 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
1345 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
1346
1346
1347 Has special code to detect magic functions.
1347 Has special code to detect magic functions.
1348 """
1348 """
1349 oname = oname.strip()
1349 oname = oname.strip()
1350 #print '1- oname: <%r>' % oname # dbg
1350 #print '1- oname: <%r>' % oname # dbg
1351 if not py3compat.isidentifier(oname.lstrip(ESC_MAGIC), dotted=True):
1351 if not py3compat.isidentifier(oname.lstrip(ESC_MAGIC), dotted=True):
1352 return dict(found=False)
1352 return dict(found=False)
1353
1353
1354 alias_ns = None
1354 alias_ns = None
1355 if namespaces is None:
1355 if namespaces is None:
1356 # Namespaces to search in:
1356 # Namespaces to search in:
1357 # Put them in a list. The order is important so that we
1357 # Put them in a list. The order is important so that we
1358 # find things in the same order that Python finds them.
1358 # find things in the same order that Python finds them.
1359 namespaces = [ ('Interactive', self.user_ns),
1359 namespaces = [ ('Interactive', self.user_ns),
1360 ('Interactive (global)', self.user_global_ns),
1360 ('Interactive (global)', self.user_global_ns),
1361 ('Python builtin', builtin_mod.__dict__),
1361 ('Python builtin', builtin_mod.__dict__),
1362 ('Alias', self.alias_manager.alias_table),
1362 ('Alias', self.alias_manager.alias_table),
1363 ]
1363 ]
1364 alias_ns = self.alias_manager.alias_table
1364 alias_ns = self.alias_manager.alias_table
1365
1365
1366 # initialize results to 'null'
1366 # initialize results to 'null'
1367 found = False; obj = None; ospace = None; ds = None;
1367 found = False; obj = None; ospace = None; ds = None;
1368 ismagic = False; isalias = False; parent = None
1368 ismagic = False; isalias = False; parent = None
1369
1369
1370 # We need to special-case 'print', which as of python2.6 registers as a
1370 # We need to special-case 'print', which as of python2.6 registers as a
1371 # function but should only be treated as one if print_function was
1371 # function but should only be treated as one if print_function was
1372 # loaded with a future import. In this case, just bail.
1372 # loaded with a future import. In this case, just bail.
1373 if (oname == 'print' and not py3compat.PY3 and not \
1373 if (oname == 'print' and not py3compat.PY3 and not \
1374 (self.compile.compiler_flags & __future__.CO_FUTURE_PRINT_FUNCTION)):
1374 (self.compile.compiler_flags & __future__.CO_FUTURE_PRINT_FUNCTION)):
1375 return {'found':found, 'obj':obj, 'namespace':ospace,
1375 return {'found':found, 'obj':obj, 'namespace':ospace,
1376 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1376 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1377
1377
1378 # Look for the given name by splitting it in parts. If the head is
1378 # Look for the given name by splitting it in parts. If the head is
1379 # found, then we look for all the remaining parts as members, and only
1379 # found, then we look for all the remaining parts as members, and only
1380 # declare success if we can find them all.
1380 # declare success if we can find them all.
1381 oname_parts = oname.split('.')
1381 oname_parts = oname.split('.')
1382 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
1382 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
1383 for nsname,ns in namespaces:
1383 for nsname,ns in namespaces:
1384 try:
1384 try:
1385 obj = ns[oname_head]
1385 obj = ns[oname_head]
1386 except KeyError:
1386 except KeyError:
1387 continue
1387 continue
1388 else:
1388 else:
1389 #print 'oname_rest:', oname_rest # dbg
1389 #print 'oname_rest:', oname_rest # dbg
1390 for part in oname_rest:
1390 for part in oname_rest:
1391 try:
1391 try:
1392 parent = obj
1392 parent = obj
1393 obj = getattr(obj,part)
1393 obj = getattr(obj,part)
1394 except:
1394 except:
1395 # Blanket except b/c some badly implemented objects
1395 # Blanket except b/c some badly implemented objects
1396 # allow __getattr__ to raise exceptions other than
1396 # allow __getattr__ to raise exceptions other than
1397 # AttributeError, which then crashes IPython.
1397 # AttributeError, which then crashes IPython.
1398 break
1398 break
1399 else:
1399 else:
1400 # If we finish the for loop (no break), we got all members
1400 # If we finish the for loop (no break), we got all members
1401 found = True
1401 found = True
1402 ospace = nsname
1402 ospace = nsname
1403 if ns == alias_ns:
1403 if ns == alias_ns:
1404 isalias = True
1404 isalias = True
1405 break # namespace loop
1405 break # namespace loop
1406
1406
1407 # Try to see if it's magic
1407 # Try to see if it's magic
1408 if not found:
1408 if not found:
1409 if oname.startswith(ESC_MAGIC):
1409 if oname.startswith(ESC_MAGIC):
1410 oname = oname.lstrip(ESC_MAGIC)
1410 oname = oname.lstrip(ESC_MAGIC)
1411 obj = self.find_line_magic(oname)
1411 obj = self.find_line_magic(oname)
1412 if obj is None:
1412 if obj is None:
1413 obj = self.find_cell_magic(oname)
1413 obj = self.find_cell_magic(oname)
1414 if obj is not None:
1414 if obj is not None:
1415 found = True
1415 found = True
1416 ospace = 'IPython internal'
1416 ospace = 'IPython internal'
1417 ismagic = True
1417 ismagic = True
1418
1418
1419 # Last try: special-case some literals like '', [], {}, etc:
1419 # Last try: special-case some literals like '', [], {}, etc:
1420 if not found and oname_head in ["''",'""','[]','{}','()']:
1420 if not found and oname_head in ["''",'""','[]','{}','()']:
1421 obj = eval(oname_head)
1421 obj = eval(oname_head)
1422 found = True
1422 found = True
1423 ospace = 'Interactive'
1423 ospace = 'Interactive'
1424
1424
1425 return {'found':found, 'obj':obj, 'namespace':ospace,
1425 return {'found':found, 'obj':obj, 'namespace':ospace,
1426 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1426 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1427
1427
1428 def _ofind_property(self, oname, info):
1428 def _ofind_property(self, oname, info):
1429 """Second part of object finding, to look for property details."""
1429 """Second part of object finding, to look for property details."""
1430 if info.found:
1430 if info.found:
1431 # Get the docstring of the class property if it exists.
1431 # Get the docstring of the class property if it exists.
1432 path = oname.split('.')
1432 path = oname.split('.')
1433 root = '.'.join(path[:-1])
1433 root = '.'.join(path[:-1])
1434 if info.parent is not None:
1434 if info.parent is not None:
1435 try:
1435 try:
1436 target = getattr(info.parent, '__class__')
1436 target = getattr(info.parent, '__class__')
1437 # The object belongs to a class instance.
1437 # The object belongs to a class instance.
1438 try:
1438 try:
1439 target = getattr(target, path[-1])
1439 target = getattr(target, path[-1])
1440 # The class defines the object.
1440 # The class defines the object.
1441 if isinstance(target, property):
1441 if isinstance(target, property):
1442 oname = root + '.__class__.' + path[-1]
1442 oname = root + '.__class__.' + path[-1]
1443 info = Struct(self._ofind(oname))
1443 info = Struct(self._ofind(oname))
1444 except AttributeError: pass
1444 except AttributeError: pass
1445 except AttributeError: pass
1445 except AttributeError: pass
1446
1446
1447 # We return either the new info or the unmodified input if the object
1447 # We return either the new info or the unmodified input if the object
1448 # hadn't been found
1448 # hadn't been found
1449 return info
1449 return info
1450
1450
1451 def _object_find(self, oname, namespaces=None):
1451 def _object_find(self, oname, namespaces=None):
1452 """Find an object and return a struct with info about it."""
1452 """Find an object and return a struct with info about it."""
1453 inf = Struct(self._ofind(oname, namespaces))
1453 inf = Struct(self._ofind(oname, namespaces))
1454 return Struct(self._ofind_property(oname, inf))
1454 return Struct(self._ofind_property(oname, inf))
1455
1455
1456 def _inspect(self, meth, oname, namespaces=None, **kw):
1456 def _inspect(self, meth, oname, namespaces=None, **kw):
1457 """Generic interface to the inspector system.
1457 """Generic interface to the inspector system.
1458
1458
1459 This function is meant to be called by pdef, pdoc & friends."""
1459 This function is meant to be called by pdef, pdoc & friends."""
1460 info = self._object_find(oname)
1460 info = self._object_find(oname)
1461 if info.found:
1461 if info.found:
1462 pmethod = getattr(self.inspector, meth)
1462 pmethod = getattr(self.inspector, meth)
1463 formatter = format_screen if info.ismagic else None
1463 formatter = format_screen if info.ismagic else None
1464 if meth == 'pdoc':
1464 if meth == 'pdoc':
1465 pmethod(info.obj, oname, formatter)
1465 pmethod(info.obj, oname, formatter)
1466 elif meth == 'pinfo':
1466 elif meth == 'pinfo':
1467 pmethod(info.obj, oname, formatter, info, **kw)
1467 pmethod(info.obj, oname, formatter, info, **kw)
1468 else:
1468 else:
1469 pmethod(info.obj, oname)
1469 pmethod(info.obj, oname)
1470 else:
1470 else:
1471 print 'Object `%s` not found.' % oname
1471 print 'Object `%s` not found.' % oname
1472 return 'not found' # so callers can take other action
1472 return 'not found' # so callers can take other action
1473
1473
1474 def object_inspect(self, oname, detail_level=0):
1474 def object_inspect(self, oname, detail_level=0):
1475 with self.builtin_trap:
1475 with self.builtin_trap:
1476 info = self._object_find(oname)
1476 info = self._object_find(oname)
1477 if info.found:
1477 if info.found:
1478 return self.inspector.info(info.obj, oname, info=info,
1478 return self.inspector.info(info.obj, oname, info=info,
1479 detail_level=detail_level
1479 detail_level=detail_level
1480 )
1480 )
1481 else:
1481 else:
1482 return oinspect.object_info(name=oname, found=False)
1482 return oinspect.object_info(name=oname, found=False)
1483
1483
1484 #-------------------------------------------------------------------------
1484 #-------------------------------------------------------------------------
1485 # Things related to history management
1485 # Things related to history management
1486 #-------------------------------------------------------------------------
1486 #-------------------------------------------------------------------------
1487
1487
1488 def init_history(self):
1488 def init_history(self):
1489 """Sets up the command history, and starts regular autosaves."""
1489 """Sets up the command history, and starts regular autosaves."""
1490 self.history_manager = HistoryManager(shell=self, config=self.config)
1490 self.history_manager = HistoryManager(shell=self, config=self.config)
1491 self.configurables.append(self.history_manager)
1491 self.configurables.append(self.history_manager)
1492
1492
1493 #-------------------------------------------------------------------------
1493 #-------------------------------------------------------------------------
1494 # Things related to exception handling and tracebacks (not debugging)
1494 # Things related to exception handling and tracebacks (not debugging)
1495 #-------------------------------------------------------------------------
1495 #-------------------------------------------------------------------------
1496
1496
1497 def init_traceback_handlers(self, custom_exceptions):
1497 def init_traceback_handlers(self, custom_exceptions):
1498 # Syntax error handler.
1498 # Syntax error handler.
1499 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor')
1499 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor')
1500
1500
1501 # The interactive one is initialized with an offset, meaning we always
1501 # The interactive one is initialized with an offset, meaning we always
1502 # want to remove the topmost item in the traceback, which is our own
1502 # want to remove the topmost item in the traceback, which is our own
1503 # internal code. Valid modes: ['Plain','Context','Verbose']
1503 # internal code. Valid modes: ['Plain','Context','Verbose']
1504 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1504 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1505 color_scheme='NoColor',
1505 color_scheme='NoColor',
1506 tb_offset = 1,
1506 tb_offset = 1,
1507 check_cache=self.compile.check_cache)
1507 check_cache=self.compile.check_cache)
1508
1508
1509 # The instance will store a pointer to the system-wide exception hook,
1509 # The instance will store a pointer to the system-wide exception hook,
1510 # so that runtime code (such as magics) can access it. This is because
1510 # so that runtime code (such as magics) can access it. This is because
1511 # during the read-eval loop, it may get temporarily overwritten.
1511 # during the read-eval loop, it may get temporarily overwritten.
1512 self.sys_excepthook = sys.excepthook
1512 self.sys_excepthook = sys.excepthook
1513
1513
1514 # and add any custom exception handlers the user may have specified
1514 # and add any custom exception handlers the user may have specified
1515 self.set_custom_exc(*custom_exceptions)
1515 self.set_custom_exc(*custom_exceptions)
1516
1516
1517 # Set the exception mode
1517 # Set the exception mode
1518 self.InteractiveTB.set_mode(mode=self.xmode)
1518 self.InteractiveTB.set_mode(mode=self.xmode)
1519
1519
1520 def set_custom_exc(self, exc_tuple, handler):
1520 def set_custom_exc(self, exc_tuple, handler):
1521 """set_custom_exc(exc_tuple,handler)
1521 """set_custom_exc(exc_tuple,handler)
1522
1522
1523 Set a custom exception handler, which will be called if any of the
1523 Set a custom exception handler, which will be called if any of the
1524 exceptions in exc_tuple occur in the mainloop (specifically, in the
1524 exceptions in exc_tuple occur in the mainloop (specifically, in the
1525 run_code() method).
1525 run_code() method).
1526
1526
1527 Parameters
1527 Parameters
1528 ----------
1528 ----------
1529
1529
1530 exc_tuple : tuple of exception classes
1530 exc_tuple : tuple of exception classes
1531 A *tuple* of exception classes, for which to call the defined
1531 A *tuple* of exception classes, for which to call the defined
1532 handler. It is very important that you use a tuple, and NOT A
1532 handler. It is very important that you use a tuple, and NOT A
1533 LIST here, because of the way Python's except statement works. If
1533 LIST here, because of the way Python's except statement works. If
1534 you only want to trap a single exception, use a singleton tuple::
1534 you only want to trap a single exception, use a singleton tuple::
1535
1535
1536 exc_tuple == (MyCustomException,)
1536 exc_tuple == (MyCustomException,)
1537
1537
1538 handler : callable
1538 handler : callable
1539 handler must have the following signature::
1539 handler must have the following signature::
1540
1540
1541 def my_handler(self, etype, value, tb, tb_offset=None):
1541 def my_handler(self, etype, value, tb, tb_offset=None):
1542 ...
1542 ...
1543 return structured_traceback
1543 return structured_traceback
1544
1544
1545 Your handler must return a structured traceback (a list of strings),
1545 Your handler must return a structured traceback (a list of strings),
1546 or None.
1546 or None.
1547
1547
1548 This will be made into an instance method (via types.MethodType)
1548 This will be made into an instance method (via types.MethodType)
1549 of IPython itself, and it will be called if any of the exceptions
1549 of IPython itself, and it will be called if any of the exceptions
1550 listed in the exc_tuple are caught. If the handler is None, an
1550 listed in the exc_tuple are caught. If the handler is None, an
1551 internal basic one is used, which just prints basic info.
1551 internal basic one is used, which just prints basic info.
1552
1552
1553 To protect IPython from crashes, if your handler ever raises an
1553 To protect IPython from crashes, if your handler ever raises an
1554 exception or returns an invalid result, it will be immediately
1554 exception or returns an invalid result, it will be immediately
1555 disabled.
1555 disabled.
1556
1556
1557 WARNING: by putting in your own exception handler into IPython's main
1557 WARNING: by putting in your own exception handler into IPython's main
1558 execution loop, you run a very good chance of nasty crashes. This
1558 execution loop, you run a very good chance of nasty crashes. This
1559 facility should only be used if you really know what you are doing."""
1559 facility should only be used if you really know what you are doing."""
1560
1560
1561 assert type(exc_tuple)==type(()) , \
1561 assert type(exc_tuple)==type(()) , \
1562 "The custom exceptions must be given AS A TUPLE."
1562 "The custom exceptions must be given AS A TUPLE."
1563
1563
1564 def dummy_handler(self,etype,value,tb,tb_offset=None):
1564 def dummy_handler(self,etype,value,tb,tb_offset=None):
1565 print '*** Simple custom exception handler ***'
1565 print '*** Simple custom exception handler ***'
1566 print 'Exception type :',etype
1566 print 'Exception type :',etype
1567 print 'Exception value:',value
1567 print 'Exception value:',value
1568 print 'Traceback :',tb
1568 print 'Traceback :',tb
1569 #print 'Source code :','\n'.join(self.buffer)
1569 #print 'Source code :','\n'.join(self.buffer)
1570
1570
1571 def validate_stb(stb):
1571 def validate_stb(stb):
1572 """validate structured traceback return type
1572 """validate structured traceback return type
1573
1573
1574 return type of CustomTB *should* be a list of strings, but allow
1574 return type of CustomTB *should* be a list of strings, but allow
1575 single strings or None, which are harmless.
1575 single strings or None, which are harmless.
1576
1576
1577 This function will *always* return a list of strings,
1577 This function will *always* return a list of strings,
1578 and will raise a TypeError if stb is inappropriate.
1578 and will raise a TypeError if stb is inappropriate.
1579 """
1579 """
1580 msg = "CustomTB must return list of strings, not %r" % stb
1580 msg = "CustomTB must return list of strings, not %r" % stb
1581 if stb is None:
1581 if stb is None:
1582 return []
1582 return []
1583 elif isinstance(stb, basestring):
1583 elif isinstance(stb, basestring):
1584 return [stb]
1584 return [stb]
1585 elif not isinstance(stb, list):
1585 elif not isinstance(stb, list):
1586 raise TypeError(msg)
1586 raise TypeError(msg)
1587 # it's a list
1587 # it's a list
1588 for line in stb:
1588 for line in stb:
1589 # check every element
1589 # check every element
1590 if not isinstance(line, basestring):
1590 if not isinstance(line, basestring):
1591 raise TypeError(msg)
1591 raise TypeError(msg)
1592 return stb
1592 return stb
1593
1593
1594 if handler is None:
1594 if handler is None:
1595 wrapped = dummy_handler
1595 wrapped = dummy_handler
1596 else:
1596 else:
1597 def wrapped(self,etype,value,tb,tb_offset=None):
1597 def wrapped(self,etype,value,tb,tb_offset=None):
1598 """wrap CustomTB handler, to protect IPython from user code
1598 """wrap CustomTB handler, to protect IPython from user code
1599
1599
1600 This makes it harder (but not impossible) for custom exception
1600 This makes it harder (but not impossible) for custom exception
1601 handlers to crash IPython.
1601 handlers to crash IPython.
1602 """
1602 """
1603 try:
1603 try:
1604 stb = handler(self,etype,value,tb,tb_offset=tb_offset)
1604 stb = handler(self,etype,value,tb,tb_offset=tb_offset)
1605 return validate_stb(stb)
1605 return validate_stb(stb)
1606 except:
1606 except:
1607 # clear custom handler immediately
1607 # clear custom handler immediately
1608 self.set_custom_exc((), None)
1608 self.set_custom_exc((), None)
1609 print >> io.stderr, "Custom TB Handler failed, unregistering"
1609 print >> io.stderr, "Custom TB Handler failed, unregistering"
1610 # show the exception in handler first
1610 # show the exception in handler first
1611 stb = self.InteractiveTB.structured_traceback(*sys.exc_info())
1611 stb = self.InteractiveTB.structured_traceback(*sys.exc_info())
1612 print >> io.stdout, self.InteractiveTB.stb2text(stb)
1612 print >> io.stdout, self.InteractiveTB.stb2text(stb)
1613 print >> io.stdout, "The original exception:"
1613 print >> io.stdout, "The original exception:"
1614 stb = self.InteractiveTB.structured_traceback(
1614 stb = self.InteractiveTB.structured_traceback(
1615 (etype,value,tb), tb_offset=tb_offset
1615 (etype,value,tb), tb_offset=tb_offset
1616 )
1616 )
1617 return stb
1617 return stb
1618
1618
1619 self.CustomTB = types.MethodType(wrapped,self)
1619 self.CustomTB = types.MethodType(wrapped,self)
1620 self.custom_exceptions = exc_tuple
1620 self.custom_exceptions = exc_tuple
1621
1621
1622 def excepthook(self, etype, value, tb):
1622 def excepthook(self, etype, value, tb):
1623 """One more defense for GUI apps that call sys.excepthook.
1623 """One more defense for GUI apps that call sys.excepthook.
1624
1624
1625 GUI frameworks like wxPython trap exceptions and call
1625 GUI frameworks like wxPython trap exceptions and call
1626 sys.excepthook themselves. I guess this is a feature that
1626 sys.excepthook themselves. I guess this is a feature that
1627 enables them to keep running after exceptions that would
1627 enables them to keep running after exceptions that would
1628 otherwise kill their mainloop. This is a bother for IPython
1628 otherwise kill their mainloop. This is a bother for IPython
1629 which excepts to catch all of the program exceptions with a try:
1629 which excepts to catch all of the program exceptions with a try:
1630 except: statement.
1630 except: statement.
1631
1631
1632 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1632 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1633 any app directly invokes sys.excepthook, it will look to the user like
1633 any app directly invokes sys.excepthook, it will look to the user like
1634 IPython crashed. In order to work around this, we can disable the
1634 IPython crashed. In order to work around this, we can disable the
1635 CrashHandler and replace it with this excepthook instead, which prints a
1635 CrashHandler and replace it with this excepthook instead, which prints a
1636 regular traceback using our InteractiveTB. In this fashion, apps which
1636 regular traceback using our InteractiveTB. In this fashion, apps which
1637 call sys.excepthook will generate a regular-looking exception from
1637 call sys.excepthook will generate a regular-looking exception from
1638 IPython, and the CrashHandler will only be triggered by real IPython
1638 IPython, and the CrashHandler will only be triggered by real IPython
1639 crashes.
1639 crashes.
1640
1640
1641 This hook should be used sparingly, only in places which are not likely
1641 This hook should be used sparingly, only in places which are not likely
1642 to be true IPython errors.
1642 to be true IPython errors.
1643 """
1643 """
1644 self.showtraceback((etype,value,tb),tb_offset=0)
1644 self.showtraceback((etype,value,tb),tb_offset=0)
1645
1645
1646 def _get_exc_info(self, exc_tuple=None):
1646 def _get_exc_info(self, exc_tuple=None):
1647 """get exc_info from a given tuple, sys.exc_info() or sys.last_type etc.
1647 """get exc_info from a given tuple, sys.exc_info() or sys.last_type etc.
1648
1648
1649 Ensures sys.last_type,value,traceback hold the exc_info we found,
1649 Ensures sys.last_type,value,traceback hold the exc_info we found,
1650 from whichever source.
1650 from whichever source.
1651
1651
1652 raises ValueError if none of these contain any information
1652 raises ValueError if none of these contain any information
1653 """
1653 """
1654 if exc_tuple is None:
1654 if exc_tuple is None:
1655 etype, value, tb = sys.exc_info()
1655 etype, value, tb = sys.exc_info()
1656 else:
1656 else:
1657 etype, value, tb = exc_tuple
1657 etype, value, tb = exc_tuple
1658
1658
1659 if etype is None:
1659 if etype is None:
1660 if hasattr(sys, 'last_type'):
1660 if hasattr(sys, 'last_type'):
1661 etype, value, tb = sys.last_type, sys.last_value, \
1661 etype, value, tb = sys.last_type, sys.last_value, \
1662 sys.last_traceback
1662 sys.last_traceback
1663
1663
1664 if etype is None:
1664 if etype is None:
1665 raise ValueError("No exception to find")
1665 raise ValueError("No exception to find")
1666
1666
1667 # Now store the exception info in sys.last_type etc.
1667 # Now store the exception info in sys.last_type etc.
1668 # WARNING: these variables are somewhat deprecated and not
1668 # WARNING: these variables are somewhat deprecated and not
1669 # necessarily safe to use in a threaded environment, but tools
1669 # necessarily safe to use in a threaded environment, but tools
1670 # like pdb depend on their existence, so let's set them. If we
1670 # like pdb depend on their existence, so let's set them. If we
1671 # find problems in the field, we'll need to revisit their use.
1671 # find problems in the field, we'll need to revisit their use.
1672 sys.last_type = etype
1672 sys.last_type = etype
1673 sys.last_value = value
1673 sys.last_value = value
1674 sys.last_traceback = tb
1674 sys.last_traceback = tb
1675
1675
1676 return etype, value, tb
1676 return etype, value, tb
1677
1677
1678
1678
1679 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None,
1679 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None,
1680 exception_only=False):
1680 exception_only=False):
1681 """Display the exception that just occurred.
1681 """Display the exception that just occurred.
1682
1682
1683 If nothing is known about the exception, this is the method which
1683 If nothing is known about the exception, this is the method which
1684 should be used throughout the code for presenting user tracebacks,
1684 should be used throughout the code for presenting user tracebacks,
1685 rather than directly invoking the InteractiveTB object.
1685 rather than directly invoking the InteractiveTB object.
1686
1686
1687 A specific showsyntaxerror() also exists, but this method can take
1687 A specific showsyntaxerror() also exists, but this method can take
1688 care of calling it if needed, so unless you are explicitly catching a
1688 care of calling it if needed, so unless you are explicitly catching a
1689 SyntaxError exception, don't try to analyze the stack manually and
1689 SyntaxError exception, don't try to analyze the stack manually and
1690 simply call this method."""
1690 simply call this method."""
1691
1691
1692 try:
1692 try:
1693 try:
1693 try:
1694 etype, value, tb = self._get_exc_info(exc_tuple)
1694 etype, value, tb = self._get_exc_info(exc_tuple)
1695 except ValueError:
1695 except ValueError:
1696 self.write_err('No traceback available to show.\n')
1696 self.write_err('No traceback available to show.\n')
1697 return
1697 return
1698
1698
1699 if etype is SyntaxError:
1699 if etype is SyntaxError:
1700 # Though this won't be called by syntax errors in the input
1700 # Though this won't be called by syntax errors in the input
1701 # line, there may be SyntaxError cases with imported code.
1701 # line, there may be SyntaxError cases with imported code.
1702 self.showsyntaxerror(filename)
1702 self.showsyntaxerror(filename)
1703 elif etype is UsageError:
1703 elif etype is UsageError:
1704 self.write_err("UsageError: %s" % value)
1704 self.write_err("UsageError: %s" % value)
1705 else:
1705 else:
1706 if etype in self.custom_exceptions:
1706 if exception_only:
1707 stb = self.CustomTB(etype, value, tb, tb_offset)
1707 stb = ['An exception has occurred, use %tb to see '
1708 'the full traceback.\n']
1709 stb.extend(self.InteractiveTB.get_exception_only(etype,
1710 value))
1708 else:
1711 else:
1709 if exception_only:
1712 stb = self.InteractiveTB.structured_traceback(etype,
1710 stb = ['An exception has occurred, use %tb to see '
1713 value, tb, tb_offset=tb_offset)
1711 'the full traceback.\n']
1714
1712 stb.extend(self.InteractiveTB.get_exception_only(etype,
1715 self._showtraceback(etype, value, stb)
1713 value))
1716 if self.call_pdb:
1714 else:
1717 # drop into debugger
1715 stb = self.InteractiveTB.structured_traceback(etype,
1718 self.debugger(force=True)
1716 value, tb, tb_offset=tb_offset)
1719 return
1717
1718 self._showtraceback(etype, value, stb)
1719 if self.call_pdb:
1720 # drop into debugger
1721 self.debugger(force=True)
1722 return
1723
1720
1724 # Actually show the traceback
1721 # Actually show the traceback
1725 self._showtraceback(etype, value, stb)
1722 self._showtraceback(etype, value, stb)
1726
1723
1727 except KeyboardInterrupt:
1724 except KeyboardInterrupt:
1728 self.write_err("\nKeyboardInterrupt\n")
1725 self.write_err("\nKeyboardInterrupt\n")
1729
1726
1730 def _showtraceback(self, etype, evalue, stb):
1727 def _showtraceback(self, etype, evalue, stb):
1731 """Actually show a traceback.
1728 """Actually show a traceback.
1732
1729
1733 Subclasses may override this method to put the traceback on a different
1730 Subclasses may override this method to put the traceback on a different
1734 place, like a side channel.
1731 place, like a side channel.
1735 """
1732 """
1736 print >> io.stdout, self.InteractiveTB.stb2text(stb)
1733 print >> io.stdout, self.InteractiveTB.stb2text(stb)
1737
1734
1738 def showsyntaxerror(self, filename=None):
1735 def showsyntaxerror(self, filename=None):
1739 """Display the syntax error that just occurred.
1736 """Display the syntax error that just occurred.
1740
1737
1741 This doesn't display a stack trace because there isn't one.
1738 This doesn't display a stack trace because there isn't one.
1742
1739
1743 If a filename is given, it is stuffed in the exception instead
1740 If a filename is given, it is stuffed in the exception instead
1744 of what was there before (because Python's parser always uses
1741 of what was there before (because Python's parser always uses
1745 "<string>" when reading from a string).
1742 "<string>" when reading from a string).
1746 """
1743 """
1747 etype, value, last_traceback = self._get_exc_info()
1744 etype, value, last_traceback = self._get_exc_info()
1748
1745
1749 if filename and etype is SyntaxError:
1746 if filename and etype is SyntaxError:
1750 try:
1747 try:
1751 value.filename = filename
1748 value.filename = filename
1752 except:
1749 except:
1753 # Not the format we expect; leave it alone
1750 # Not the format we expect; leave it alone
1754 pass
1751 pass
1755
1752
1756 stb = self.SyntaxTB.structured_traceback(etype, value, [])
1753 stb = self.SyntaxTB.structured_traceback(etype, value, [])
1757 self._showtraceback(etype, value, stb)
1754 self._showtraceback(etype, value, stb)
1758
1755
1759 # This is overridden in TerminalInteractiveShell to show a message about
1756 # This is overridden in TerminalInteractiveShell to show a message about
1760 # the %paste magic.
1757 # the %paste magic.
1761 def showindentationerror(self):
1758 def showindentationerror(self):
1762 """Called by run_cell when there's an IndentationError in code entered
1759 """Called by run_cell when there's an IndentationError in code entered
1763 at the prompt.
1760 at the prompt.
1764
1761
1765 This is overridden in TerminalInteractiveShell to show a message about
1762 This is overridden in TerminalInteractiveShell to show a message about
1766 the %paste magic."""
1763 the %paste magic."""
1767 self.showsyntaxerror()
1764 self.showsyntaxerror()
1768
1765
1769 #-------------------------------------------------------------------------
1766 #-------------------------------------------------------------------------
1770 # Things related to readline
1767 # Things related to readline
1771 #-------------------------------------------------------------------------
1768 #-------------------------------------------------------------------------
1772
1769
1773 def init_readline(self):
1770 def init_readline(self):
1774 """Command history completion/saving/reloading."""
1771 """Command history completion/saving/reloading."""
1775
1772
1776 if self.readline_use:
1773 if self.readline_use:
1777 import IPython.utils.rlineimpl as readline
1774 import IPython.utils.rlineimpl as readline
1778
1775
1779 self.rl_next_input = None
1776 self.rl_next_input = None
1780 self.rl_do_indent = False
1777 self.rl_do_indent = False
1781
1778
1782 if not self.readline_use or not readline.have_readline:
1779 if not self.readline_use or not readline.have_readline:
1783 self.has_readline = False
1780 self.has_readline = False
1784 self.readline = None
1781 self.readline = None
1785 # Set a number of methods that depend on readline to be no-op
1782 # Set a number of methods that depend on readline to be no-op
1786 self.readline_no_record = no_op_context
1783 self.readline_no_record = no_op_context
1787 self.set_readline_completer = no_op
1784 self.set_readline_completer = no_op
1788 self.set_custom_completer = no_op
1785 self.set_custom_completer = no_op
1789 self.set_completer_frame = no_op
1786 self.set_completer_frame = no_op
1790 if self.readline_use:
1787 if self.readline_use:
1791 warn('Readline services not available or not loaded.')
1788 warn('Readline services not available or not loaded.')
1792 else:
1789 else:
1793 self.has_readline = True
1790 self.has_readline = True
1794 self.readline = readline
1791 self.readline = readline
1795 sys.modules['readline'] = readline
1792 sys.modules['readline'] = readline
1796
1793
1797 # Platform-specific configuration
1794 # Platform-specific configuration
1798 if os.name == 'nt':
1795 if os.name == 'nt':
1799 # FIXME - check with Frederick to see if we can harmonize
1796 # FIXME - check with Frederick to see if we can harmonize
1800 # naming conventions with pyreadline to avoid this
1797 # naming conventions with pyreadline to avoid this
1801 # platform-dependent check
1798 # platform-dependent check
1802 self.readline_startup_hook = readline.set_pre_input_hook
1799 self.readline_startup_hook = readline.set_pre_input_hook
1803 else:
1800 else:
1804 self.readline_startup_hook = readline.set_startup_hook
1801 self.readline_startup_hook = readline.set_startup_hook
1805
1802
1806 # Load user's initrc file (readline config)
1803 # Load user's initrc file (readline config)
1807 # Or if libedit is used, load editrc.
1804 # Or if libedit is used, load editrc.
1808 inputrc_name = os.environ.get('INPUTRC')
1805 inputrc_name = os.environ.get('INPUTRC')
1809 if inputrc_name is None:
1806 if inputrc_name is None:
1810 inputrc_name = '.inputrc'
1807 inputrc_name = '.inputrc'
1811 if readline.uses_libedit:
1808 if readline.uses_libedit:
1812 inputrc_name = '.editrc'
1809 inputrc_name = '.editrc'
1813 inputrc_name = os.path.join(self.home_dir, inputrc_name)
1810 inputrc_name = os.path.join(self.home_dir, inputrc_name)
1814 if os.path.isfile(inputrc_name):
1811 if os.path.isfile(inputrc_name):
1815 try:
1812 try:
1816 readline.read_init_file(inputrc_name)
1813 readline.read_init_file(inputrc_name)
1817 except:
1814 except:
1818 warn('Problems reading readline initialization file <%s>'
1815 warn('Problems reading readline initialization file <%s>'
1819 % inputrc_name)
1816 % inputrc_name)
1820
1817
1821 # Configure readline according to user's prefs
1818 # Configure readline according to user's prefs
1822 # This is only done if GNU readline is being used. If libedit
1819 # This is only done if GNU readline is being used. If libedit
1823 # is being used (as on Leopard) the readline config is
1820 # is being used (as on Leopard) the readline config is
1824 # not run as the syntax for libedit is different.
1821 # not run as the syntax for libedit is different.
1825 if not readline.uses_libedit:
1822 if not readline.uses_libedit:
1826 for rlcommand in self.readline_parse_and_bind:
1823 for rlcommand in self.readline_parse_and_bind:
1827 #print "loading rl:",rlcommand # dbg
1824 #print "loading rl:",rlcommand # dbg
1828 readline.parse_and_bind(rlcommand)
1825 readline.parse_and_bind(rlcommand)
1829
1826
1830 # Remove some chars from the delimiters list. If we encounter
1827 # Remove some chars from the delimiters list. If we encounter
1831 # unicode chars, discard them.
1828 # unicode chars, discard them.
1832 delims = readline.get_completer_delims()
1829 delims = readline.get_completer_delims()
1833 if not py3compat.PY3:
1830 if not py3compat.PY3:
1834 delims = delims.encode("ascii", "ignore")
1831 delims = delims.encode("ascii", "ignore")
1835 for d in self.readline_remove_delims:
1832 for d in self.readline_remove_delims:
1836 delims = delims.replace(d, "")
1833 delims = delims.replace(d, "")
1837 delims = delims.replace(ESC_MAGIC, '')
1834 delims = delims.replace(ESC_MAGIC, '')
1838 readline.set_completer_delims(delims)
1835 readline.set_completer_delims(delims)
1839 # otherwise we end up with a monster history after a while:
1836 # otherwise we end up with a monster history after a while:
1840 readline.set_history_length(self.history_length)
1837 readline.set_history_length(self.history_length)
1841
1838
1842 self.refill_readline_hist()
1839 self.refill_readline_hist()
1843 self.readline_no_record = ReadlineNoRecord(self)
1840 self.readline_no_record = ReadlineNoRecord(self)
1844
1841
1845 # Configure auto-indent for all platforms
1842 # Configure auto-indent for all platforms
1846 self.set_autoindent(self.autoindent)
1843 self.set_autoindent(self.autoindent)
1847
1844
1848 def refill_readline_hist(self):
1845 def refill_readline_hist(self):
1849 # Load the last 1000 lines from history
1846 # Load the last 1000 lines from history
1850 self.readline.clear_history()
1847 self.readline.clear_history()
1851 stdin_encoding = sys.stdin.encoding or "utf-8"
1848 stdin_encoding = sys.stdin.encoding or "utf-8"
1852 last_cell = u""
1849 last_cell = u""
1853 for _, _, cell in self.history_manager.get_tail(1000,
1850 for _, _, cell in self.history_manager.get_tail(1000,
1854 include_latest=True):
1851 include_latest=True):
1855 # Ignore blank lines and consecutive duplicates
1852 # Ignore blank lines and consecutive duplicates
1856 cell = cell.rstrip()
1853 cell = cell.rstrip()
1857 if cell and (cell != last_cell):
1854 if cell and (cell != last_cell):
1858 if self.multiline_history:
1855 if self.multiline_history:
1859 self.readline.add_history(py3compat.unicode_to_str(cell,
1856 self.readline.add_history(py3compat.unicode_to_str(cell,
1860 stdin_encoding))
1857 stdin_encoding))
1861 else:
1858 else:
1862 for line in cell.splitlines():
1859 for line in cell.splitlines():
1863 self.readline.add_history(py3compat.unicode_to_str(line,
1860 self.readline.add_history(py3compat.unicode_to_str(line,
1864 stdin_encoding))
1861 stdin_encoding))
1865 last_cell = cell
1862 last_cell = cell
1866
1863
1867 def set_next_input(self, s):
1864 def set_next_input(self, s):
1868 """ Sets the 'default' input string for the next command line.
1865 """ Sets the 'default' input string for the next command line.
1869
1866
1870 Requires readline.
1867 Requires readline.
1871
1868
1872 Example:
1869 Example:
1873
1870
1874 [D:\ipython]|1> _ip.set_next_input("Hello Word")
1871 [D:\ipython]|1> _ip.set_next_input("Hello Word")
1875 [D:\ipython]|2> Hello Word_ # cursor is here
1872 [D:\ipython]|2> Hello Word_ # cursor is here
1876 """
1873 """
1877 self.rl_next_input = py3compat.cast_bytes_py2(s)
1874 self.rl_next_input = py3compat.cast_bytes_py2(s)
1878
1875
1879 # Maybe move this to the terminal subclass?
1876 # Maybe move this to the terminal subclass?
1880 def pre_readline(self):
1877 def pre_readline(self):
1881 """readline hook to be used at the start of each line.
1878 """readline hook to be used at the start of each line.
1882
1879
1883 Currently it handles auto-indent only."""
1880 Currently it handles auto-indent only."""
1884
1881
1885 if self.rl_do_indent:
1882 if self.rl_do_indent:
1886 self.readline.insert_text(self._indent_current_str())
1883 self.readline.insert_text(self._indent_current_str())
1887 if self.rl_next_input is not None:
1884 if self.rl_next_input is not None:
1888 self.readline.insert_text(self.rl_next_input)
1885 self.readline.insert_text(self.rl_next_input)
1889 self.rl_next_input = None
1886 self.rl_next_input = None
1890
1887
1891 def _indent_current_str(self):
1888 def _indent_current_str(self):
1892 """return the current level of indentation as a string"""
1889 """return the current level of indentation as a string"""
1893 return self.input_splitter.indent_spaces * ' '
1890 return self.input_splitter.indent_spaces * ' '
1894
1891
1895 #-------------------------------------------------------------------------
1892 #-------------------------------------------------------------------------
1896 # Things related to text completion
1893 # Things related to text completion
1897 #-------------------------------------------------------------------------
1894 #-------------------------------------------------------------------------
1898
1895
1899 def init_completer(self):
1896 def init_completer(self):
1900 """Initialize the completion machinery.
1897 """Initialize the completion machinery.
1901
1898
1902 This creates completion machinery that can be used by client code,
1899 This creates completion machinery that can be used by client code,
1903 either interactively in-process (typically triggered by the readline
1900 either interactively in-process (typically triggered by the readline
1904 library), programatically (such as in test suites) or out-of-prcess
1901 library), programatically (such as in test suites) or out-of-prcess
1905 (typically over the network by remote frontends).
1902 (typically over the network by remote frontends).
1906 """
1903 """
1907 from IPython.core.completer import IPCompleter
1904 from IPython.core.completer import IPCompleter
1908 from IPython.core.completerlib import (module_completer,
1905 from IPython.core.completerlib import (module_completer,
1909 magic_run_completer, cd_completer, reset_completer)
1906 magic_run_completer, cd_completer, reset_completer)
1910
1907
1911 self.Completer = IPCompleter(shell=self,
1908 self.Completer = IPCompleter(shell=self,
1912 namespace=self.user_ns,
1909 namespace=self.user_ns,
1913 global_namespace=self.user_global_ns,
1910 global_namespace=self.user_global_ns,
1914 alias_table=self.alias_manager.alias_table,
1911 alias_table=self.alias_manager.alias_table,
1915 use_readline=self.has_readline,
1912 use_readline=self.has_readline,
1916 config=self.config,
1913 config=self.config,
1917 )
1914 )
1918 self.configurables.append(self.Completer)
1915 self.configurables.append(self.Completer)
1919
1916
1920 # Add custom completers to the basic ones built into IPCompleter
1917 # Add custom completers to the basic ones built into IPCompleter
1921 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1918 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1922 self.strdispatchers['complete_command'] = sdisp
1919 self.strdispatchers['complete_command'] = sdisp
1923 self.Completer.custom_completers = sdisp
1920 self.Completer.custom_completers = sdisp
1924
1921
1925 self.set_hook('complete_command', module_completer, str_key = 'import')
1922 self.set_hook('complete_command', module_completer, str_key = 'import')
1926 self.set_hook('complete_command', module_completer, str_key = 'from')
1923 self.set_hook('complete_command', module_completer, str_key = 'from')
1927 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
1924 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
1928 self.set_hook('complete_command', cd_completer, str_key = '%cd')
1925 self.set_hook('complete_command', cd_completer, str_key = '%cd')
1929 self.set_hook('complete_command', reset_completer, str_key = '%reset')
1926 self.set_hook('complete_command', reset_completer, str_key = '%reset')
1930
1927
1931 # Only configure readline if we truly are using readline. IPython can
1928 # Only configure readline if we truly are using readline. IPython can
1932 # do tab-completion over the network, in GUIs, etc, where readline
1929 # do tab-completion over the network, in GUIs, etc, where readline
1933 # itself may be absent
1930 # itself may be absent
1934 if self.has_readline:
1931 if self.has_readline:
1935 self.set_readline_completer()
1932 self.set_readline_completer()
1936
1933
1937 def complete(self, text, line=None, cursor_pos=None):
1934 def complete(self, text, line=None, cursor_pos=None):
1938 """Return the completed text and a list of completions.
1935 """Return the completed text and a list of completions.
1939
1936
1940 Parameters
1937 Parameters
1941 ----------
1938 ----------
1942
1939
1943 text : string
1940 text : string
1944 A string of text to be completed on. It can be given as empty and
1941 A string of text to be completed on. It can be given as empty and
1945 instead a line/position pair are given. In this case, the
1942 instead a line/position pair are given. In this case, the
1946 completer itself will split the line like readline does.
1943 completer itself will split the line like readline does.
1947
1944
1948 line : string, optional
1945 line : string, optional
1949 The complete line that text is part of.
1946 The complete line that text is part of.
1950
1947
1951 cursor_pos : int, optional
1948 cursor_pos : int, optional
1952 The position of the cursor on the input line.
1949 The position of the cursor on the input line.
1953
1950
1954 Returns
1951 Returns
1955 -------
1952 -------
1956 text : string
1953 text : string
1957 The actual text that was completed.
1954 The actual text that was completed.
1958
1955
1959 matches : list
1956 matches : list
1960 A sorted list with all possible completions.
1957 A sorted list with all possible completions.
1961
1958
1962 The optional arguments allow the completion to take more context into
1959 The optional arguments allow the completion to take more context into
1963 account, and are part of the low-level completion API.
1960 account, and are part of the low-level completion API.
1964
1961
1965 This is a wrapper around the completion mechanism, similar to what
1962 This is a wrapper around the completion mechanism, similar to what
1966 readline does at the command line when the TAB key is hit. By
1963 readline does at the command line when the TAB key is hit. By
1967 exposing it as a method, it can be used by other non-readline
1964 exposing it as a method, it can be used by other non-readline
1968 environments (such as GUIs) for text completion.
1965 environments (such as GUIs) for text completion.
1969
1966
1970 Simple usage example:
1967 Simple usage example:
1971
1968
1972 In [1]: x = 'hello'
1969 In [1]: x = 'hello'
1973
1970
1974 In [2]: _ip.complete('x.l')
1971 In [2]: _ip.complete('x.l')
1975 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
1972 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
1976 """
1973 """
1977
1974
1978 # Inject names into __builtin__ so we can complete on the added names.
1975 # Inject names into __builtin__ so we can complete on the added names.
1979 with self.builtin_trap:
1976 with self.builtin_trap:
1980 return self.Completer.complete(text, line, cursor_pos)
1977 return self.Completer.complete(text, line, cursor_pos)
1981
1978
1982 def set_custom_completer(self, completer, pos=0):
1979 def set_custom_completer(self, completer, pos=0):
1983 """Adds a new custom completer function.
1980 """Adds a new custom completer function.
1984
1981
1985 The position argument (defaults to 0) is the index in the completers
1982 The position argument (defaults to 0) is the index in the completers
1986 list where you want the completer to be inserted."""
1983 list where you want the completer to be inserted."""
1987
1984
1988 newcomp = types.MethodType(completer,self.Completer)
1985 newcomp = types.MethodType(completer,self.Completer)
1989 self.Completer.matchers.insert(pos,newcomp)
1986 self.Completer.matchers.insert(pos,newcomp)
1990
1987
1991 def set_readline_completer(self):
1988 def set_readline_completer(self):
1992 """Reset readline's completer to be our own."""
1989 """Reset readline's completer to be our own."""
1993 self.readline.set_completer(self.Completer.rlcomplete)
1990 self.readline.set_completer(self.Completer.rlcomplete)
1994
1991
1995 def set_completer_frame(self, frame=None):
1992 def set_completer_frame(self, frame=None):
1996 """Set the frame of the completer."""
1993 """Set the frame of the completer."""
1997 if frame:
1994 if frame:
1998 self.Completer.namespace = frame.f_locals
1995 self.Completer.namespace = frame.f_locals
1999 self.Completer.global_namespace = frame.f_globals
1996 self.Completer.global_namespace = frame.f_globals
2000 else:
1997 else:
2001 self.Completer.namespace = self.user_ns
1998 self.Completer.namespace = self.user_ns
2002 self.Completer.global_namespace = self.user_global_ns
1999 self.Completer.global_namespace = self.user_global_ns
2003
2000
2004 #-------------------------------------------------------------------------
2001 #-------------------------------------------------------------------------
2005 # Things related to magics
2002 # Things related to magics
2006 #-------------------------------------------------------------------------
2003 #-------------------------------------------------------------------------
2007
2004
2008 def init_magics(self):
2005 def init_magics(self):
2009 from IPython.core import magics as m
2006 from IPython.core import magics as m
2010 self.magics_manager = magic.MagicsManager(shell=self,
2007 self.magics_manager = magic.MagicsManager(shell=self,
2011 confg=self.config,
2008 confg=self.config,
2012 user_magics=m.UserMagics(self))
2009 user_magics=m.UserMagics(self))
2013 self.configurables.append(self.magics_manager)
2010 self.configurables.append(self.magics_manager)
2014
2011
2015 # Expose as public API from the magics manager
2012 # Expose as public API from the magics manager
2016 self.register_magics = self.magics_manager.register
2013 self.register_magics = self.magics_manager.register
2017 self.register_magic_function = self.magics_manager.register_function
2014 self.register_magic_function = self.magics_manager.register_function
2018 self.define_magic = self.magics_manager.define_magic
2015 self.define_magic = self.magics_manager.define_magic
2019
2016
2020 self.register_magics(m.AutoMagics, m.BasicMagics, m.CodeMagics,
2017 self.register_magics(m.AutoMagics, m.BasicMagics, m.CodeMagics,
2021 m.ConfigMagics, m.DeprecatedMagics, m.ExecutionMagics,
2018 m.ConfigMagics, m.DeprecatedMagics, m.ExecutionMagics,
2022 m.ExtensionMagics, m.HistoryMagics, m.LoggingMagics,
2019 m.ExtensionMagics, m.HistoryMagics, m.LoggingMagics,
2023 m.NamespaceMagics, m.OSMagics, m.PylabMagics )
2020 m.NamespaceMagics, m.OSMagics, m.PylabMagics )
2024
2021
2025 # FIXME: Move the color initialization to the DisplayHook, which
2022 # FIXME: Move the color initialization to the DisplayHook, which
2026 # should be split into a prompt manager and displayhook. We probably
2023 # should be split into a prompt manager and displayhook. We probably
2027 # even need a centralize colors management object.
2024 # even need a centralize colors management object.
2028 self.magic('colors %s' % self.colors)
2025 self.magic('colors %s' % self.colors)
2029
2026
2030 def run_line_magic(self, magic_name, line):
2027 def run_line_magic(self, magic_name, line):
2031 """Execute the given line magic.
2028 """Execute the given line magic.
2032
2029
2033 Parameters
2030 Parameters
2034 ----------
2031 ----------
2035 magic_name : str
2032 magic_name : str
2036 Name of the desired magic function, without '%' prefix.
2033 Name of the desired magic function, without '%' prefix.
2037
2034
2038 line : str
2035 line : str
2039 The rest of the input line as a single string.
2036 The rest of the input line as a single string.
2040 """
2037 """
2041 fn = self.find_line_magic(magic_name)
2038 fn = self.find_line_magic(magic_name)
2042 if fn is None:
2039 if fn is None:
2043 cm = self.find_cell_magic(magic_name)
2040 cm = self.find_cell_magic(magic_name)
2044 etpl = "Line magic function `%%%s` not found%s."
2041 etpl = "Line magic function `%%%s` not found%s."
2045 extra = '' if cm is None else (' (But cell magic `%%%%%s` exists, '
2042 extra = '' if cm is None else (' (But cell magic `%%%%%s` exists, '
2046 'did you mean that instead?)' % magic_name )
2043 'did you mean that instead?)' % magic_name )
2047 error(etpl % (magic_name, extra))
2044 error(etpl % (magic_name, extra))
2048 else:
2045 else:
2049 # Note: this is the distance in the stack to the user's frame.
2046 # Note: this is the distance in the stack to the user's frame.
2050 # This will need to be updated if the internal calling logic gets
2047 # This will need to be updated if the internal calling logic gets
2051 # refactored, or else we'll be expanding the wrong variables.
2048 # refactored, or else we'll be expanding the wrong variables.
2052 stack_depth = 2
2049 stack_depth = 2
2053 magic_arg_s = self.var_expand(line, stack_depth)
2050 magic_arg_s = self.var_expand(line, stack_depth)
2054 # Put magic args in a list so we can call with f(*a) syntax
2051 # Put magic args in a list so we can call with f(*a) syntax
2055 args = [magic_arg_s]
2052 args = [magic_arg_s]
2056 # Grab local namespace if we need it:
2053 # Grab local namespace if we need it:
2057 if getattr(fn, "needs_local_scope", False):
2054 if getattr(fn, "needs_local_scope", False):
2058 args.append(sys._getframe(stack_depth).f_locals)
2055 args.append(sys._getframe(stack_depth).f_locals)
2059 with self.builtin_trap:
2056 with self.builtin_trap:
2060 result = fn(*args)
2057 result = fn(*args)
2061 return result
2058 return result
2062
2059
2063 def run_cell_magic(self, magic_name, line, cell):
2060 def run_cell_magic(self, magic_name, line, cell):
2064 """Execute the given cell magic.
2061 """Execute the given cell magic.
2065
2062
2066 Parameters
2063 Parameters
2067 ----------
2064 ----------
2068 magic_name : str
2065 magic_name : str
2069 Name of the desired magic function, without '%' prefix.
2066 Name of the desired magic function, without '%' prefix.
2070
2067
2071 line : str
2068 line : str
2072 The rest of the first input line as a single string.
2069 The rest of the first input line as a single string.
2073
2070
2074 cell : str
2071 cell : str
2075 The body of the cell as a (possibly multiline) string.
2072 The body of the cell as a (possibly multiline) string.
2076 """
2073 """
2077 fn = self.find_cell_magic(magic_name)
2074 fn = self.find_cell_magic(magic_name)
2078 if fn is None:
2075 if fn is None:
2079 lm = self.find_line_magic(magic_name)
2076 lm = self.find_line_magic(magic_name)
2080 etpl = "Cell magic function `%%%%%s` not found%s."
2077 etpl = "Cell magic function `%%%%%s` not found%s."
2081 extra = '' if lm is None else (' (But line magic `%%%s` exists, '
2078 extra = '' if lm is None else (' (But line magic `%%%s` exists, '
2082 'did you mean that instead?)' % magic_name )
2079 'did you mean that instead?)' % magic_name )
2083 error(etpl % (magic_name, extra))
2080 error(etpl % (magic_name, extra))
2084 else:
2081 else:
2085 # Note: this is the distance in the stack to the user's frame.
2082 # Note: this is the distance in the stack to the user's frame.
2086 # This will need to be updated if the internal calling logic gets
2083 # This will need to be updated if the internal calling logic gets
2087 # refactored, or else we'll be expanding the wrong variables.
2084 # refactored, or else we'll be expanding the wrong variables.
2088 stack_depth = 2
2085 stack_depth = 2
2089 magic_arg_s = self.var_expand(line, stack_depth)
2086 magic_arg_s = self.var_expand(line, stack_depth)
2090 with self.builtin_trap:
2087 with self.builtin_trap:
2091 result = fn(line, cell)
2088 result = fn(line, cell)
2092 return result
2089 return result
2093
2090
2094 def find_line_magic(self, magic_name):
2091 def find_line_magic(self, magic_name):
2095 """Find and return a line magic by name.
2092 """Find and return a line magic by name.
2096
2093
2097 Returns None if the magic isn't found."""
2094 Returns None if the magic isn't found."""
2098 return self.magics_manager.magics['line'].get(magic_name)
2095 return self.magics_manager.magics['line'].get(magic_name)
2099
2096
2100 def find_cell_magic(self, magic_name):
2097 def find_cell_magic(self, magic_name):
2101 """Find and return a cell magic by name.
2098 """Find and return a cell magic by name.
2102
2099
2103 Returns None if the magic isn't found."""
2100 Returns None if the magic isn't found."""
2104 return self.magics_manager.magics['cell'].get(magic_name)
2101 return self.magics_manager.magics['cell'].get(magic_name)
2105
2102
2106 def find_magic(self, magic_name, magic_kind='line'):
2103 def find_magic(self, magic_name, magic_kind='line'):
2107 """Find and return a magic of the given type by name.
2104 """Find and return a magic of the given type by name.
2108
2105
2109 Returns None if the magic isn't found."""
2106 Returns None if the magic isn't found."""
2110 return self.magics_manager.magics[magic_kind].get(magic_name)
2107 return self.magics_manager.magics[magic_kind].get(magic_name)
2111
2108
2112 def magic(self, arg_s):
2109 def magic(self, arg_s):
2113 """DEPRECATED. Use run_line_magic() instead.
2110 """DEPRECATED. Use run_line_magic() instead.
2114
2111
2115 Call a magic function by name.
2112 Call a magic function by name.
2116
2113
2117 Input: a string containing the name of the magic function to call and
2114 Input: a string containing the name of the magic function to call and
2118 any additional arguments to be passed to the magic.
2115 any additional arguments to be passed to the magic.
2119
2116
2120 magic('name -opt foo bar') is equivalent to typing at the ipython
2117 magic('name -opt foo bar') is equivalent to typing at the ipython
2121 prompt:
2118 prompt:
2122
2119
2123 In[1]: %name -opt foo bar
2120 In[1]: %name -opt foo bar
2124
2121
2125 To call a magic without arguments, simply use magic('name').
2122 To call a magic without arguments, simply use magic('name').
2126
2123
2127 This provides a proper Python function to call IPython's magics in any
2124 This provides a proper Python function to call IPython's magics in any
2128 valid Python code you can type at the interpreter, including loops and
2125 valid Python code you can type at the interpreter, including loops and
2129 compound statements.
2126 compound statements.
2130 """
2127 """
2131 # TODO: should we issue a loud deprecation warning here?
2128 # TODO: should we issue a loud deprecation warning here?
2132 magic_name, _, magic_arg_s = arg_s.partition(' ')
2129 magic_name, _, magic_arg_s = arg_s.partition(' ')
2133 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
2130 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
2134 return self.run_line_magic(magic_name, magic_arg_s)
2131 return self.run_line_magic(magic_name, magic_arg_s)
2135
2132
2136 #-------------------------------------------------------------------------
2133 #-------------------------------------------------------------------------
2137 # Things related to macros
2134 # Things related to macros
2138 #-------------------------------------------------------------------------
2135 #-------------------------------------------------------------------------
2139
2136
2140 def define_macro(self, name, themacro):
2137 def define_macro(self, name, themacro):
2141 """Define a new macro
2138 """Define a new macro
2142
2139
2143 Parameters
2140 Parameters
2144 ----------
2141 ----------
2145 name : str
2142 name : str
2146 The name of the macro.
2143 The name of the macro.
2147 themacro : str or Macro
2144 themacro : str or Macro
2148 The action to do upon invoking the macro. If a string, a new
2145 The action to do upon invoking the macro. If a string, a new
2149 Macro object is created by passing the string to it.
2146 Macro object is created by passing the string to it.
2150 """
2147 """
2151
2148
2152 from IPython.core import macro
2149 from IPython.core import macro
2153
2150
2154 if isinstance(themacro, basestring):
2151 if isinstance(themacro, basestring):
2155 themacro = macro.Macro(themacro)
2152 themacro = macro.Macro(themacro)
2156 if not isinstance(themacro, macro.Macro):
2153 if not isinstance(themacro, macro.Macro):
2157 raise ValueError('A macro must be a string or a Macro instance.')
2154 raise ValueError('A macro must be a string or a Macro instance.')
2158 self.user_ns[name] = themacro
2155 self.user_ns[name] = themacro
2159
2156
2160 #-------------------------------------------------------------------------
2157 #-------------------------------------------------------------------------
2161 # Things related to the running of system commands
2158 # Things related to the running of system commands
2162 #-------------------------------------------------------------------------
2159 #-------------------------------------------------------------------------
2163
2160
2164 def system_piped(self, cmd):
2161 def system_piped(self, cmd):
2165 """Call the given cmd in a subprocess, piping stdout/err
2162 """Call the given cmd in a subprocess, piping stdout/err
2166
2163
2167 Parameters
2164 Parameters
2168 ----------
2165 ----------
2169 cmd : str
2166 cmd : str
2170 Command to execute (can not end in '&', as background processes are
2167 Command to execute (can not end in '&', as background processes are
2171 not supported. Should not be a command that expects input
2168 not supported. Should not be a command that expects input
2172 other than simple text.
2169 other than simple text.
2173 """
2170 """
2174 if cmd.rstrip().endswith('&'):
2171 if cmd.rstrip().endswith('&'):
2175 # this is *far* from a rigorous test
2172 # this is *far* from a rigorous test
2176 # We do not support backgrounding processes because we either use
2173 # We do not support backgrounding processes because we either use
2177 # pexpect or pipes to read from. Users can always just call
2174 # pexpect or pipes to read from. Users can always just call
2178 # os.system() or use ip.system=ip.system_raw
2175 # os.system() or use ip.system=ip.system_raw
2179 # if they really want a background process.
2176 # if they really want a background process.
2180 raise OSError("Background processes not supported.")
2177 raise OSError("Background processes not supported.")
2181
2178
2182 # we explicitly do NOT return the subprocess status code, because
2179 # we explicitly do NOT return the subprocess status code, because
2183 # a non-None value would trigger :func:`sys.displayhook` calls.
2180 # a non-None value would trigger :func:`sys.displayhook` calls.
2184 # Instead, we store the exit_code in user_ns.
2181 # Instead, we store the exit_code in user_ns.
2185 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=2))
2182 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=2))
2186
2183
2187 def system_raw(self, cmd):
2184 def system_raw(self, cmd):
2188 """Call the given cmd in a subprocess using os.system
2185 """Call the given cmd in a subprocess using os.system
2189
2186
2190 Parameters
2187 Parameters
2191 ----------
2188 ----------
2192 cmd : str
2189 cmd : str
2193 Command to execute.
2190 Command to execute.
2194 """
2191 """
2195 cmd = self.var_expand(cmd, depth=2)
2192 cmd = self.var_expand(cmd, depth=2)
2196 # protect os.system from UNC paths on Windows, which it can't handle:
2193 # protect os.system from UNC paths on Windows, which it can't handle:
2197 if sys.platform == 'win32':
2194 if sys.platform == 'win32':
2198 from IPython.utils._process_win32 import AvoidUNCPath
2195 from IPython.utils._process_win32 import AvoidUNCPath
2199 with AvoidUNCPath() as path:
2196 with AvoidUNCPath() as path:
2200 if path is not None:
2197 if path is not None:
2201 cmd = '"pushd %s &&"%s' % (path, cmd)
2198 cmd = '"pushd %s &&"%s' % (path, cmd)
2202 cmd = py3compat.unicode_to_str(cmd)
2199 cmd = py3compat.unicode_to_str(cmd)
2203 ec = os.system(cmd)
2200 ec = os.system(cmd)
2204 else:
2201 else:
2205 cmd = py3compat.unicode_to_str(cmd)
2202 cmd = py3compat.unicode_to_str(cmd)
2206 ec = os.system(cmd)
2203 ec = os.system(cmd)
2207
2204
2208 # We explicitly do NOT return the subprocess status code, because
2205 # We explicitly do NOT return the subprocess status code, because
2209 # a non-None value would trigger :func:`sys.displayhook` calls.
2206 # a non-None value would trigger :func:`sys.displayhook` calls.
2210 # Instead, we store the exit_code in user_ns.
2207 # Instead, we store the exit_code in user_ns.
2211 self.user_ns['_exit_code'] = ec
2208 self.user_ns['_exit_code'] = ec
2212
2209
2213 # use piped system by default, because it is better behaved
2210 # use piped system by default, because it is better behaved
2214 system = system_piped
2211 system = system_piped
2215
2212
2216 def getoutput(self, cmd, split=True):
2213 def getoutput(self, cmd, split=True):
2217 """Get output (possibly including stderr) from a subprocess.
2214 """Get output (possibly including stderr) from a subprocess.
2218
2215
2219 Parameters
2216 Parameters
2220 ----------
2217 ----------
2221 cmd : str
2218 cmd : str
2222 Command to execute (can not end in '&', as background processes are
2219 Command to execute (can not end in '&', as background processes are
2223 not supported.
2220 not supported.
2224 split : bool, optional
2221 split : bool, optional
2225
2222
2226 If True, split the output into an IPython SList. Otherwise, an
2223 If True, split the output into an IPython SList. Otherwise, an
2227 IPython LSString is returned. These are objects similar to normal
2224 IPython LSString is returned. These are objects similar to normal
2228 lists and strings, with a few convenience attributes for easier
2225 lists and strings, with a few convenience attributes for easier
2229 manipulation of line-based output. You can use '?' on them for
2226 manipulation of line-based output. You can use '?' on them for
2230 details.
2227 details.
2231 """
2228 """
2232 if cmd.rstrip().endswith('&'):
2229 if cmd.rstrip().endswith('&'):
2233 # this is *far* from a rigorous test
2230 # this is *far* from a rigorous test
2234 raise OSError("Background processes not supported.")
2231 raise OSError("Background processes not supported.")
2235 out = getoutput(self.var_expand(cmd, depth=2))
2232 out = getoutput(self.var_expand(cmd, depth=2))
2236 if split:
2233 if split:
2237 out = SList(out.splitlines())
2234 out = SList(out.splitlines())
2238 else:
2235 else:
2239 out = LSString(out)
2236 out = LSString(out)
2240 return out
2237 return out
2241
2238
2242 #-------------------------------------------------------------------------
2239 #-------------------------------------------------------------------------
2243 # Things related to aliases
2240 # Things related to aliases
2244 #-------------------------------------------------------------------------
2241 #-------------------------------------------------------------------------
2245
2242
2246 def init_alias(self):
2243 def init_alias(self):
2247 self.alias_manager = AliasManager(shell=self, config=self.config)
2244 self.alias_manager = AliasManager(shell=self, config=self.config)
2248 self.configurables.append(self.alias_manager)
2245 self.configurables.append(self.alias_manager)
2249 self.ns_table['alias'] = self.alias_manager.alias_table,
2246 self.ns_table['alias'] = self.alias_manager.alias_table,
2250
2247
2251 #-------------------------------------------------------------------------
2248 #-------------------------------------------------------------------------
2252 # Things related to extensions and plugins
2249 # Things related to extensions and plugins
2253 #-------------------------------------------------------------------------
2250 #-------------------------------------------------------------------------
2254
2251
2255 def init_extension_manager(self):
2252 def init_extension_manager(self):
2256 self.extension_manager = ExtensionManager(shell=self, config=self.config)
2253 self.extension_manager = ExtensionManager(shell=self, config=self.config)
2257 self.configurables.append(self.extension_manager)
2254 self.configurables.append(self.extension_manager)
2258
2255
2259 def init_plugin_manager(self):
2256 def init_plugin_manager(self):
2260 self.plugin_manager = PluginManager(config=self.config)
2257 self.plugin_manager = PluginManager(config=self.config)
2261 self.configurables.append(self.plugin_manager)
2258 self.configurables.append(self.plugin_manager)
2262
2259
2263
2260
2264 #-------------------------------------------------------------------------
2261 #-------------------------------------------------------------------------
2265 # Things related to payloads
2262 # Things related to payloads
2266 #-------------------------------------------------------------------------
2263 #-------------------------------------------------------------------------
2267
2264
2268 def init_payload(self):
2265 def init_payload(self):
2269 self.payload_manager = PayloadManager(config=self.config)
2266 self.payload_manager = PayloadManager(config=self.config)
2270 self.configurables.append(self.payload_manager)
2267 self.configurables.append(self.payload_manager)
2271
2268
2272 #-------------------------------------------------------------------------
2269 #-------------------------------------------------------------------------
2273 # Things related to the prefilter
2270 # Things related to the prefilter
2274 #-------------------------------------------------------------------------
2271 #-------------------------------------------------------------------------
2275
2272
2276 def init_prefilter(self):
2273 def init_prefilter(self):
2277 self.prefilter_manager = PrefilterManager(shell=self, config=self.config)
2274 self.prefilter_manager = PrefilterManager(shell=self, config=self.config)
2278 self.configurables.append(self.prefilter_manager)
2275 self.configurables.append(self.prefilter_manager)
2279 # Ultimately this will be refactored in the new interpreter code, but
2276 # Ultimately this will be refactored in the new interpreter code, but
2280 # for now, we should expose the main prefilter method (there's legacy
2277 # for now, we should expose the main prefilter method (there's legacy
2281 # code out there that may rely on this).
2278 # code out there that may rely on this).
2282 self.prefilter = self.prefilter_manager.prefilter_lines
2279 self.prefilter = self.prefilter_manager.prefilter_lines
2283
2280
2284 def auto_rewrite_input(self, cmd):
2281 def auto_rewrite_input(self, cmd):
2285 """Print to the screen the rewritten form of the user's command.
2282 """Print to the screen the rewritten form of the user's command.
2286
2283
2287 This shows visual feedback by rewriting input lines that cause
2284 This shows visual feedback by rewriting input lines that cause
2288 automatic calling to kick in, like::
2285 automatic calling to kick in, like::
2289
2286
2290 /f x
2287 /f x
2291
2288
2292 into::
2289 into::
2293
2290
2294 ------> f(x)
2291 ------> f(x)
2295
2292
2296 after the user's input prompt. This helps the user understand that the
2293 after the user's input prompt. This helps the user understand that the
2297 input line was transformed automatically by IPython.
2294 input line was transformed automatically by IPython.
2298 """
2295 """
2299 if not self.show_rewritten_input:
2296 if not self.show_rewritten_input:
2300 return
2297 return
2301
2298
2302 rw = self.prompt_manager.render('rewrite') + cmd
2299 rw = self.prompt_manager.render('rewrite') + cmd
2303
2300
2304 try:
2301 try:
2305 # plain ascii works better w/ pyreadline, on some machines, so
2302 # plain ascii works better w/ pyreadline, on some machines, so
2306 # we use it and only print uncolored rewrite if we have unicode
2303 # we use it and only print uncolored rewrite if we have unicode
2307 rw = str(rw)
2304 rw = str(rw)
2308 print >> io.stdout, rw
2305 print >> io.stdout, rw
2309 except UnicodeEncodeError:
2306 except UnicodeEncodeError:
2310 print "------> " + cmd
2307 print "------> " + cmd
2311
2308
2312 #-------------------------------------------------------------------------
2309 #-------------------------------------------------------------------------
2313 # Things related to extracting values/expressions from kernel and user_ns
2310 # Things related to extracting values/expressions from kernel and user_ns
2314 #-------------------------------------------------------------------------
2311 #-------------------------------------------------------------------------
2315
2312
2316 def _simple_error(self):
2313 def _simple_error(self):
2317 etype, value = sys.exc_info()[:2]
2314 etype, value = sys.exc_info()[:2]
2318 return u'[ERROR] {e.__name__}: {v}'.format(e=etype, v=value)
2315 return u'[ERROR] {e.__name__}: {v}'.format(e=etype, v=value)
2319
2316
2320 def user_variables(self, names):
2317 def user_variables(self, names):
2321 """Get a list of variable names from the user's namespace.
2318 """Get a list of variable names from the user's namespace.
2322
2319
2323 Parameters
2320 Parameters
2324 ----------
2321 ----------
2325 names : list of strings
2322 names : list of strings
2326 A list of names of variables to be read from the user namespace.
2323 A list of names of variables to be read from the user namespace.
2327
2324
2328 Returns
2325 Returns
2329 -------
2326 -------
2330 A dict, keyed by the input names and with the repr() of each value.
2327 A dict, keyed by the input names and with the repr() of each value.
2331 """
2328 """
2332 out = {}
2329 out = {}
2333 user_ns = self.user_ns
2330 user_ns = self.user_ns
2334 for varname in names:
2331 for varname in names:
2335 try:
2332 try:
2336 value = repr(user_ns[varname])
2333 value = repr(user_ns[varname])
2337 except:
2334 except:
2338 value = self._simple_error()
2335 value = self._simple_error()
2339 out[varname] = value
2336 out[varname] = value
2340 return out
2337 return out
2341
2338
2342 def user_expressions(self, expressions):
2339 def user_expressions(self, expressions):
2343 """Evaluate a dict of expressions in the user's namespace.
2340 """Evaluate a dict of expressions in the user's namespace.
2344
2341
2345 Parameters
2342 Parameters
2346 ----------
2343 ----------
2347 expressions : dict
2344 expressions : dict
2348 A dict with string keys and string values. The expression values
2345 A dict with string keys and string values. The expression values
2349 should be valid Python expressions, each of which will be evaluated
2346 should be valid Python expressions, each of which will be evaluated
2350 in the user namespace.
2347 in the user namespace.
2351
2348
2352 Returns
2349 Returns
2353 -------
2350 -------
2354 A dict, keyed like the input expressions dict, with the repr() of each
2351 A dict, keyed like the input expressions dict, with the repr() of each
2355 value.
2352 value.
2356 """
2353 """
2357 out = {}
2354 out = {}
2358 user_ns = self.user_ns
2355 user_ns = self.user_ns
2359 global_ns = self.user_global_ns
2356 global_ns = self.user_global_ns
2360 for key, expr in expressions.iteritems():
2357 for key, expr in expressions.iteritems():
2361 try:
2358 try:
2362 value = repr(eval(expr, global_ns, user_ns))
2359 value = repr(eval(expr, global_ns, user_ns))
2363 except:
2360 except:
2364 value = self._simple_error()
2361 value = self._simple_error()
2365 out[key] = value
2362 out[key] = value
2366 return out
2363 return out
2367
2364
2368 #-------------------------------------------------------------------------
2365 #-------------------------------------------------------------------------
2369 # Things related to the running of code
2366 # Things related to the running of code
2370 #-------------------------------------------------------------------------
2367 #-------------------------------------------------------------------------
2371
2368
2372 def ex(self, cmd):
2369 def ex(self, cmd):
2373 """Execute a normal python statement in user namespace."""
2370 """Execute a normal python statement in user namespace."""
2374 with self.builtin_trap:
2371 with self.builtin_trap:
2375 exec cmd in self.user_global_ns, self.user_ns
2372 exec cmd in self.user_global_ns, self.user_ns
2376
2373
2377 def ev(self, expr):
2374 def ev(self, expr):
2378 """Evaluate python expression expr in user namespace.
2375 """Evaluate python expression expr in user namespace.
2379
2376
2380 Returns the result of evaluation
2377 Returns the result of evaluation
2381 """
2378 """
2382 with self.builtin_trap:
2379 with self.builtin_trap:
2383 return eval(expr, self.user_global_ns, self.user_ns)
2380 return eval(expr, self.user_global_ns, self.user_ns)
2384
2381
2385 def safe_execfile(self, fname, *where, **kw):
2382 def safe_execfile(self, fname, *where, **kw):
2386 """A safe version of the builtin execfile().
2383 """A safe version of the builtin execfile().
2387
2384
2388 This version will never throw an exception, but instead print
2385 This version will never throw an exception, but instead print
2389 helpful error messages to the screen. This only works on pure
2386 helpful error messages to the screen. This only works on pure
2390 Python files with the .py extension.
2387 Python files with the .py extension.
2391
2388
2392 Parameters
2389 Parameters
2393 ----------
2390 ----------
2394 fname : string
2391 fname : string
2395 The name of the file to be executed.
2392 The name of the file to be executed.
2396 where : tuple
2393 where : tuple
2397 One or two namespaces, passed to execfile() as (globals,locals).
2394 One or two namespaces, passed to execfile() as (globals,locals).
2398 If only one is given, it is passed as both.
2395 If only one is given, it is passed as both.
2399 exit_ignore : bool (False)
2396 exit_ignore : bool (False)
2400 If True, then silence SystemExit for non-zero status (it is always
2397 If True, then silence SystemExit for non-zero status (it is always
2401 silenced for zero status, as it is so common).
2398 silenced for zero status, as it is so common).
2402 raise_exceptions : bool (False)
2399 raise_exceptions : bool (False)
2403 If True raise exceptions everywhere. Meant for testing.
2400 If True raise exceptions everywhere. Meant for testing.
2404
2401
2405 """
2402 """
2406 kw.setdefault('exit_ignore', False)
2403 kw.setdefault('exit_ignore', False)
2407 kw.setdefault('raise_exceptions', False)
2404 kw.setdefault('raise_exceptions', False)
2408
2405
2409 fname = os.path.abspath(os.path.expanduser(fname))
2406 fname = os.path.abspath(os.path.expanduser(fname))
2410
2407
2411 # Make sure we can open the file
2408 # Make sure we can open the file
2412 try:
2409 try:
2413 with open(fname) as thefile:
2410 with open(fname) as thefile:
2414 pass
2411 pass
2415 except:
2412 except:
2416 warn('Could not open file <%s> for safe execution.' % fname)
2413 warn('Could not open file <%s> for safe execution.' % fname)
2417 return
2414 return
2418
2415
2419 # Find things also in current directory. This is needed to mimic the
2416 # Find things also in current directory. This is needed to mimic the
2420 # behavior of running a script from the system command line, where
2417 # behavior of running a script from the system command line, where
2421 # Python inserts the script's directory into sys.path
2418 # Python inserts the script's directory into sys.path
2422 dname = os.path.dirname(fname)
2419 dname = os.path.dirname(fname)
2423
2420
2424 with prepended_to_syspath(dname):
2421 with prepended_to_syspath(dname):
2425 try:
2422 try:
2426 py3compat.execfile(fname,*where)
2423 py3compat.execfile(fname,*where)
2427 except SystemExit, status:
2424 except SystemExit, status:
2428 # If the call was made with 0 or None exit status (sys.exit(0)
2425 # If the call was made with 0 or None exit status (sys.exit(0)
2429 # or sys.exit() ), don't bother showing a traceback, as both of
2426 # or sys.exit() ), don't bother showing a traceback, as both of
2430 # these are considered normal by the OS:
2427 # these are considered normal by the OS:
2431 # > python -c'import sys;sys.exit(0)'; echo $?
2428 # > python -c'import sys;sys.exit(0)'; echo $?
2432 # 0
2429 # 0
2433 # > python -c'import sys;sys.exit()'; echo $?
2430 # > python -c'import sys;sys.exit()'; echo $?
2434 # 0
2431 # 0
2435 # For other exit status, we show the exception unless
2432 # For other exit status, we show the exception unless
2436 # explicitly silenced, but only in short form.
2433 # explicitly silenced, but only in short form.
2437 if kw['raise_exceptions']:
2434 if kw['raise_exceptions']:
2438 raise
2435 raise
2439 if status.code not in (0, None) and not kw['exit_ignore']:
2436 if status.code not in (0, None) and not kw['exit_ignore']:
2440 self.showtraceback(exception_only=True)
2437 self.showtraceback(exception_only=True)
2441 except:
2438 except:
2442 if kw['raise_exceptions']:
2439 if kw['raise_exceptions']:
2443 raise
2440 raise
2444 self.showtraceback()
2441 self.showtraceback()
2445
2442
2446 def safe_execfile_ipy(self, fname):
2443 def safe_execfile_ipy(self, fname):
2447 """Like safe_execfile, but for .ipy files with IPython syntax.
2444 """Like safe_execfile, but for .ipy files with IPython syntax.
2448
2445
2449 Parameters
2446 Parameters
2450 ----------
2447 ----------
2451 fname : str
2448 fname : str
2452 The name of the file to execute. The filename must have a
2449 The name of the file to execute. The filename must have a
2453 .ipy extension.
2450 .ipy extension.
2454 """
2451 """
2455 fname = os.path.abspath(os.path.expanduser(fname))
2452 fname = os.path.abspath(os.path.expanduser(fname))
2456
2453
2457 # Make sure we can open the file
2454 # Make sure we can open the file
2458 try:
2455 try:
2459 with open(fname) as thefile:
2456 with open(fname) as thefile:
2460 pass
2457 pass
2461 except:
2458 except:
2462 warn('Could not open file <%s> for safe execution.' % fname)
2459 warn('Could not open file <%s> for safe execution.' % fname)
2463 return
2460 return
2464
2461
2465 # Find things also in current directory. This is needed to mimic the
2462 # Find things also in current directory. This is needed to mimic the
2466 # behavior of running a script from the system command line, where
2463 # behavior of running a script from the system command line, where
2467 # Python inserts the script's directory into sys.path
2464 # Python inserts the script's directory into sys.path
2468 dname = os.path.dirname(fname)
2465 dname = os.path.dirname(fname)
2469
2466
2470 with prepended_to_syspath(dname):
2467 with prepended_to_syspath(dname):
2471 try:
2468 try:
2472 with open(fname) as thefile:
2469 with open(fname) as thefile:
2473 # self.run_cell currently captures all exceptions
2470 # self.run_cell currently captures all exceptions
2474 # raised in user code. It would be nice if there were
2471 # raised in user code. It would be nice if there were
2475 # versions of runlines, execfile that did raise, so
2472 # versions of runlines, execfile that did raise, so
2476 # we could catch the errors.
2473 # we could catch the errors.
2477 self.run_cell(thefile.read(), store_history=False)
2474 self.run_cell(thefile.read(), store_history=False)
2478 except:
2475 except:
2479 self.showtraceback()
2476 self.showtraceback()
2480 warn('Unknown failure executing file: <%s>' % fname)
2477 warn('Unknown failure executing file: <%s>' % fname)
2481
2478
2482 def safe_run_module(self, mod_name, where):
2479 def safe_run_module(self, mod_name, where):
2483 """A safe version of runpy.run_module().
2480 """A safe version of runpy.run_module().
2484
2481
2485 This version will never throw an exception, but instead print
2482 This version will never throw an exception, but instead print
2486 helpful error messages to the screen.
2483 helpful error messages to the screen.
2487
2484
2488 Parameters
2485 Parameters
2489 ----------
2486 ----------
2490 mod_name : string
2487 mod_name : string
2491 The name of the module to be executed.
2488 The name of the module to be executed.
2492 where : dict
2489 where : dict
2493 The globals namespace.
2490 The globals namespace.
2494 """
2491 """
2495 try:
2492 try:
2496 where.update(
2493 where.update(
2497 runpy.run_module(str(mod_name), run_name="__main__",
2494 runpy.run_module(str(mod_name), run_name="__main__",
2498 alter_sys=True)
2495 alter_sys=True)
2499 )
2496 )
2500 except:
2497 except:
2501 self.showtraceback()
2498 self.showtraceback()
2502 warn('Unknown failure executing module: <%s>' % mod_name)
2499 warn('Unknown failure executing module: <%s>' % mod_name)
2503
2500
2504 def _run_cached_cell_magic(self, magic_name, line):
2501 def _run_cached_cell_magic(self, magic_name, line):
2505 """Special method to call a cell magic with the data stored in self.
2502 """Special method to call a cell magic with the data stored in self.
2506 """
2503 """
2507 cell = self._current_cell_magic_body
2504 cell = self._current_cell_magic_body
2508 self._current_cell_magic_body = None
2505 self._current_cell_magic_body = None
2509 return self.run_cell_magic(magic_name, line, cell)
2506 return self.run_cell_magic(magic_name, line, cell)
2510
2507
2511 def run_cell(self, raw_cell, store_history=False, silent=False):
2508 def run_cell(self, raw_cell, store_history=False, silent=False):
2512 """Run a complete IPython cell.
2509 """Run a complete IPython cell.
2513
2510
2514 Parameters
2511 Parameters
2515 ----------
2512 ----------
2516 raw_cell : str
2513 raw_cell : str
2517 The code (including IPython code such as %magic functions) to run.
2514 The code (including IPython code such as %magic functions) to run.
2518 store_history : bool
2515 store_history : bool
2519 If True, the raw and translated cell will be stored in IPython's
2516 If True, the raw and translated cell will be stored in IPython's
2520 history. For user code calling back into IPython's machinery, this
2517 history. For user code calling back into IPython's machinery, this
2521 should be set to False.
2518 should be set to False.
2522 silent : bool
2519 silent : bool
2523 If True, avoid side-effets, such as implicit displayhooks, history,
2520 If True, avoid side-effets, such as implicit displayhooks, history,
2524 and logging. silent=True forces store_history=False.
2521 and logging. silent=True forces store_history=False.
2525 """
2522 """
2526 if (not raw_cell) or raw_cell.isspace():
2523 if (not raw_cell) or raw_cell.isspace():
2527 return
2524 return
2528
2525
2529 if silent:
2526 if silent:
2530 store_history = False
2527 store_history = False
2531
2528
2532 self.input_splitter.push(raw_cell)
2529 self.input_splitter.push(raw_cell)
2533
2530
2534 # Check for cell magics, which leave state behind. This interface is
2531 # Check for cell magics, which leave state behind. This interface is
2535 # ugly, we need to do something cleaner later... Now the logic is
2532 # ugly, we need to do something cleaner later... Now the logic is
2536 # simply that the input_splitter remembers if there was a cell magic,
2533 # simply that the input_splitter remembers if there was a cell magic,
2537 # and in that case we grab the cell body.
2534 # and in that case we grab the cell body.
2538 if self.input_splitter.cell_magic_parts:
2535 if self.input_splitter.cell_magic_parts:
2539 self._current_cell_magic_body = \
2536 self._current_cell_magic_body = \
2540 ''.join(self.input_splitter.cell_magic_parts)
2537 ''.join(self.input_splitter.cell_magic_parts)
2541 cell = self.input_splitter.source_reset()
2538 cell = self.input_splitter.source_reset()
2542
2539
2543 with self.builtin_trap:
2540 with self.builtin_trap:
2544 prefilter_failed = False
2541 prefilter_failed = False
2545 if len(cell.splitlines()) == 1:
2542 if len(cell.splitlines()) == 1:
2546 try:
2543 try:
2547 # use prefilter_lines to handle trailing newlines
2544 # use prefilter_lines to handle trailing newlines
2548 # restore trailing newline for ast.parse
2545 # restore trailing newline for ast.parse
2549 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
2546 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
2550 except AliasError as e:
2547 except AliasError as e:
2551 error(e)
2548 error(e)
2552 prefilter_failed = True
2549 prefilter_failed = True
2553 except Exception:
2550 except Exception:
2554 # don't allow prefilter errors to crash IPython
2551 # don't allow prefilter errors to crash IPython
2555 self.showtraceback()
2552 self.showtraceback()
2556 prefilter_failed = True
2553 prefilter_failed = True
2557
2554
2558 # Store raw and processed history
2555 # Store raw and processed history
2559 if store_history:
2556 if store_history:
2560 self.history_manager.store_inputs(self.execution_count,
2557 self.history_manager.store_inputs(self.execution_count,
2561 cell, raw_cell)
2558 cell, raw_cell)
2562 if not silent:
2559 if not silent:
2563 self.logger.log(cell, raw_cell)
2560 self.logger.log(cell, raw_cell)
2564
2561
2565 if not prefilter_failed:
2562 if not prefilter_failed:
2566 # don't run if prefilter failed
2563 # don't run if prefilter failed
2567 cell_name = self.compile.cache(cell, self.execution_count)
2564 cell_name = self.compile.cache(cell, self.execution_count)
2568
2565
2569 with self.display_trap:
2566 with self.display_trap:
2570 try:
2567 try:
2571 code_ast = self.compile.ast_parse(cell,
2568 code_ast = self.compile.ast_parse(cell,
2572 filename=cell_name)
2569 filename=cell_name)
2573 except IndentationError:
2570 except IndentationError:
2574 self.showindentationerror()
2571 self.showindentationerror()
2575 if store_history:
2572 if store_history:
2576 self.execution_count += 1
2573 self.execution_count += 1
2577 return None
2574 return None
2578 except (OverflowError, SyntaxError, ValueError, TypeError,
2575 except (OverflowError, SyntaxError, ValueError, TypeError,
2579 MemoryError):
2576 MemoryError):
2580 self.showsyntaxerror()
2577 self.showsyntaxerror()
2581 if store_history:
2578 if store_history:
2582 self.execution_count += 1
2579 self.execution_count += 1
2583 return None
2580 return None
2584
2581
2585 interactivity = "none" if silent else self.ast_node_interactivity
2582 interactivity = "none" if silent else self.ast_node_interactivity
2586 self.run_ast_nodes(code_ast.body, cell_name,
2583 self.run_ast_nodes(code_ast.body, cell_name,
2587 interactivity=interactivity)
2584 interactivity=interactivity)
2588
2585
2589 # Execute any registered post-execution functions.
2586 # Execute any registered post-execution functions.
2590 # unless we are silent
2587 # unless we are silent
2591 post_exec = [] if silent else self._post_execute.iteritems()
2588 post_exec = [] if silent else self._post_execute.iteritems()
2592
2589
2593 for func, status in post_exec:
2590 for func, status in post_exec:
2594 if self.disable_failing_post_execute and not status:
2591 if self.disable_failing_post_execute and not status:
2595 continue
2592 continue
2596 try:
2593 try:
2597 func()
2594 func()
2598 except KeyboardInterrupt:
2595 except KeyboardInterrupt:
2599 print >> io.stderr, "\nKeyboardInterrupt"
2596 print >> io.stderr, "\nKeyboardInterrupt"
2600 except Exception:
2597 except Exception:
2601 # register as failing:
2598 # register as failing:
2602 self._post_execute[func] = False
2599 self._post_execute[func] = False
2603 self.showtraceback()
2600 self.showtraceback()
2604 print >> io.stderr, '\n'.join([
2601 print >> io.stderr, '\n'.join([
2605 "post-execution function %r produced an error." % func,
2602 "post-execution function %r produced an error." % func,
2606 "If this problem persists, you can disable failing post-exec functions with:",
2603 "If this problem persists, you can disable failing post-exec functions with:",
2607 "",
2604 "",
2608 " get_ipython().disable_failing_post_execute = True"
2605 " get_ipython().disable_failing_post_execute = True"
2609 ])
2606 ])
2610
2607
2611 if store_history:
2608 if store_history:
2612 # Write output to the database. Does nothing unless
2609 # Write output to the database. Does nothing unless
2613 # history output logging is enabled.
2610 # history output logging is enabled.
2614 self.history_manager.store_output(self.execution_count)
2611 self.history_manager.store_output(self.execution_count)
2615 # Each cell is a *single* input, regardless of how many lines it has
2612 # Each cell is a *single* input, regardless of how many lines it has
2616 self.execution_count += 1
2613 self.execution_count += 1
2617
2614
2618 def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr'):
2615 def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr'):
2619 """Run a sequence of AST nodes. The execution mode depends on the
2616 """Run a sequence of AST nodes. The execution mode depends on the
2620 interactivity parameter.
2617 interactivity parameter.
2621
2618
2622 Parameters
2619 Parameters
2623 ----------
2620 ----------
2624 nodelist : list
2621 nodelist : list
2625 A sequence of AST nodes to run.
2622 A sequence of AST nodes to run.
2626 cell_name : str
2623 cell_name : str
2627 Will be passed to the compiler as the filename of the cell. Typically
2624 Will be passed to the compiler as the filename of the cell. Typically
2628 the value returned by ip.compile.cache(cell).
2625 the value returned by ip.compile.cache(cell).
2629 interactivity : str
2626 interactivity : str
2630 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
2627 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
2631 run interactively (displaying output from expressions). 'last_expr'
2628 run interactively (displaying output from expressions). 'last_expr'
2632 will run the last node interactively only if it is an expression (i.e.
2629 will run the last node interactively only if it is an expression (i.e.
2633 expressions in loops or other blocks are not displayed. Other values
2630 expressions in loops or other blocks are not displayed. Other values
2634 for this parameter will raise a ValueError.
2631 for this parameter will raise a ValueError.
2635 """
2632 """
2636 if not nodelist:
2633 if not nodelist:
2637 return
2634 return
2638
2635
2639 if interactivity == 'last_expr':
2636 if interactivity == 'last_expr':
2640 if isinstance(nodelist[-1], ast.Expr):
2637 if isinstance(nodelist[-1], ast.Expr):
2641 interactivity = "last"
2638 interactivity = "last"
2642 else:
2639 else:
2643 interactivity = "none"
2640 interactivity = "none"
2644
2641
2645 if interactivity == 'none':
2642 if interactivity == 'none':
2646 to_run_exec, to_run_interactive = nodelist, []
2643 to_run_exec, to_run_interactive = nodelist, []
2647 elif interactivity == 'last':
2644 elif interactivity == 'last':
2648 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
2645 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
2649 elif interactivity == 'all':
2646 elif interactivity == 'all':
2650 to_run_exec, to_run_interactive = [], nodelist
2647 to_run_exec, to_run_interactive = [], nodelist
2651 else:
2648 else:
2652 raise ValueError("Interactivity was %r" % interactivity)
2649 raise ValueError("Interactivity was %r" % interactivity)
2653
2650
2654 exec_count = self.execution_count
2651 exec_count = self.execution_count
2655
2652
2656 try:
2653 try:
2657 for i, node in enumerate(to_run_exec):
2654 for i, node in enumerate(to_run_exec):
2658 mod = ast.Module([node])
2655 mod = ast.Module([node])
2659 code = self.compile(mod, cell_name, "exec")
2656 code = self.compile(mod, cell_name, "exec")
2660 if self.run_code(code):
2657 if self.run_code(code):
2661 return True
2658 return True
2662
2659
2663 for i, node in enumerate(to_run_interactive):
2660 for i, node in enumerate(to_run_interactive):
2664 mod = ast.Interactive([node])
2661 mod = ast.Interactive([node])
2665 code = self.compile(mod, cell_name, "single")
2662 code = self.compile(mod, cell_name, "single")
2666 if self.run_code(code):
2663 if self.run_code(code):
2667 return True
2664 return True
2668
2665
2669 # Flush softspace
2666 # Flush softspace
2670 if softspace(sys.stdout, 0):
2667 if softspace(sys.stdout, 0):
2671 print
2668 print
2672
2669
2673 except:
2670 except:
2674 # It's possible to have exceptions raised here, typically by
2671 # It's possible to have exceptions raised here, typically by
2675 # compilation of odd code (such as a naked 'return' outside a
2672 # compilation of odd code (such as a naked 'return' outside a
2676 # function) that did parse but isn't valid. Typically the exception
2673 # function) that did parse but isn't valid. Typically the exception
2677 # is a SyntaxError, but it's safest just to catch anything and show
2674 # is a SyntaxError, but it's safest just to catch anything and show
2678 # the user a traceback.
2675 # the user a traceback.
2679
2676
2680 # We do only one try/except outside the loop to minimize the impact
2677 # We do only one try/except outside the loop to minimize the impact
2681 # on runtime, and also because if any node in the node list is
2678 # on runtime, and also because if any node in the node list is
2682 # broken, we should stop execution completely.
2679 # broken, we should stop execution completely.
2683 self.showtraceback()
2680 self.showtraceback()
2684
2681
2685 return False
2682 return False
2686
2683
2687 def run_code(self, code_obj):
2684 def run_code(self, code_obj):
2688 """Execute a code object.
2685 """Execute a code object.
2689
2686
2690 When an exception occurs, self.showtraceback() is called to display a
2687 When an exception occurs, self.showtraceback() is called to display a
2691 traceback.
2688 traceback.
2692
2689
2693 Parameters
2690 Parameters
2694 ----------
2691 ----------
2695 code_obj : code object
2692 code_obj : code object
2696 A compiled code object, to be executed
2693 A compiled code object, to be executed
2697
2694
2698 Returns
2695 Returns
2699 -------
2696 -------
2700 False : successful execution.
2697 False : successful execution.
2701 True : an error occurred.
2698 True : an error occurred.
2702 """
2699 """
2703
2700
2704 # Set our own excepthook in case the user code tries to call it
2701 # Set our own excepthook in case the user code tries to call it
2705 # directly, so that the IPython crash handler doesn't get triggered
2702 # directly, so that the IPython crash handler doesn't get triggered
2706 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2703 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2707
2704
2708 # we save the original sys.excepthook in the instance, in case config
2705 # we save the original sys.excepthook in the instance, in case config
2709 # code (such as magics) needs access to it.
2706 # code (such as magics) needs access to it.
2710 self.sys_excepthook = old_excepthook
2707 self.sys_excepthook = old_excepthook
2711 outflag = 1 # happens in more places, so it's easier as default
2708 outflag = 1 # happens in more places, so it's easier as default
2712 try:
2709 try:
2713 try:
2710 try:
2714 self.hooks.pre_run_code_hook()
2711 self.hooks.pre_run_code_hook()
2715 #rprint('Running code', repr(code_obj)) # dbg
2712 #rprint('Running code', repr(code_obj)) # dbg
2716 exec code_obj in self.user_global_ns, self.user_ns
2713 exec code_obj in self.user_global_ns, self.user_ns
2717 finally:
2714 finally:
2718 # Reset our crash handler in place
2715 # Reset our crash handler in place
2719 sys.excepthook = old_excepthook
2716 sys.excepthook = old_excepthook
2720 except SystemExit:
2717 except SystemExit:
2721 self.showtraceback(exception_only=True)
2718 self.showtraceback(exception_only=True)
2722 warn("To exit: use 'exit', 'quit', or Ctrl-D.", level=1)
2719 warn("To exit: use 'exit', 'quit', or Ctrl-D.", level=1)
2723 except self.custom_exceptions:
2720 except self.custom_exceptions:
2724 etype,value,tb = sys.exc_info()
2721 etype,value,tb = sys.exc_info()
2725 self.CustomTB(etype,value,tb)
2722 self.CustomTB(etype,value,tb)
2726 except:
2723 except:
2727 self.showtraceback()
2724 self.showtraceback()
2728 else:
2725 else:
2729 outflag = 0
2726 outflag = 0
2730 return outflag
2727 return outflag
2731
2728
2732 # For backwards compatibility
2729 # For backwards compatibility
2733 runcode = run_code
2730 runcode = run_code
2734
2731
2735 #-------------------------------------------------------------------------
2732 #-------------------------------------------------------------------------
2736 # Things related to GUI support and pylab
2733 # Things related to GUI support and pylab
2737 #-------------------------------------------------------------------------
2734 #-------------------------------------------------------------------------
2738
2735
2739 def enable_gui(self, gui=None):
2736 def enable_gui(self, gui=None):
2740 raise NotImplementedError('Implement enable_gui in a subclass')
2737 raise NotImplementedError('Implement enable_gui in a subclass')
2741
2738
2742 def enable_pylab(self, gui=None, import_all=True):
2739 def enable_pylab(self, gui=None, import_all=True):
2743 """Activate pylab support at runtime.
2740 """Activate pylab support at runtime.
2744
2741
2745 This turns on support for matplotlib, preloads into the interactive
2742 This turns on support for matplotlib, preloads into the interactive
2746 namespace all of numpy and pylab, and configures IPython to correctly
2743 namespace all of numpy and pylab, and configures IPython to correctly
2747 interact with the GUI event loop. The GUI backend to be used can be
2744 interact with the GUI event loop. The GUI backend to be used can be
2748 optionally selected with the optional :param:`gui` argument.
2745 optionally selected with the optional :param:`gui` argument.
2749
2746
2750 Parameters
2747 Parameters
2751 ----------
2748 ----------
2752 gui : optional, string
2749 gui : optional, string
2753
2750
2754 If given, dictates the choice of matplotlib GUI backend to use
2751 If given, dictates the choice of matplotlib GUI backend to use
2755 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
2752 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
2756 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
2753 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
2757 matplotlib (as dictated by the matplotlib build-time options plus the
2754 matplotlib (as dictated by the matplotlib build-time options plus the
2758 user's matplotlibrc configuration file). Note that not all backends
2755 user's matplotlibrc configuration file). Note that not all backends
2759 make sense in all contexts, for example a terminal ipython can't
2756 make sense in all contexts, for example a terminal ipython can't
2760 display figures inline.
2757 display figures inline.
2761 """
2758 """
2762 from IPython.core.pylabtools import mpl_runner
2759 from IPython.core.pylabtools import mpl_runner
2763 # We want to prevent the loading of pylab to pollute the user's
2760 # We want to prevent the loading of pylab to pollute the user's
2764 # namespace as shown by the %who* magics, so we execute the activation
2761 # namespace as shown by the %who* magics, so we execute the activation
2765 # code in an empty namespace, and we update *both* user_ns and
2762 # code in an empty namespace, and we update *both* user_ns and
2766 # user_ns_hidden with this information.
2763 # user_ns_hidden with this information.
2767 ns = {}
2764 ns = {}
2768 try:
2765 try:
2769 gui = pylab_activate(ns, gui, import_all, self)
2766 gui = pylab_activate(ns, gui, import_all, self)
2770 except KeyError:
2767 except KeyError:
2771 error("Backend %r not supported" % gui)
2768 error("Backend %r not supported" % gui)
2772 return
2769 return
2773 self.user_ns.update(ns)
2770 self.user_ns.update(ns)
2774 self.user_ns_hidden.update(ns)
2771 self.user_ns_hidden.update(ns)
2775 # Now we must activate the gui pylab wants to use, and fix %run to take
2772 # Now we must activate the gui pylab wants to use, and fix %run to take
2776 # plot updates into account
2773 # plot updates into account
2777 self.enable_gui(gui)
2774 self.enable_gui(gui)
2778 self.magics_manager.registry['ExecutionMagics'].default_runner = \
2775 self.magics_manager.registry['ExecutionMagics'].default_runner = \
2779 mpl_runner(self.safe_execfile)
2776 mpl_runner(self.safe_execfile)
2780
2777
2781 #-------------------------------------------------------------------------
2778 #-------------------------------------------------------------------------
2782 # Utilities
2779 # Utilities
2783 #-------------------------------------------------------------------------
2780 #-------------------------------------------------------------------------
2784
2781
2785 def var_expand(self, cmd, depth=0, formatter=DollarFormatter()):
2782 def var_expand(self, cmd, depth=0, formatter=DollarFormatter()):
2786 """Expand python variables in a string.
2783 """Expand python variables in a string.
2787
2784
2788 The depth argument indicates how many frames above the caller should
2785 The depth argument indicates how many frames above the caller should
2789 be walked to look for the local namespace where to expand variables.
2786 be walked to look for the local namespace where to expand variables.
2790
2787
2791 The global namespace for expansion is always the user's interactive
2788 The global namespace for expansion is always the user's interactive
2792 namespace.
2789 namespace.
2793 """
2790 """
2794 ns = self.user_ns.copy()
2791 ns = self.user_ns.copy()
2795 ns.update(sys._getframe(depth+1).f_locals)
2792 ns.update(sys._getframe(depth+1).f_locals)
2796 ns.pop('self', None)
2793 ns.pop('self', None)
2797 try:
2794 try:
2798 cmd = formatter.format(cmd, **ns)
2795 cmd = formatter.format(cmd, **ns)
2799 except Exception:
2796 except Exception:
2800 # if formatter couldn't format, just let it go untransformed
2797 # if formatter couldn't format, just let it go untransformed
2801 pass
2798 pass
2802 return cmd
2799 return cmd
2803
2800
2804 def mktempfile(self, data=None, prefix='ipython_edit_'):
2801 def mktempfile(self, data=None, prefix='ipython_edit_'):
2805 """Make a new tempfile and return its filename.
2802 """Make a new tempfile and return its filename.
2806
2803
2807 This makes a call to tempfile.mktemp, but it registers the created
2804 This makes a call to tempfile.mktemp, but it registers the created
2808 filename internally so ipython cleans it up at exit time.
2805 filename internally so ipython cleans it up at exit time.
2809
2806
2810 Optional inputs:
2807 Optional inputs:
2811
2808
2812 - data(None): if data is given, it gets written out to the temp file
2809 - data(None): if data is given, it gets written out to the temp file
2813 immediately, and the file is closed again."""
2810 immediately, and the file is closed again."""
2814
2811
2815 filename = tempfile.mktemp('.py', prefix)
2812 filename = tempfile.mktemp('.py', prefix)
2816 self.tempfiles.append(filename)
2813 self.tempfiles.append(filename)
2817
2814
2818 if data:
2815 if data:
2819 tmp_file = open(filename,'w')
2816 tmp_file = open(filename,'w')
2820 tmp_file.write(data)
2817 tmp_file.write(data)
2821 tmp_file.close()
2818 tmp_file.close()
2822 return filename
2819 return filename
2823
2820
2824 # TODO: This should be removed when Term is refactored.
2821 # TODO: This should be removed when Term is refactored.
2825 def write(self,data):
2822 def write(self,data):
2826 """Write a string to the default output"""
2823 """Write a string to the default output"""
2827 io.stdout.write(data)
2824 io.stdout.write(data)
2828
2825
2829 # TODO: This should be removed when Term is refactored.
2826 # TODO: This should be removed when Term is refactored.
2830 def write_err(self,data):
2827 def write_err(self,data):
2831 """Write a string to the default error output"""
2828 """Write a string to the default error output"""
2832 io.stderr.write(data)
2829 io.stderr.write(data)
2833
2830
2834 def ask_yes_no(self, prompt, default=None):
2831 def ask_yes_no(self, prompt, default=None):
2835 if self.quiet:
2832 if self.quiet:
2836 return True
2833 return True
2837 return ask_yes_no(prompt,default)
2834 return ask_yes_no(prompt,default)
2838
2835
2839 def show_usage(self):
2836 def show_usage(self):
2840 """Show a usage message"""
2837 """Show a usage message"""
2841 page.page(IPython.core.usage.interactive_usage)
2838 page.page(IPython.core.usage.interactive_usage)
2842
2839
2843 def extract_input_lines(self, range_str, raw=False):
2840 def extract_input_lines(self, range_str, raw=False):
2844 """Return as a string a set of input history slices.
2841 """Return as a string a set of input history slices.
2845
2842
2846 Parameters
2843 Parameters
2847 ----------
2844 ----------
2848 range_str : string
2845 range_str : string
2849 The set of slices is given as a string, like "~5/6-~4/2 4:8 9",
2846 The set of slices is given as a string, like "~5/6-~4/2 4:8 9",
2850 since this function is for use by magic functions which get their
2847 since this function is for use by magic functions which get their
2851 arguments as strings. The number before the / is the session
2848 arguments as strings. The number before the / is the session
2852 number: ~n goes n back from the current session.
2849 number: ~n goes n back from the current session.
2853
2850
2854 Optional Parameters:
2851 Optional Parameters:
2855 - raw(False): by default, the processed input is used. If this is
2852 - raw(False): by default, the processed input is used. If this is
2856 true, the raw input history is used instead.
2853 true, the raw input history is used instead.
2857
2854
2858 Note that slices can be called with two notations:
2855 Note that slices can be called with two notations:
2859
2856
2860 N:M -> standard python form, means including items N...(M-1).
2857 N:M -> standard python form, means including items N...(M-1).
2861
2858
2862 N-M -> include items N..M (closed endpoint)."""
2859 N-M -> include items N..M (closed endpoint)."""
2863 lines = self.history_manager.get_range_by_str(range_str, raw=raw)
2860 lines = self.history_manager.get_range_by_str(range_str, raw=raw)
2864 return "\n".join(x for _, _, x in lines)
2861 return "\n".join(x for _, _, x in lines)
2865
2862
2866 def find_user_code(self, target, raw=True, py_only=False):
2863 def find_user_code(self, target, raw=True, py_only=False):
2867 """Get a code string from history, file, url, or a string or macro.
2864 """Get a code string from history, file, url, or a string or macro.
2868
2865
2869 This is mainly used by magic functions.
2866 This is mainly used by magic functions.
2870
2867
2871 Parameters
2868 Parameters
2872 ----------
2869 ----------
2873
2870
2874 target : str
2871 target : str
2875
2872
2876 A string specifying code to retrieve. This will be tried respectively
2873 A string specifying code to retrieve. This will be tried respectively
2877 as: ranges of input history (see %history for syntax), url,
2874 as: ranges of input history (see %history for syntax), url,
2878 correspnding .py file, filename, or an expression evaluating to a
2875 correspnding .py file, filename, or an expression evaluating to a
2879 string or Macro in the user namespace.
2876 string or Macro in the user namespace.
2880
2877
2881 raw : bool
2878 raw : bool
2882 If true (default), retrieve raw history. Has no effect on the other
2879 If true (default), retrieve raw history. Has no effect on the other
2883 retrieval mechanisms.
2880 retrieval mechanisms.
2884
2881
2885 py_only : bool (default False)
2882 py_only : bool (default False)
2886 Only try to fetch python code, do not try alternative methods to decode file
2883 Only try to fetch python code, do not try alternative methods to decode file
2887 if unicode fails.
2884 if unicode fails.
2888
2885
2889 Returns
2886 Returns
2890 -------
2887 -------
2891 A string of code.
2888 A string of code.
2892
2889
2893 ValueError is raised if nothing is found, and TypeError if it evaluates
2890 ValueError is raised if nothing is found, and TypeError if it evaluates
2894 to an object of another type. In each case, .args[0] is a printable
2891 to an object of another type. In each case, .args[0] is a printable
2895 message.
2892 message.
2896 """
2893 """
2897 code = self.extract_input_lines(target, raw=raw) # Grab history
2894 code = self.extract_input_lines(target, raw=raw) # Grab history
2898 if code:
2895 if code:
2899 return code
2896 return code
2900 utarget = unquote_filename(target)
2897 utarget = unquote_filename(target)
2901 try:
2898 try:
2902 if utarget.startswith(('http://', 'https://')):
2899 if utarget.startswith(('http://', 'https://')):
2903 return openpy.read_py_url(utarget, skip_encoding_cookie=True)
2900 return openpy.read_py_url(utarget, skip_encoding_cookie=True)
2904 except UnicodeDecodeError:
2901 except UnicodeDecodeError:
2905 if not py_only :
2902 if not py_only :
2906 response = urllib.urlopen(target)
2903 response = urllib.urlopen(target)
2907 return response.read().decode('latin1')
2904 return response.read().decode('latin1')
2908 raise ValueError(("'%s' seem to be unreadable.") % utarget)
2905 raise ValueError(("'%s' seem to be unreadable.") % utarget)
2909
2906
2910 potential_target = [target]
2907 potential_target = [target]
2911 try :
2908 try :
2912 potential_target.insert(0,get_py_filename(target))
2909 potential_target.insert(0,get_py_filename(target))
2913 except IOError:
2910 except IOError:
2914 pass
2911 pass
2915
2912
2916 for tgt in potential_target :
2913 for tgt in potential_target :
2917 if os.path.isfile(tgt): # Read file
2914 if os.path.isfile(tgt): # Read file
2918 try :
2915 try :
2919 return openpy.read_py_file(tgt, skip_encoding_cookie=True)
2916 return openpy.read_py_file(tgt, skip_encoding_cookie=True)
2920 except UnicodeDecodeError :
2917 except UnicodeDecodeError :
2921 if not py_only :
2918 if not py_only :
2922 with io_open(tgt,'r', encoding='latin1') as f :
2919 with io_open(tgt,'r', encoding='latin1') as f :
2923 return f.read()
2920 return f.read()
2924 raise ValueError(("'%s' seem to be unreadable.") % target)
2921 raise ValueError(("'%s' seem to be unreadable.") % target)
2925
2922
2926 try: # User namespace
2923 try: # User namespace
2927 codeobj = eval(target, self.user_ns)
2924 codeobj = eval(target, self.user_ns)
2928 except Exception:
2925 except Exception:
2929 raise ValueError(("'%s' was not found in history, as a file, url, "
2926 raise ValueError(("'%s' was not found in history, as a file, url, "
2930 "nor in the user namespace.") % target)
2927 "nor in the user namespace.") % target)
2931 if isinstance(codeobj, basestring):
2928 if isinstance(codeobj, basestring):
2932 return codeobj
2929 return codeobj
2933 elif isinstance(codeobj, Macro):
2930 elif isinstance(codeobj, Macro):
2934 return codeobj.value
2931 return codeobj.value
2935
2932
2936 raise TypeError("%s is neither a string nor a macro." % target,
2933 raise TypeError("%s is neither a string nor a macro." % target,
2937 codeobj)
2934 codeobj)
2938
2935
2939 #-------------------------------------------------------------------------
2936 #-------------------------------------------------------------------------
2940 # Things related to IPython exiting
2937 # Things related to IPython exiting
2941 #-------------------------------------------------------------------------
2938 #-------------------------------------------------------------------------
2942 def atexit_operations(self):
2939 def atexit_operations(self):
2943 """This will be executed at the time of exit.
2940 """This will be executed at the time of exit.
2944
2941
2945 Cleanup operations and saving of persistent data that is done
2942 Cleanup operations and saving of persistent data that is done
2946 unconditionally by IPython should be performed here.
2943 unconditionally by IPython should be performed here.
2947
2944
2948 For things that may depend on startup flags or platform specifics (such
2945 For things that may depend on startup flags or platform specifics (such
2949 as having readline or not), register a separate atexit function in the
2946 as having readline or not), register a separate atexit function in the
2950 code that has the appropriate information, rather than trying to
2947 code that has the appropriate information, rather than trying to
2951 clutter
2948 clutter
2952 """
2949 """
2953 # Close the history session (this stores the end time and line count)
2950 # Close the history session (this stores the end time and line count)
2954 # this must be *before* the tempfile cleanup, in case of temporary
2951 # this must be *before* the tempfile cleanup, in case of temporary
2955 # history db
2952 # history db
2956 self.history_manager.end_session()
2953 self.history_manager.end_session()
2957
2954
2958 # Cleanup all tempfiles left around
2955 # Cleanup all tempfiles left around
2959 for tfile in self.tempfiles:
2956 for tfile in self.tempfiles:
2960 try:
2957 try:
2961 os.unlink(tfile)
2958 os.unlink(tfile)
2962 except OSError:
2959 except OSError:
2963 pass
2960 pass
2964
2961
2965 # Clear all user namespaces to release all references cleanly.
2962 # Clear all user namespaces to release all references cleanly.
2966 self.reset(new_session=False)
2963 self.reset(new_session=False)
2967
2964
2968 # Run user hooks
2965 # Run user hooks
2969 self.hooks.shutdown_hook()
2966 self.hooks.shutdown_hook()
2970
2967
2971 def cleanup(self):
2968 def cleanup(self):
2972 self.restore_sys_module_state()
2969 self.restore_sys_module_state()
2973
2970
2974
2971
2975 class InteractiveShellABC(object):
2972 class InteractiveShellABC(object):
2976 """An abstract base class for InteractiveShell."""
2973 """An abstract base class for InteractiveShell."""
2977 __metaclass__ = abc.ABCMeta
2974 __metaclass__ = abc.ABCMeta
2978
2975
2979 InteractiveShellABC.register(InteractiveShell)
2976 InteractiveShellABC.register(InteractiveShell)
General Comments 0
You need to be logged in to leave comments. Login now