##// END OF EJS Templates
Correct stack depth for !system calls...
Thomas Kluyver -
Show More
@@ -1,2976 +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 exception_only:
1706 if exception_only:
1707 stb = ['An exception has occurred, use %tb to see '
1707 stb = ['An exception has occurred, use %tb to see '
1708 'the full traceback.\n']
1708 'the full traceback.\n']
1709 stb.extend(self.InteractiveTB.get_exception_only(etype,
1709 stb.extend(self.InteractiveTB.get_exception_only(etype,
1710 value))
1710 value))
1711 else:
1711 else:
1712 stb = self.InteractiveTB.structured_traceback(etype,
1712 stb = self.InteractiveTB.structured_traceback(etype,
1713 value, tb, tb_offset=tb_offset)
1713 value, tb, tb_offset=tb_offset)
1714
1714
1715 self._showtraceback(etype, value, stb)
1715 self._showtraceback(etype, value, stb)
1716 if self.call_pdb:
1716 if self.call_pdb:
1717 # drop into debugger
1717 # drop into debugger
1718 self.debugger(force=True)
1718 self.debugger(force=True)
1719 return
1719 return
1720
1720
1721 # Actually show the traceback
1721 # Actually show the traceback
1722 self._showtraceback(etype, value, stb)
1722 self._showtraceback(etype, value, stb)
1723
1723
1724 except KeyboardInterrupt:
1724 except KeyboardInterrupt:
1725 self.write_err("\nKeyboardInterrupt\n")
1725 self.write_err("\nKeyboardInterrupt\n")
1726
1726
1727 def _showtraceback(self, etype, evalue, stb):
1727 def _showtraceback(self, etype, evalue, stb):
1728 """Actually show a traceback.
1728 """Actually show a traceback.
1729
1729
1730 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
1731 place, like a side channel.
1731 place, like a side channel.
1732 """
1732 """
1733 print >> io.stdout, self.InteractiveTB.stb2text(stb)
1733 print >> io.stdout, self.InteractiveTB.stb2text(stb)
1734
1734
1735 def showsyntaxerror(self, filename=None):
1735 def showsyntaxerror(self, filename=None):
1736 """Display the syntax error that just occurred.
1736 """Display the syntax error that just occurred.
1737
1737
1738 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.
1739
1739
1740 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
1741 of what was there before (because Python's parser always uses
1741 of what was there before (because Python's parser always uses
1742 "<string>" when reading from a string).
1742 "<string>" when reading from a string).
1743 """
1743 """
1744 etype, value, last_traceback = self._get_exc_info()
1744 etype, value, last_traceback = self._get_exc_info()
1745
1745
1746 if filename and etype is SyntaxError:
1746 if filename and etype is SyntaxError:
1747 try:
1747 try:
1748 value.filename = filename
1748 value.filename = filename
1749 except:
1749 except:
1750 # Not the format we expect; leave it alone
1750 # Not the format we expect; leave it alone
1751 pass
1751 pass
1752
1752
1753 stb = self.SyntaxTB.structured_traceback(etype, value, [])
1753 stb = self.SyntaxTB.structured_traceback(etype, value, [])
1754 self._showtraceback(etype, value, stb)
1754 self._showtraceback(etype, value, stb)
1755
1755
1756 # This is overridden in TerminalInteractiveShell to show a message about
1756 # This is overridden in TerminalInteractiveShell to show a message about
1757 # the %paste magic.
1757 # the %paste magic.
1758 def showindentationerror(self):
1758 def showindentationerror(self):
1759 """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
1760 at the prompt.
1760 at the prompt.
1761
1761
1762 This is overridden in TerminalInteractiveShell to show a message about
1762 This is overridden in TerminalInteractiveShell to show a message about
1763 the %paste magic."""
1763 the %paste magic."""
1764 self.showsyntaxerror()
1764 self.showsyntaxerror()
1765
1765
1766 #-------------------------------------------------------------------------
1766 #-------------------------------------------------------------------------
1767 # Things related to readline
1767 # Things related to readline
1768 #-------------------------------------------------------------------------
1768 #-------------------------------------------------------------------------
1769
1769
1770 def init_readline(self):
1770 def init_readline(self):
1771 """Command history completion/saving/reloading."""
1771 """Command history completion/saving/reloading."""
1772
1772
1773 if self.readline_use:
1773 if self.readline_use:
1774 import IPython.utils.rlineimpl as readline
1774 import IPython.utils.rlineimpl as readline
1775
1775
1776 self.rl_next_input = None
1776 self.rl_next_input = None
1777 self.rl_do_indent = False
1777 self.rl_do_indent = False
1778
1778
1779 if not self.readline_use or not readline.have_readline:
1779 if not self.readline_use or not readline.have_readline:
1780 self.has_readline = False
1780 self.has_readline = False
1781 self.readline = None
1781 self.readline = None
1782 # 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
1783 self.readline_no_record = no_op_context
1783 self.readline_no_record = no_op_context
1784 self.set_readline_completer = no_op
1784 self.set_readline_completer = no_op
1785 self.set_custom_completer = no_op
1785 self.set_custom_completer = no_op
1786 self.set_completer_frame = no_op
1786 self.set_completer_frame = no_op
1787 if self.readline_use:
1787 if self.readline_use:
1788 warn('Readline services not available or not loaded.')
1788 warn('Readline services not available or not loaded.')
1789 else:
1789 else:
1790 self.has_readline = True
1790 self.has_readline = True
1791 self.readline = readline
1791 self.readline = readline
1792 sys.modules['readline'] = readline
1792 sys.modules['readline'] = readline
1793
1793
1794 # Platform-specific configuration
1794 # Platform-specific configuration
1795 if os.name == 'nt':
1795 if os.name == 'nt':
1796 # FIXME - check with Frederick to see if we can harmonize
1796 # FIXME - check with Frederick to see if we can harmonize
1797 # naming conventions with pyreadline to avoid this
1797 # naming conventions with pyreadline to avoid this
1798 # platform-dependent check
1798 # platform-dependent check
1799 self.readline_startup_hook = readline.set_pre_input_hook
1799 self.readline_startup_hook = readline.set_pre_input_hook
1800 else:
1800 else:
1801 self.readline_startup_hook = readline.set_startup_hook
1801 self.readline_startup_hook = readline.set_startup_hook
1802
1802
1803 # Load user's initrc file (readline config)
1803 # Load user's initrc file (readline config)
1804 # Or if libedit is used, load editrc.
1804 # Or if libedit is used, load editrc.
1805 inputrc_name = os.environ.get('INPUTRC')
1805 inputrc_name = os.environ.get('INPUTRC')
1806 if inputrc_name is None:
1806 if inputrc_name is None:
1807 inputrc_name = '.inputrc'
1807 inputrc_name = '.inputrc'
1808 if readline.uses_libedit:
1808 if readline.uses_libedit:
1809 inputrc_name = '.editrc'
1809 inputrc_name = '.editrc'
1810 inputrc_name = os.path.join(self.home_dir, inputrc_name)
1810 inputrc_name = os.path.join(self.home_dir, inputrc_name)
1811 if os.path.isfile(inputrc_name):
1811 if os.path.isfile(inputrc_name):
1812 try:
1812 try:
1813 readline.read_init_file(inputrc_name)
1813 readline.read_init_file(inputrc_name)
1814 except:
1814 except:
1815 warn('Problems reading readline initialization file <%s>'
1815 warn('Problems reading readline initialization file <%s>'
1816 % inputrc_name)
1816 % inputrc_name)
1817
1817
1818 # Configure readline according to user's prefs
1818 # Configure readline according to user's prefs
1819 # 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
1820 # is being used (as on Leopard) the readline config is
1820 # is being used (as on Leopard) the readline config is
1821 # not run as the syntax for libedit is different.
1821 # not run as the syntax for libedit is different.
1822 if not readline.uses_libedit:
1822 if not readline.uses_libedit:
1823 for rlcommand in self.readline_parse_and_bind:
1823 for rlcommand in self.readline_parse_and_bind:
1824 #print "loading rl:",rlcommand # dbg
1824 #print "loading rl:",rlcommand # dbg
1825 readline.parse_and_bind(rlcommand)
1825 readline.parse_and_bind(rlcommand)
1826
1826
1827 # Remove some chars from the delimiters list. If we encounter
1827 # Remove some chars from the delimiters list. If we encounter
1828 # unicode chars, discard them.
1828 # unicode chars, discard them.
1829 delims = readline.get_completer_delims()
1829 delims = readline.get_completer_delims()
1830 if not py3compat.PY3:
1830 if not py3compat.PY3:
1831 delims = delims.encode("ascii", "ignore")
1831 delims = delims.encode("ascii", "ignore")
1832 for d in self.readline_remove_delims:
1832 for d in self.readline_remove_delims:
1833 delims = delims.replace(d, "")
1833 delims = delims.replace(d, "")
1834 delims = delims.replace(ESC_MAGIC, '')
1834 delims = delims.replace(ESC_MAGIC, '')
1835 readline.set_completer_delims(delims)
1835 readline.set_completer_delims(delims)
1836 # otherwise we end up with a monster history after a while:
1836 # otherwise we end up with a monster history after a while:
1837 readline.set_history_length(self.history_length)
1837 readline.set_history_length(self.history_length)
1838
1838
1839 self.refill_readline_hist()
1839 self.refill_readline_hist()
1840 self.readline_no_record = ReadlineNoRecord(self)
1840 self.readline_no_record = ReadlineNoRecord(self)
1841
1841
1842 # Configure auto-indent for all platforms
1842 # Configure auto-indent for all platforms
1843 self.set_autoindent(self.autoindent)
1843 self.set_autoindent(self.autoindent)
1844
1844
1845 def refill_readline_hist(self):
1845 def refill_readline_hist(self):
1846 # Load the last 1000 lines from history
1846 # Load the last 1000 lines from history
1847 self.readline.clear_history()
1847 self.readline.clear_history()
1848 stdin_encoding = sys.stdin.encoding or "utf-8"
1848 stdin_encoding = sys.stdin.encoding or "utf-8"
1849 last_cell = u""
1849 last_cell = u""
1850 for _, _, cell in self.history_manager.get_tail(1000,
1850 for _, _, cell in self.history_manager.get_tail(1000,
1851 include_latest=True):
1851 include_latest=True):
1852 # Ignore blank lines and consecutive duplicates
1852 # Ignore blank lines and consecutive duplicates
1853 cell = cell.rstrip()
1853 cell = cell.rstrip()
1854 if cell and (cell != last_cell):
1854 if cell and (cell != last_cell):
1855 if self.multiline_history:
1855 if self.multiline_history:
1856 self.readline.add_history(py3compat.unicode_to_str(cell,
1856 self.readline.add_history(py3compat.unicode_to_str(cell,
1857 stdin_encoding))
1857 stdin_encoding))
1858 else:
1858 else:
1859 for line in cell.splitlines():
1859 for line in cell.splitlines():
1860 self.readline.add_history(py3compat.unicode_to_str(line,
1860 self.readline.add_history(py3compat.unicode_to_str(line,
1861 stdin_encoding))
1861 stdin_encoding))
1862 last_cell = cell
1862 last_cell = cell
1863
1863
1864 def set_next_input(self, s):
1864 def set_next_input(self, s):
1865 """ Sets the 'default' input string for the next command line.
1865 """ Sets the 'default' input string for the next command line.
1866
1866
1867 Requires readline.
1867 Requires readline.
1868
1868
1869 Example:
1869 Example:
1870
1870
1871 [D:\ipython]|1> _ip.set_next_input("Hello Word")
1871 [D:\ipython]|1> _ip.set_next_input("Hello Word")
1872 [D:\ipython]|2> Hello Word_ # cursor is here
1872 [D:\ipython]|2> Hello Word_ # cursor is here
1873 """
1873 """
1874 self.rl_next_input = py3compat.cast_bytes_py2(s)
1874 self.rl_next_input = py3compat.cast_bytes_py2(s)
1875
1875
1876 # Maybe move this to the terminal subclass?
1876 # Maybe move this to the terminal subclass?
1877 def pre_readline(self):
1877 def pre_readline(self):
1878 """readline hook to be used at the start of each line.
1878 """readline hook to be used at the start of each line.
1879
1879
1880 Currently it handles auto-indent only."""
1880 Currently it handles auto-indent only."""
1881
1881
1882 if self.rl_do_indent:
1882 if self.rl_do_indent:
1883 self.readline.insert_text(self._indent_current_str())
1883 self.readline.insert_text(self._indent_current_str())
1884 if self.rl_next_input is not None:
1884 if self.rl_next_input is not None:
1885 self.readline.insert_text(self.rl_next_input)
1885 self.readline.insert_text(self.rl_next_input)
1886 self.rl_next_input = None
1886 self.rl_next_input = None
1887
1887
1888 def _indent_current_str(self):
1888 def _indent_current_str(self):
1889 """return the current level of indentation as a string"""
1889 """return the current level of indentation as a string"""
1890 return self.input_splitter.indent_spaces * ' '
1890 return self.input_splitter.indent_spaces * ' '
1891
1891
1892 #-------------------------------------------------------------------------
1892 #-------------------------------------------------------------------------
1893 # Things related to text completion
1893 # Things related to text completion
1894 #-------------------------------------------------------------------------
1894 #-------------------------------------------------------------------------
1895
1895
1896 def init_completer(self):
1896 def init_completer(self):
1897 """Initialize the completion machinery.
1897 """Initialize the completion machinery.
1898
1898
1899 This creates completion machinery that can be used by client code,
1899 This creates completion machinery that can be used by client code,
1900 either interactively in-process (typically triggered by the readline
1900 either interactively in-process (typically triggered by the readline
1901 library), programatically (such as in test suites) or out-of-prcess
1901 library), programatically (such as in test suites) or out-of-prcess
1902 (typically over the network by remote frontends).
1902 (typically over the network by remote frontends).
1903 """
1903 """
1904 from IPython.core.completer import IPCompleter
1904 from IPython.core.completer import IPCompleter
1905 from IPython.core.completerlib import (module_completer,
1905 from IPython.core.completerlib import (module_completer,
1906 magic_run_completer, cd_completer, reset_completer)
1906 magic_run_completer, cd_completer, reset_completer)
1907
1907
1908 self.Completer = IPCompleter(shell=self,
1908 self.Completer = IPCompleter(shell=self,
1909 namespace=self.user_ns,
1909 namespace=self.user_ns,
1910 global_namespace=self.user_global_ns,
1910 global_namespace=self.user_global_ns,
1911 alias_table=self.alias_manager.alias_table,
1911 alias_table=self.alias_manager.alias_table,
1912 use_readline=self.has_readline,
1912 use_readline=self.has_readline,
1913 config=self.config,
1913 config=self.config,
1914 )
1914 )
1915 self.configurables.append(self.Completer)
1915 self.configurables.append(self.Completer)
1916
1916
1917 # Add custom completers to the basic ones built into IPCompleter
1917 # Add custom completers to the basic ones built into IPCompleter
1918 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1918 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1919 self.strdispatchers['complete_command'] = sdisp
1919 self.strdispatchers['complete_command'] = sdisp
1920 self.Completer.custom_completers = sdisp
1920 self.Completer.custom_completers = sdisp
1921
1921
1922 self.set_hook('complete_command', module_completer, str_key = 'import')
1922 self.set_hook('complete_command', module_completer, str_key = 'import')
1923 self.set_hook('complete_command', module_completer, str_key = 'from')
1923 self.set_hook('complete_command', module_completer, str_key = 'from')
1924 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
1924 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
1925 self.set_hook('complete_command', cd_completer, str_key = '%cd')
1925 self.set_hook('complete_command', cd_completer, str_key = '%cd')
1926 self.set_hook('complete_command', reset_completer, str_key = '%reset')
1926 self.set_hook('complete_command', reset_completer, str_key = '%reset')
1927
1927
1928 # Only configure readline if we truly are using readline. IPython can
1928 # Only configure readline if we truly are using readline. IPython can
1929 # do tab-completion over the network, in GUIs, etc, where readline
1929 # do tab-completion over the network, in GUIs, etc, where readline
1930 # itself may be absent
1930 # itself may be absent
1931 if self.has_readline:
1931 if self.has_readline:
1932 self.set_readline_completer()
1932 self.set_readline_completer()
1933
1933
1934 def complete(self, text, line=None, cursor_pos=None):
1934 def complete(self, text, line=None, cursor_pos=None):
1935 """Return the completed text and a list of completions.
1935 """Return the completed text and a list of completions.
1936
1936
1937 Parameters
1937 Parameters
1938 ----------
1938 ----------
1939
1939
1940 text : string
1940 text : string
1941 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
1942 instead a line/position pair are given. In this case, the
1942 instead a line/position pair are given. In this case, the
1943 completer itself will split the line like readline does.
1943 completer itself will split the line like readline does.
1944
1944
1945 line : string, optional
1945 line : string, optional
1946 The complete line that text is part of.
1946 The complete line that text is part of.
1947
1947
1948 cursor_pos : int, optional
1948 cursor_pos : int, optional
1949 The position of the cursor on the input line.
1949 The position of the cursor on the input line.
1950
1950
1951 Returns
1951 Returns
1952 -------
1952 -------
1953 text : string
1953 text : string
1954 The actual text that was completed.
1954 The actual text that was completed.
1955
1955
1956 matches : list
1956 matches : list
1957 A sorted list with all possible completions.
1957 A sorted list with all possible completions.
1958
1958
1959 The optional arguments allow the completion to take more context into
1959 The optional arguments allow the completion to take more context into
1960 account, and are part of the low-level completion API.
1960 account, and are part of the low-level completion API.
1961
1961
1962 This is a wrapper around the completion mechanism, similar to what
1962 This is a wrapper around the completion mechanism, similar to what
1963 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
1964 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
1965 environments (such as GUIs) for text completion.
1965 environments (such as GUIs) for text completion.
1966
1966
1967 Simple usage example:
1967 Simple usage example:
1968
1968
1969 In [1]: x = 'hello'
1969 In [1]: x = 'hello'
1970
1970
1971 In [2]: _ip.complete('x.l')
1971 In [2]: _ip.complete('x.l')
1972 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
1972 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
1973 """
1973 """
1974
1974
1975 # 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.
1976 with self.builtin_trap:
1976 with self.builtin_trap:
1977 return self.Completer.complete(text, line, cursor_pos)
1977 return self.Completer.complete(text, line, cursor_pos)
1978
1978
1979 def set_custom_completer(self, completer, pos=0):
1979 def set_custom_completer(self, completer, pos=0):
1980 """Adds a new custom completer function.
1980 """Adds a new custom completer function.
1981
1981
1982 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
1983 list where you want the completer to be inserted."""
1983 list where you want the completer to be inserted."""
1984
1984
1985 newcomp = types.MethodType(completer,self.Completer)
1985 newcomp = types.MethodType(completer,self.Completer)
1986 self.Completer.matchers.insert(pos,newcomp)
1986 self.Completer.matchers.insert(pos,newcomp)
1987
1987
1988 def set_readline_completer(self):
1988 def set_readline_completer(self):
1989 """Reset readline's completer to be our own."""
1989 """Reset readline's completer to be our own."""
1990 self.readline.set_completer(self.Completer.rlcomplete)
1990 self.readline.set_completer(self.Completer.rlcomplete)
1991
1991
1992 def set_completer_frame(self, frame=None):
1992 def set_completer_frame(self, frame=None):
1993 """Set the frame of the completer."""
1993 """Set the frame of the completer."""
1994 if frame:
1994 if frame:
1995 self.Completer.namespace = frame.f_locals
1995 self.Completer.namespace = frame.f_locals
1996 self.Completer.global_namespace = frame.f_globals
1996 self.Completer.global_namespace = frame.f_globals
1997 else:
1997 else:
1998 self.Completer.namespace = self.user_ns
1998 self.Completer.namespace = self.user_ns
1999 self.Completer.global_namespace = self.user_global_ns
1999 self.Completer.global_namespace = self.user_global_ns
2000
2000
2001 #-------------------------------------------------------------------------
2001 #-------------------------------------------------------------------------
2002 # Things related to magics
2002 # Things related to magics
2003 #-------------------------------------------------------------------------
2003 #-------------------------------------------------------------------------
2004
2004
2005 def init_magics(self):
2005 def init_magics(self):
2006 from IPython.core import magics as m
2006 from IPython.core import magics as m
2007 self.magics_manager = magic.MagicsManager(shell=self,
2007 self.magics_manager = magic.MagicsManager(shell=self,
2008 confg=self.config,
2008 confg=self.config,
2009 user_magics=m.UserMagics(self))
2009 user_magics=m.UserMagics(self))
2010 self.configurables.append(self.magics_manager)
2010 self.configurables.append(self.magics_manager)
2011
2011
2012 # Expose as public API from the magics manager
2012 # Expose as public API from the magics manager
2013 self.register_magics = self.magics_manager.register
2013 self.register_magics = self.magics_manager.register
2014 self.register_magic_function = self.magics_manager.register_function
2014 self.register_magic_function = self.magics_manager.register_function
2015 self.define_magic = self.magics_manager.define_magic
2015 self.define_magic = self.magics_manager.define_magic
2016
2016
2017 self.register_magics(m.AutoMagics, m.BasicMagics, m.CodeMagics,
2017 self.register_magics(m.AutoMagics, m.BasicMagics, m.CodeMagics,
2018 m.ConfigMagics, m.DeprecatedMagics, m.ExecutionMagics,
2018 m.ConfigMagics, m.DeprecatedMagics, m.ExecutionMagics,
2019 m.ExtensionMagics, m.HistoryMagics, m.LoggingMagics,
2019 m.ExtensionMagics, m.HistoryMagics, m.LoggingMagics,
2020 m.NamespaceMagics, m.OSMagics, m.PylabMagics )
2020 m.NamespaceMagics, m.OSMagics, m.PylabMagics )
2021
2021
2022 # FIXME: Move the color initialization to the DisplayHook, which
2022 # FIXME: Move the color initialization to the DisplayHook, which
2023 # should be split into a prompt manager and displayhook. We probably
2023 # should be split into a prompt manager and displayhook. We probably
2024 # even need a centralize colors management object.
2024 # even need a centralize colors management object.
2025 self.magic('colors %s' % self.colors)
2025 self.magic('colors %s' % self.colors)
2026
2026
2027 def run_line_magic(self, magic_name, line):
2027 def run_line_magic(self, magic_name, line):
2028 """Execute the given line magic.
2028 """Execute the given line magic.
2029
2029
2030 Parameters
2030 Parameters
2031 ----------
2031 ----------
2032 magic_name : str
2032 magic_name : str
2033 Name of the desired magic function, without '%' prefix.
2033 Name of the desired magic function, without '%' prefix.
2034
2034
2035 line : str
2035 line : str
2036 The rest of the input line as a single string.
2036 The rest of the input line as a single string.
2037 """
2037 """
2038 fn = self.find_line_magic(magic_name)
2038 fn = self.find_line_magic(magic_name)
2039 if fn is None:
2039 if fn is None:
2040 cm = self.find_cell_magic(magic_name)
2040 cm = self.find_cell_magic(magic_name)
2041 etpl = "Line magic function `%%%s` not found%s."
2041 etpl = "Line magic function `%%%s` not found%s."
2042 extra = '' if cm is None else (' (But cell magic `%%%%%s` exists, '
2042 extra = '' if cm is None else (' (But cell magic `%%%%%s` exists, '
2043 'did you mean that instead?)' % magic_name )
2043 'did you mean that instead?)' % magic_name )
2044 error(etpl % (magic_name, extra))
2044 error(etpl % (magic_name, extra))
2045 else:
2045 else:
2046 # 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.
2047 # 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
2048 # refactored, or else we'll be expanding the wrong variables.
2048 # refactored, or else we'll be expanding the wrong variables.
2049 stack_depth = 2
2049 stack_depth = 2
2050 magic_arg_s = self.var_expand(line, stack_depth)
2050 magic_arg_s = self.var_expand(line, stack_depth)
2051 # 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
2052 args = [magic_arg_s]
2052 args = [magic_arg_s]
2053 # Grab local namespace if we need it:
2053 # Grab local namespace if we need it:
2054 if getattr(fn, "needs_local_scope", False):
2054 if getattr(fn, "needs_local_scope", False):
2055 args.append(sys._getframe(stack_depth).f_locals)
2055 args.append(sys._getframe(stack_depth).f_locals)
2056 with self.builtin_trap:
2056 with self.builtin_trap:
2057 result = fn(*args)
2057 result = fn(*args)
2058 return result
2058 return result
2059
2059
2060 def run_cell_magic(self, magic_name, line, cell):
2060 def run_cell_magic(self, magic_name, line, cell):
2061 """Execute the given cell magic.
2061 """Execute the given cell magic.
2062
2062
2063 Parameters
2063 Parameters
2064 ----------
2064 ----------
2065 magic_name : str
2065 magic_name : str
2066 Name of the desired magic function, without '%' prefix.
2066 Name of the desired magic function, without '%' prefix.
2067
2067
2068 line : str
2068 line : str
2069 The rest of the first input line as a single string.
2069 The rest of the first input line as a single string.
2070
2070
2071 cell : str
2071 cell : str
2072 The body of the cell as a (possibly multiline) string.
2072 The body of the cell as a (possibly multiline) string.
2073 """
2073 """
2074 fn = self.find_cell_magic(magic_name)
2074 fn = self.find_cell_magic(magic_name)
2075 if fn is None:
2075 if fn is None:
2076 lm = self.find_line_magic(magic_name)
2076 lm = self.find_line_magic(magic_name)
2077 etpl = "Cell magic function `%%%%%s` not found%s."
2077 etpl = "Cell magic function `%%%%%s` not found%s."
2078 extra = '' if lm is None else (' (But line magic `%%%s` exists, '
2078 extra = '' if lm is None else (' (But line magic `%%%s` exists, '
2079 'did you mean that instead?)' % magic_name )
2079 'did you mean that instead?)' % magic_name )
2080 error(etpl % (magic_name, extra))
2080 error(etpl % (magic_name, extra))
2081 else:
2081 else:
2082 # 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.
2083 # 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
2084 # refactored, or else we'll be expanding the wrong variables.
2084 # refactored, or else we'll be expanding the wrong variables.
2085 stack_depth = 2
2085 stack_depth = 2
2086 magic_arg_s = self.var_expand(line, stack_depth)
2086 magic_arg_s = self.var_expand(line, stack_depth)
2087 with self.builtin_trap:
2087 with self.builtin_trap:
2088 result = fn(line, cell)
2088 result = fn(line, cell)
2089 return result
2089 return result
2090
2090
2091 def find_line_magic(self, magic_name):
2091 def find_line_magic(self, magic_name):
2092 """Find and return a line magic by name.
2092 """Find and return a line magic by name.
2093
2093
2094 Returns None if the magic isn't found."""
2094 Returns None if the magic isn't found."""
2095 return self.magics_manager.magics['line'].get(magic_name)
2095 return self.magics_manager.magics['line'].get(magic_name)
2096
2096
2097 def find_cell_magic(self, magic_name):
2097 def find_cell_magic(self, magic_name):
2098 """Find and return a cell magic by name.
2098 """Find and return a cell magic by name.
2099
2099
2100 Returns None if the magic isn't found."""
2100 Returns None if the magic isn't found."""
2101 return self.magics_manager.magics['cell'].get(magic_name)
2101 return self.magics_manager.magics['cell'].get(magic_name)
2102
2102
2103 def find_magic(self, magic_name, magic_kind='line'):
2103 def find_magic(self, magic_name, magic_kind='line'):
2104 """Find and return a magic of the given type by name.
2104 """Find and return a magic of the given type by name.
2105
2105
2106 Returns None if the magic isn't found."""
2106 Returns None if the magic isn't found."""
2107 return self.magics_manager.magics[magic_kind].get(magic_name)
2107 return self.magics_manager.magics[magic_kind].get(magic_name)
2108
2108
2109 def magic(self, arg_s):
2109 def magic(self, arg_s):
2110 """DEPRECATED. Use run_line_magic() instead.
2110 """DEPRECATED. Use run_line_magic() instead.
2111
2111
2112 Call a magic function by name.
2112 Call a magic function by name.
2113
2113
2114 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
2115 any additional arguments to be passed to the magic.
2115 any additional arguments to be passed to the magic.
2116
2116
2117 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
2118 prompt:
2118 prompt:
2119
2119
2120 In[1]: %name -opt foo bar
2120 In[1]: %name -opt foo bar
2121
2121
2122 To call a magic without arguments, simply use magic('name').
2122 To call a magic without arguments, simply use magic('name').
2123
2123
2124 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
2125 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
2126 compound statements.
2126 compound statements.
2127 """
2127 """
2128 # TODO: should we issue a loud deprecation warning here?
2128 # TODO: should we issue a loud deprecation warning here?
2129 magic_name, _, magic_arg_s = arg_s.partition(' ')
2129 magic_name, _, magic_arg_s = arg_s.partition(' ')
2130 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
2130 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
2131 return self.run_line_magic(magic_name, magic_arg_s)
2131 return self.run_line_magic(magic_name, magic_arg_s)
2132
2132
2133 #-------------------------------------------------------------------------
2133 #-------------------------------------------------------------------------
2134 # Things related to macros
2134 # Things related to macros
2135 #-------------------------------------------------------------------------
2135 #-------------------------------------------------------------------------
2136
2136
2137 def define_macro(self, name, themacro):
2137 def define_macro(self, name, themacro):
2138 """Define a new macro
2138 """Define a new macro
2139
2139
2140 Parameters
2140 Parameters
2141 ----------
2141 ----------
2142 name : str
2142 name : str
2143 The name of the macro.
2143 The name of the macro.
2144 themacro : str or Macro
2144 themacro : str or Macro
2145 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
2146 Macro object is created by passing the string to it.
2146 Macro object is created by passing the string to it.
2147 """
2147 """
2148
2148
2149 from IPython.core import macro
2149 from IPython.core import macro
2150
2150
2151 if isinstance(themacro, basestring):
2151 if isinstance(themacro, basestring):
2152 themacro = macro.Macro(themacro)
2152 themacro = macro.Macro(themacro)
2153 if not isinstance(themacro, macro.Macro):
2153 if not isinstance(themacro, macro.Macro):
2154 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.')
2155 self.user_ns[name] = themacro
2155 self.user_ns[name] = themacro
2156
2156
2157 #-------------------------------------------------------------------------
2157 #-------------------------------------------------------------------------
2158 # Things related to the running of system commands
2158 # Things related to the running of system commands
2159 #-------------------------------------------------------------------------
2159 #-------------------------------------------------------------------------
2160
2160
2161 def system_piped(self, cmd):
2161 def system_piped(self, cmd):
2162 """Call the given cmd in a subprocess, piping stdout/err
2162 """Call the given cmd in a subprocess, piping stdout/err
2163
2163
2164 Parameters
2164 Parameters
2165 ----------
2165 ----------
2166 cmd : str
2166 cmd : str
2167 Command to execute (can not end in '&', as background processes are
2167 Command to execute (can not end in '&', as background processes are
2168 not supported. Should not be a command that expects input
2168 not supported. Should not be a command that expects input
2169 other than simple text.
2169 other than simple text.
2170 """
2170 """
2171 if cmd.rstrip().endswith('&'):
2171 if cmd.rstrip().endswith('&'):
2172 # this is *far* from a rigorous test
2172 # this is *far* from a rigorous test
2173 # We do not support backgrounding processes because we either use
2173 # We do not support backgrounding processes because we either use
2174 # pexpect or pipes to read from. Users can always just call
2174 # pexpect or pipes to read from. Users can always just call
2175 # os.system() or use ip.system=ip.system_raw
2175 # os.system() or use ip.system=ip.system_raw
2176 # if they really want a background process.
2176 # if they really want a background process.
2177 raise OSError("Background processes not supported.")
2177 raise OSError("Background processes not supported.")
2178
2178
2179 # we explicitly do NOT return the subprocess status code, because
2179 # we explicitly do NOT return the subprocess status code, because
2180 # a non-None value would trigger :func:`sys.displayhook` calls.
2180 # a non-None value would trigger :func:`sys.displayhook` calls.
2181 # Instead, we store the exit_code in user_ns.
2181 # Instead, we store the exit_code in user_ns.
2182 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=2))
2182 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=1))
2183
2183
2184 def system_raw(self, cmd):
2184 def system_raw(self, cmd):
2185 """Call the given cmd in a subprocess using os.system
2185 """Call the given cmd in a subprocess using os.system
2186
2186
2187 Parameters
2187 Parameters
2188 ----------
2188 ----------
2189 cmd : str
2189 cmd : str
2190 Command to execute.
2190 Command to execute.
2191 """
2191 """
2192 cmd = self.var_expand(cmd, depth=2)
2192 cmd = self.var_expand(cmd, depth=1)
2193 # 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:
2194 if sys.platform == 'win32':
2194 if sys.platform == 'win32':
2195 from IPython.utils._process_win32 import AvoidUNCPath
2195 from IPython.utils._process_win32 import AvoidUNCPath
2196 with AvoidUNCPath() as path:
2196 with AvoidUNCPath() as path:
2197 if path is not None:
2197 if path is not None:
2198 cmd = '"pushd %s &&"%s' % (path, cmd)
2198 cmd = '"pushd %s &&"%s' % (path, cmd)
2199 cmd = py3compat.unicode_to_str(cmd)
2199 cmd = py3compat.unicode_to_str(cmd)
2200 ec = os.system(cmd)
2200 ec = os.system(cmd)
2201 else:
2201 else:
2202 cmd = py3compat.unicode_to_str(cmd)
2202 cmd = py3compat.unicode_to_str(cmd)
2203 ec = os.system(cmd)
2203 ec = os.system(cmd)
2204
2204
2205 # We explicitly do NOT return the subprocess status code, because
2205 # We explicitly do NOT return the subprocess status code, because
2206 # a non-None value would trigger :func:`sys.displayhook` calls.
2206 # a non-None value would trigger :func:`sys.displayhook` calls.
2207 # Instead, we store the exit_code in user_ns.
2207 # Instead, we store the exit_code in user_ns.
2208 self.user_ns['_exit_code'] = ec
2208 self.user_ns['_exit_code'] = ec
2209
2209
2210 # use piped system by default, because it is better behaved
2210 # use piped system by default, because it is better behaved
2211 system = system_piped
2211 system = system_piped
2212
2212
2213 def getoutput(self, cmd, split=True):
2213 def getoutput(self, cmd, split=True):
2214 """Get output (possibly including stderr) from a subprocess.
2214 """Get output (possibly including stderr) from a subprocess.
2215
2215
2216 Parameters
2216 Parameters
2217 ----------
2217 ----------
2218 cmd : str
2218 cmd : str
2219 Command to execute (can not end in '&', as background processes are
2219 Command to execute (can not end in '&', as background processes are
2220 not supported.
2220 not supported.
2221 split : bool, optional
2221 split : bool, optional
2222
2222
2223 If True, split the output into an IPython SList. Otherwise, an
2223 If True, split the output into an IPython SList. Otherwise, an
2224 IPython LSString is returned. These are objects similar to normal
2224 IPython LSString is returned. These are objects similar to normal
2225 lists and strings, with a few convenience attributes for easier
2225 lists and strings, with a few convenience attributes for easier
2226 manipulation of line-based output. You can use '?' on them for
2226 manipulation of line-based output. You can use '?' on them for
2227 details.
2227 details.
2228 """
2228 """
2229 if cmd.rstrip().endswith('&'):
2229 if cmd.rstrip().endswith('&'):
2230 # this is *far* from a rigorous test
2230 # this is *far* from a rigorous test
2231 raise OSError("Background processes not supported.")
2231 raise OSError("Background processes not supported.")
2232 out = getoutput(self.var_expand(cmd, depth=2))
2232 out = getoutput(self.var_expand(cmd, depth=1))
2233 if split:
2233 if split:
2234 out = SList(out.splitlines())
2234 out = SList(out.splitlines())
2235 else:
2235 else:
2236 out = LSString(out)
2236 out = LSString(out)
2237 return out
2237 return out
2238
2238
2239 #-------------------------------------------------------------------------
2239 #-------------------------------------------------------------------------
2240 # Things related to aliases
2240 # Things related to aliases
2241 #-------------------------------------------------------------------------
2241 #-------------------------------------------------------------------------
2242
2242
2243 def init_alias(self):
2243 def init_alias(self):
2244 self.alias_manager = AliasManager(shell=self, config=self.config)
2244 self.alias_manager = AliasManager(shell=self, config=self.config)
2245 self.configurables.append(self.alias_manager)
2245 self.configurables.append(self.alias_manager)
2246 self.ns_table['alias'] = self.alias_manager.alias_table,
2246 self.ns_table['alias'] = self.alias_manager.alias_table,
2247
2247
2248 #-------------------------------------------------------------------------
2248 #-------------------------------------------------------------------------
2249 # Things related to extensions and plugins
2249 # Things related to extensions and plugins
2250 #-------------------------------------------------------------------------
2250 #-------------------------------------------------------------------------
2251
2251
2252 def init_extension_manager(self):
2252 def init_extension_manager(self):
2253 self.extension_manager = ExtensionManager(shell=self, config=self.config)
2253 self.extension_manager = ExtensionManager(shell=self, config=self.config)
2254 self.configurables.append(self.extension_manager)
2254 self.configurables.append(self.extension_manager)
2255
2255
2256 def init_plugin_manager(self):
2256 def init_plugin_manager(self):
2257 self.plugin_manager = PluginManager(config=self.config)
2257 self.plugin_manager = PluginManager(config=self.config)
2258 self.configurables.append(self.plugin_manager)
2258 self.configurables.append(self.plugin_manager)
2259
2259
2260
2260
2261 #-------------------------------------------------------------------------
2261 #-------------------------------------------------------------------------
2262 # Things related to payloads
2262 # Things related to payloads
2263 #-------------------------------------------------------------------------
2263 #-------------------------------------------------------------------------
2264
2264
2265 def init_payload(self):
2265 def init_payload(self):
2266 self.payload_manager = PayloadManager(config=self.config)
2266 self.payload_manager = PayloadManager(config=self.config)
2267 self.configurables.append(self.payload_manager)
2267 self.configurables.append(self.payload_manager)
2268
2268
2269 #-------------------------------------------------------------------------
2269 #-------------------------------------------------------------------------
2270 # Things related to the prefilter
2270 # Things related to the prefilter
2271 #-------------------------------------------------------------------------
2271 #-------------------------------------------------------------------------
2272
2272
2273 def init_prefilter(self):
2273 def init_prefilter(self):
2274 self.prefilter_manager = PrefilterManager(shell=self, config=self.config)
2274 self.prefilter_manager = PrefilterManager(shell=self, config=self.config)
2275 self.configurables.append(self.prefilter_manager)
2275 self.configurables.append(self.prefilter_manager)
2276 # Ultimately this will be refactored in the new interpreter code, but
2276 # Ultimately this will be refactored in the new interpreter code, but
2277 # 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
2278 # code out there that may rely on this).
2278 # code out there that may rely on this).
2279 self.prefilter = self.prefilter_manager.prefilter_lines
2279 self.prefilter = self.prefilter_manager.prefilter_lines
2280
2280
2281 def auto_rewrite_input(self, cmd):
2281 def auto_rewrite_input(self, cmd):
2282 """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.
2283
2283
2284 This shows visual feedback by rewriting input lines that cause
2284 This shows visual feedback by rewriting input lines that cause
2285 automatic calling to kick in, like::
2285 automatic calling to kick in, like::
2286
2286
2287 /f x
2287 /f x
2288
2288
2289 into::
2289 into::
2290
2290
2291 ------> f(x)
2291 ------> f(x)
2292
2292
2293 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
2294 input line was transformed automatically by IPython.
2294 input line was transformed automatically by IPython.
2295 """
2295 """
2296 if not self.show_rewritten_input:
2296 if not self.show_rewritten_input:
2297 return
2297 return
2298
2298
2299 rw = self.prompt_manager.render('rewrite') + cmd
2299 rw = self.prompt_manager.render('rewrite') + cmd
2300
2300
2301 try:
2301 try:
2302 # plain ascii works better w/ pyreadline, on some machines, so
2302 # plain ascii works better w/ pyreadline, on some machines, so
2303 # 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
2304 rw = str(rw)
2304 rw = str(rw)
2305 print >> io.stdout, rw
2305 print >> io.stdout, rw
2306 except UnicodeEncodeError:
2306 except UnicodeEncodeError:
2307 print "------> " + cmd
2307 print "------> " + cmd
2308
2308
2309 #-------------------------------------------------------------------------
2309 #-------------------------------------------------------------------------
2310 # Things related to extracting values/expressions from kernel and user_ns
2310 # Things related to extracting values/expressions from kernel and user_ns
2311 #-------------------------------------------------------------------------
2311 #-------------------------------------------------------------------------
2312
2312
2313 def _simple_error(self):
2313 def _simple_error(self):
2314 etype, value = sys.exc_info()[:2]
2314 etype, value = sys.exc_info()[:2]
2315 return u'[ERROR] {e.__name__}: {v}'.format(e=etype, v=value)
2315 return u'[ERROR] {e.__name__}: {v}'.format(e=etype, v=value)
2316
2316
2317 def user_variables(self, names):
2317 def user_variables(self, names):
2318 """Get a list of variable names from the user's namespace.
2318 """Get a list of variable names from the user's namespace.
2319
2319
2320 Parameters
2320 Parameters
2321 ----------
2321 ----------
2322 names : list of strings
2322 names : list of strings
2323 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.
2324
2324
2325 Returns
2325 Returns
2326 -------
2326 -------
2327 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.
2328 """
2328 """
2329 out = {}
2329 out = {}
2330 user_ns = self.user_ns
2330 user_ns = self.user_ns
2331 for varname in names:
2331 for varname in names:
2332 try:
2332 try:
2333 value = repr(user_ns[varname])
2333 value = repr(user_ns[varname])
2334 except:
2334 except:
2335 value = self._simple_error()
2335 value = self._simple_error()
2336 out[varname] = value
2336 out[varname] = value
2337 return out
2337 return out
2338
2338
2339 def user_expressions(self, expressions):
2339 def user_expressions(self, expressions):
2340 """Evaluate a dict of expressions in the user's namespace.
2340 """Evaluate a dict of expressions in the user's namespace.
2341
2341
2342 Parameters
2342 Parameters
2343 ----------
2343 ----------
2344 expressions : dict
2344 expressions : dict
2345 A dict with string keys and string values. The expression values
2345 A dict with string keys and string values. The expression values
2346 should be valid Python expressions, each of which will be evaluated
2346 should be valid Python expressions, each of which will be evaluated
2347 in the user namespace.
2347 in the user namespace.
2348
2348
2349 Returns
2349 Returns
2350 -------
2350 -------
2351 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
2352 value.
2352 value.
2353 """
2353 """
2354 out = {}
2354 out = {}
2355 user_ns = self.user_ns
2355 user_ns = self.user_ns
2356 global_ns = self.user_global_ns
2356 global_ns = self.user_global_ns
2357 for key, expr in expressions.iteritems():
2357 for key, expr in expressions.iteritems():
2358 try:
2358 try:
2359 value = repr(eval(expr, global_ns, user_ns))
2359 value = repr(eval(expr, global_ns, user_ns))
2360 except:
2360 except:
2361 value = self._simple_error()
2361 value = self._simple_error()
2362 out[key] = value
2362 out[key] = value
2363 return out
2363 return out
2364
2364
2365 #-------------------------------------------------------------------------
2365 #-------------------------------------------------------------------------
2366 # Things related to the running of code
2366 # Things related to the running of code
2367 #-------------------------------------------------------------------------
2367 #-------------------------------------------------------------------------
2368
2368
2369 def ex(self, cmd):
2369 def ex(self, cmd):
2370 """Execute a normal python statement in user namespace."""
2370 """Execute a normal python statement in user namespace."""
2371 with self.builtin_trap:
2371 with self.builtin_trap:
2372 exec cmd in self.user_global_ns, self.user_ns
2372 exec cmd in self.user_global_ns, self.user_ns
2373
2373
2374 def ev(self, expr):
2374 def ev(self, expr):
2375 """Evaluate python expression expr in user namespace.
2375 """Evaluate python expression expr in user namespace.
2376
2376
2377 Returns the result of evaluation
2377 Returns the result of evaluation
2378 """
2378 """
2379 with self.builtin_trap:
2379 with self.builtin_trap:
2380 return eval(expr, self.user_global_ns, self.user_ns)
2380 return eval(expr, self.user_global_ns, self.user_ns)
2381
2381
2382 def safe_execfile(self, fname, *where, **kw):
2382 def safe_execfile(self, fname, *where, **kw):
2383 """A safe version of the builtin execfile().
2383 """A safe version of the builtin execfile().
2384
2384
2385 This version will never throw an exception, but instead print
2385 This version will never throw an exception, but instead print
2386 helpful error messages to the screen. This only works on pure
2386 helpful error messages to the screen. This only works on pure
2387 Python files with the .py extension.
2387 Python files with the .py extension.
2388
2388
2389 Parameters
2389 Parameters
2390 ----------
2390 ----------
2391 fname : string
2391 fname : string
2392 The name of the file to be executed.
2392 The name of the file to be executed.
2393 where : tuple
2393 where : tuple
2394 One or two namespaces, passed to execfile() as (globals,locals).
2394 One or two namespaces, passed to execfile() as (globals,locals).
2395 If only one is given, it is passed as both.
2395 If only one is given, it is passed as both.
2396 exit_ignore : bool (False)
2396 exit_ignore : bool (False)
2397 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
2398 silenced for zero status, as it is so common).
2398 silenced for zero status, as it is so common).
2399 raise_exceptions : bool (False)
2399 raise_exceptions : bool (False)
2400 If True raise exceptions everywhere. Meant for testing.
2400 If True raise exceptions everywhere. Meant for testing.
2401
2401
2402 """
2402 """
2403 kw.setdefault('exit_ignore', False)
2403 kw.setdefault('exit_ignore', False)
2404 kw.setdefault('raise_exceptions', False)
2404 kw.setdefault('raise_exceptions', False)
2405
2405
2406 fname = os.path.abspath(os.path.expanduser(fname))
2406 fname = os.path.abspath(os.path.expanduser(fname))
2407
2407
2408 # Make sure we can open the file
2408 # Make sure we can open the file
2409 try:
2409 try:
2410 with open(fname) as thefile:
2410 with open(fname) as thefile:
2411 pass
2411 pass
2412 except:
2412 except:
2413 warn('Could not open file <%s> for safe execution.' % fname)
2413 warn('Could not open file <%s> for safe execution.' % fname)
2414 return
2414 return
2415
2415
2416 # 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
2417 # behavior of running a script from the system command line, where
2417 # behavior of running a script from the system command line, where
2418 # Python inserts the script's directory into sys.path
2418 # Python inserts the script's directory into sys.path
2419 dname = os.path.dirname(fname)
2419 dname = os.path.dirname(fname)
2420
2420
2421 with prepended_to_syspath(dname):
2421 with prepended_to_syspath(dname):
2422 try:
2422 try:
2423 py3compat.execfile(fname,*where)
2423 py3compat.execfile(fname,*where)
2424 except SystemExit, status:
2424 except SystemExit, status:
2425 # 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)
2426 # 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
2427 # these are considered normal by the OS:
2427 # these are considered normal by the OS:
2428 # > python -c'import sys;sys.exit(0)'; echo $?
2428 # > python -c'import sys;sys.exit(0)'; echo $?
2429 # 0
2429 # 0
2430 # > python -c'import sys;sys.exit()'; echo $?
2430 # > python -c'import sys;sys.exit()'; echo $?
2431 # 0
2431 # 0
2432 # For other exit status, we show the exception unless
2432 # For other exit status, we show the exception unless
2433 # explicitly silenced, but only in short form.
2433 # explicitly silenced, but only in short form.
2434 if kw['raise_exceptions']:
2434 if kw['raise_exceptions']:
2435 raise
2435 raise
2436 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']:
2437 self.showtraceback(exception_only=True)
2437 self.showtraceback(exception_only=True)
2438 except:
2438 except:
2439 if kw['raise_exceptions']:
2439 if kw['raise_exceptions']:
2440 raise
2440 raise
2441 self.showtraceback()
2441 self.showtraceback()
2442
2442
2443 def safe_execfile_ipy(self, fname):
2443 def safe_execfile_ipy(self, fname):
2444 """Like safe_execfile, but for .ipy files with IPython syntax.
2444 """Like safe_execfile, but for .ipy files with IPython syntax.
2445
2445
2446 Parameters
2446 Parameters
2447 ----------
2447 ----------
2448 fname : str
2448 fname : str
2449 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
2450 .ipy extension.
2450 .ipy extension.
2451 """
2451 """
2452 fname = os.path.abspath(os.path.expanduser(fname))
2452 fname = os.path.abspath(os.path.expanduser(fname))
2453
2453
2454 # Make sure we can open the file
2454 # Make sure we can open the file
2455 try:
2455 try:
2456 with open(fname) as thefile:
2456 with open(fname) as thefile:
2457 pass
2457 pass
2458 except:
2458 except:
2459 warn('Could not open file <%s> for safe execution.' % fname)
2459 warn('Could not open file <%s> for safe execution.' % fname)
2460 return
2460 return
2461
2461
2462 # 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
2463 # behavior of running a script from the system command line, where
2463 # behavior of running a script from the system command line, where
2464 # Python inserts the script's directory into sys.path
2464 # Python inserts the script's directory into sys.path
2465 dname = os.path.dirname(fname)
2465 dname = os.path.dirname(fname)
2466
2466
2467 with prepended_to_syspath(dname):
2467 with prepended_to_syspath(dname):
2468 try:
2468 try:
2469 with open(fname) as thefile:
2469 with open(fname) as thefile:
2470 # self.run_cell currently captures all exceptions
2470 # self.run_cell currently captures all exceptions
2471 # raised in user code. It would be nice if there were
2471 # raised in user code. It would be nice if there were
2472 # versions of runlines, execfile that did raise, so
2472 # versions of runlines, execfile that did raise, so
2473 # we could catch the errors.
2473 # we could catch the errors.
2474 self.run_cell(thefile.read(), store_history=False)
2474 self.run_cell(thefile.read(), store_history=False)
2475 except:
2475 except:
2476 self.showtraceback()
2476 self.showtraceback()
2477 warn('Unknown failure executing file: <%s>' % fname)
2477 warn('Unknown failure executing file: <%s>' % fname)
2478
2478
2479 def safe_run_module(self, mod_name, where):
2479 def safe_run_module(self, mod_name, where):
2480 """A safe version of runpy.run_module().
2480 """A safe version of runpy.run_module().
2481
2481
2482 This version will never throw an exception, but instead print
2482 This version will never throw an exception, but instead print
2483 helpful error messages to the screen.
2483 helpful error messages to the screen.
2484
2484
2485 Parameters
2485 Parameters
2486 ----------
2486 ----------
2487 mod_name : string
2487 mod_name : string
2488 The name of the module to be executed.
2488 The name of the module to be executed.
2489 where : dict
2489 where : dict
2490 The globals namespace.
2490 The globals namespace.
2491 """
2491 """
2492 try:
2492 try:
2493 where.update(
2493 where.update(
2494 runpy.run_module(str(mod_name), run_name="__main__",
2494 runpy.run_module(str(mod_name), run_name="__main__",
2495 alter_sys=True)
2495 alter_sys=True)
2496 )
2496 )
2497 except:
2497 except:
2498 self.showtraceback()
2498 self.showtraceback()
2499 warn('Unknown failure executing module: <%s>' % mod_name)
2499 warn('Unknown failure executing module: <%s>' % mod_name)
2500
2500
2501 def _run_cached_cell_magic(self, magic_name, line):
2501 def _run_cached_cell_magic(self, magic_name, line):
2502 """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.
2503 """
2503 """
2504 cell = self._current_cell_magic_body
2504 cell = self._current_cell_magic_body
2505 self._current_cell_magic_body = None
2505 self._current_cell_magic_body = None
2506 return self.run_cell_magic(magic_name, line, cell)
2506 return self.run_cell_magic(magic_name, line, cell)
2507
2507
2508 def run_cell(self, raw_cell, store_history=False, silent=False):
2508 def run_cell(self, raw_cell, store_history=False, silent=False):
2509 """Run a complete IPython cell.
2509 """Run a complete IPython cell.
2510
2510
2511 Parameters
2511 Parameters
2512 ----------
2512 ----------
2513 raw_cell : str
2513 raw_cell : str
2514 The code (including IPython code such as %magic functions) to run.
2514 The code (including IPython code such as %magic functions) to run.
2515 store_history : bool
2515 store_history : bool
2516 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
2517 history. For user code calling back into IPython's machinery, this
2517 history. For user code calling back into IPython's machinery, this
2518 should be set to False.
2518 should be set to False.
2519 silent : bool
2519 silent : bool
2520 If True, avoid side-effets, such as implicit displayhooks, history,
2520 If True, avoid side-effets, such as implicit displayhooks, history,
2521 and logging. silent=True forces store_history=False.
2521 and logging. silent=True forces store_history=False.
2522 """
2522 """
2523 if (not raw_cell) or raw_cell.isspace():
2523 if (not raw_cell) or raw_cell.isspace():
2524 return
2524 return
2525
2525
2526 if silent:
2526 if silent:
2527 store_history = False
2527 store_history = False
2528
2528
2529 self.input_splitter.push(raw_cell)
2529 self.input_splitter.push(raw_cell)
2530
2530
2531 # Check for cell magics, which leave state behind. This interface is
2531 # Check for cell magics, which leave state behind. This interface is
2532 # 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
2533 # 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,
2534 # and in that case we grab the cell body.
2534 # and in that case we grab the cell body.
2535 if self.input_splitter.cell_magic_parts:
2535 if self.input_splitter.cell_magic_parts:
2536 self._current_cell_magic_body = \
2536 self._current_cell_magic_body = \
2537 ''.join(self.input_splitter.cell_magic_parts)
2537 ''.join(self.input_splitter.cell_magic_parts)
2538 cell = self.input_splitter.source_reset()
2538 cell = self.input_splitter.source_reset()
2539
2539
2540 with self.builtin_trap:
2540 with self.builtin_trap:
2541 prefilter_failed = False
2541 prefilter_failed = False
2542 if len(cell.splitlines()) == 1:
2542 if len(cell.splitlines()) == 1:
2543 try:
2543 try:
2544 # use prefilter_lines to handle trailing newlines
2544 # use prefilter_lines to handle trailing newlines
2545 # restore trailing newline for ast.parse
2545 # restore trailing newline for ast.parse
2546 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
2546 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
2547 except AliasError as e:
2547 except AliasError as e:
2548 error(e)
2548 error(e)
2549 prefilter_failed = True
2549 prefilter_failed = True
2550 except Exception:
2550 except Exception:
2551 # don't allow prefilter errors to crash IPython
2551 # don't allow prefilter errors to crash IPython
2552 self.showtraceback()
2552 self.showtraceback()
2553 prefilter_failed = True
2553 prefilter_failed = True
2554
2554
2555 # Store raw and processed history
2555 # Store raw and processed history
2556 if store_history:
2556 if store_history:
2557 self.history_manager.store_inputs(self.execution_count,
2557 self.history_manager.store_inputs(self.execution_count,
2558 cell, raw_cell)
2558 cell, raw_cell)
2559 if not silent:
2559 if not silent:
2560 self.logger.log(cell, raw_cell)
2560 self.logger.log(cell, raw_cell)
2561
2561
2562 if not prefilter_failed:
2562 if not prefilter_failed:
2563 # don't run if prefilter failed
2563 # don't run if prefilter failed
2564 cell_name = self.compile.cache(cell, self.execution_count)
2564 cell_name = self.compile.cache(cell, self.execution_count)
2565
2565
2566 with self.display_trap:
2566 with self.display_trap:
2567 try:
2567 try:
2568 code_ast = self.compile.ast_parse(cell,
2568 code_ast = self.compile.ast_parse(cell,
2569 filename=cell_name)
2569 filename=cell_name)
2570 except IndentationError:
2570 except IndentationError:
2571 self.showindentationerror()
2571 self.showindentationerror()
2572 if store_history:
2572 if store_history:
2573 self.execution_count += 1
2573 self.execution_count += 1
2574 return None
2574 return None
2575 except (OverflowError, SyntaxError, ValueError, TypeError,
2575 except (OverflowError, SyntaxError, ValueError, TypeError,
2576 MemoryError):
2576 MemoryError):
2577 self.showsyntaxerror()
2577 self.showsyntaxerror()
2578 if store_history:
2578 if store_history:
2579 self.execution_count += 1
2579 self.execution_count += 1
2580 return None
2580 return None
2581
2581
2582 interactivity = "none" if silent else self.ast_node_interactivity
2582 interactivity = "none" if silent else self.ast_node_interactivity
2583 self.run_ast_nodes(code_ast.body, cell_name,
2583 self.run_ast_nodes(code_ast.body, cell_name,
2584 interactivity=interactivity)
2584 interactivity=interactivity)
2585
2585
2586 # Execute any registered post-execution functions.
2586 # Execute any registered post-execution functions.
2587 # unless we are silent
2587 # unless we are silent
2588 post_exec = [] if silent else self._post_execute.iteritems()
2588 post_exec = [] if silent else self._post_execute.iteritems()
2589
2589
2590 for func, status in post_exec:
2590 for func, status in post_exec:
2591 if self.disable_failing_post_execute and not status:
2591 if self.disable_failing_post_execute and not status:
2592 continue
2592 continue
2593 try:
2593 try:
2594 func()
2594 func()
2595 except KeyboardInterrupt:
2595 except KeyboardInterrupt:
2596 print >> io.stderr, "\nKeyboardInterrupt"
2596 print >> io.stderr, "\nKeyboardInterrupt"
2597 except Exception:
2597 except Exception:
2598 # register as failing:
2598 # register as failing:
2599 self._post_execute[func] = False
2599 self._post_execute[func] = False
2600 self.showtraceback()
2600 self.showtraceback()
2601 print >> io.stderr, '\n'.join([
2601 print >> io.stderr, '\n'.join([
2602 "post-execution function %r produced an error." % func,
2602 "post-execution function %r produced an error." % func,
2603 "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:",
2604 "",
2604 "",
2605 " get_ipython().disable_failing_post_execute = True"
2605 " get_ipython().disable_failing_post_execute = True"
2606 ])
2606 ])
2607
2607
2608 if store_history:
2608 if store_history:
2609 # Write output to the database. Does nothing unless
2609 # Write output to the database. Does nothing unless
2610 # history output logging is enabled.
2610 # history output logging is enabled.
2611 self.history_manager.store_output(self.execution_count)
2611 self.history_manager.store_output(self.execution_count)
2612 # 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
2613 self.execution_count += 1
2613 self.execution_count += 1
2614
2614
2615 def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr'):
2615 def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr'):
2616 """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
2617 interactivity parameter.
2617 interactivity parameter.
2618
2618
2619 Parameters
2619 Parameters
2620 ----------
2620 ----------
2621 nodelist : list
2621 nodelist : list
2622 A sequence of AST nodes to run.
2622 A sequence of AST nodes to run.
2623 cell_name : str
2623 cell_name : str
2624 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
2625 the value returned by ip.compile.cache(cell).
2625 the value returned by ip.compile.cache(cell).
2626 interactivity : str
2626 interactivity : str
2627 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
2627 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
2628 run interactively (displaying output from expressions). 'last_expr'
2628 run interactively (displaying output from expressions). 'last_expr'
2629 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.
2630 expressions in loops or other blocks are not displayed. Other values
2630 expressions in loops or other blocks are not displayed. Other values
2631 for this parameter will raise a ValueError.
2631 for this parameter will raise a ValueError.
2632 """
2632 """
2633 if not nodelist:
2633 if not nodelist:
2634 return
2634 return
2635
2635
2636 if interactivity == 'last_expr':
2636 if interactivity == 'last_expr':
2637 if isinstance(nodelist[-1], ast.Expr):
2637 if isinstance(nodelist[-1], ast.Expr):
2638 interactivity = "last"
2638 interactivity = "last"
2639 else:
2639 else:
2640 interactivity = "none"
2640 interactivity = "none"
2641
2641
2642 if interactivity == 'none':
2642 if interactivity == 'none':
2643 to_run_exec, to_run_interactive = nodelist, []
2643 to_run_exec, to_run_interactive = nodelist, []
2644 elif interactivity == 'last':
2644 elif interactivity == 'last':
2645 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
2645 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
2646 elif interactivity == 'all':
2646 elif interactivity == 'all':
2647 to_run_exec, to_run_interactive = [], nodelist
2647 to_run_exec, to_run_interactive = [], nodelist
2648 else:
2648 else:
2649 raise ValueError("Interactivity was %r" % interactivity)
2649 raise ValueError("Interactivity was %r" % interactivity)
2650
2650
2651 exec_count = self.execution_count
2651 exec_count = self.execution_count
2652
2652
2653 try:
2653 try:
2654 for i, node in enumerate(to_run_exec):
2654 for i, node in enumerate(to_run_exec):
2655 mod = ast.Module([node])
2655 mod = ast.Module([node])
2656 code = self.compile(mod, cell_name, "exec")
2656 code = self.compile(mod, cell_name, "exec")
2657 if self.run_code(code):
2657 if self.run_code(code):
2658 return True
2658 return True
2659
2659
2660 for i, node in enumerate(to_run_interactive):
2660 for i, node in enumerate(to_run_interactive):
2661 mod = ast.Interactive([node])
2661 mod = ast.Interactive([node])
2662 code = self.compile(mod, cell_name, "single")
2662 code = self.compile(mod, cell_name, "single")
2663 if self.run_code(code):
2663 if self.run_code(code):
2664 return True
2664 return True
2665
2665
2666 # Flush softspace
2666 # Flush softspace
2667 if softspace(sys.stdout, 0):
2667 if softspace(sys.stdout, 0):
2668 print
2668 print
2669
2669
2670 except:
2670 except:
2671 # It's possible to have exceptions raised here, typically by
2671 # It's possible to have exceptions raised here, typically by
2672 # compilation of odd code (such as a naked 'return' outside a
2672 # compilation of odd code (such as a naked 'return' outside a
2673 # function) that did parse but isn't valid. Typically the exception
2673 # function) that did parse but isn't valid. Typically the exception
2674 # 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
2675 # the user a traceback.
2675 # the user a traceback.
2676
2676
2677 # 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
2678 # 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
2679 # broken, we should stop execution completely.
2679 # broken, we should stop execution completely.
2680 self.showtraceback()
2680 self.showtraceback()
2681
2681
2682 return False
2682 return False
2683
2683
2684 def run_code(self, code_obj):
2684 def run_code(self, code_obj):
2685 """Execute a code object.
2685 """Execute a code object.
2686
2686
2687 When an exception occurs, self.showtraceback() is called to display a
2687 When an exception occurs, self.showtraceback() is called to display a
2688 traceback.
2688 traceback.
2689
2689
2690 Parameters
2690 Parameters
2691 ----------
2691 ----------
2692 code_obj : code object
2692 code_obj : code object
2693 A compiled code object, to be executed
2693 A compiled code object, to be executed
2694
2694
2695 Returns
2695 Returns
2696 -------
2696 -------
2697 False : successful execution.
2697 False : successful execution.
2698 True : an error occurred.
2698 True : an error occurred.
2699 """
2699 """
2700
2700
2701 # 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
2702 # directly, so that the IPython crash handler doesn't get triggered
2702 # directly, so that the IPython crash handler doesn't get triggered
2703 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2703 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2704
2704
2705 # 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
2706 # code (such as magics) needs access to it.
2706 # code (such as magics) needs access to it.
2707 self.sys_excepthook = old_excepthook
2707 self.sys_excepthook = old_excepthook
2708 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
2709 try:
2709 try:
2710 try:
2710 try:
2711 self.hooks.pre_run_code_hook()
2711 self.hooks.pre_run_code_hook()
2712 #rprint('Running code', repr(code_obj)) # dbg
2712 #rprint('Running code', repr(code_obj)) # dbg
2713 exec code_obj in self.user_global_ns, self.user_ns
2713 exec code_obj in self.user_global_ns, self.user_ns
2714 finally:
2714 finally:
2715 # Reset our crash handler in place
2715 # Reset our crash handler in place
2716 sys.excepthook = old_excepthook
2716 sys.excepthook = old_excepthook
2717 except SystemExit:
2717 except SystemExit:
2718 self.showtraceback(exception_only=True)
2718 self.showtraceback(exception_only=True)
2719 warn("To exit: use 'exit', 'quit', or Ctrl-D.", level=1)
2719 warn("To exit: use 'exit', 'quit', or Ctrl-D.", level=1)
2720 except self.custom_exceptions:
2720 except self.custom_exceptions:
2721 etype,value,tb = sys.exc_info()
2721 etype,value,tb = sys.exc_info()
2722 self.CustomTB(etype,value,tb)
2722 self.CustomTB(etype,value,tb)
2723 except:
2723 except:
2724 self.showtraceback()
2724 self.showtraceback()
2725 else:
2725 else:
2726 outflag = 0
2726 outflag = 0
2727 return outflag
2727 return outflag
2728
2728
2729 # For backwards compatibility
2729 # For backwards compatibility
2730 runcode = run_code
2730 runcode = run_code
2731
2731
2732 #-------------------------------------------------------------------------
2732 #-------------------------------------------------------------------------
2733 # Things related to GUI support and pylab
2733 # Things related to GUI support and pylab
2734 #-------------------------------------------------------------------------
2734 #-------------------------------------------------------------------------
2735
2735
2736 def enable_gui(self, gui=None):
2736 def enable_gui(self, gui=None):
2737 raise NotImplementedError('Implement enable_gui in a subclass')
2737 raise NotImplementedError('Implement enable_gui in a subclass')
2738
2738
2739 def enable_pylab(self, gui=None, import_all=True):
2739 def enable_pylab(self, gui=None, import_all=True):
2740 """Activate pylab support at runtime.
2740 """Activate pylab support at runtime.
2741
2741
2742 This turns on support for matplotlib, preloads into the interactive
2742 This turns on support for matplotlib, preloads into the interactive
2743 namespace all of numpy and pylab, and configures IPython to correctly
2743 namespace all of numpy and pylab, and configures IPython to correctly
2744 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
2745 optionally selected with the optional :param:`gui` argument.
2745 optionally selected with the optional :param:`gui` argument.
2746
2746
2747 Parameters
2747 Parameters
2748 ----------
2748 ----------
2749 gui : optional, string
2749 gui : optional, string
2750
2750
2751 If given, dictates the choice of matplotlib GUI backend to use
2751 If given, dictates the choice of matplotlib GUI backend to use
2752 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
2752 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
2753 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
2753 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
2754 matplotlib (as dictated by the matplotlib build-time options plus the
2754 matplotlib (as dictated by the matplotlib build-time options plus the
2755 user's matplotlibrc configuration file). Note that not all backends
2755 user's matplotlibrc configuration file). Note that not all backends
2756 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
2757 display figures inline.
2757 display figures inline.
2758 """
2758 """
2759 from IPython.core.pylabtools import mpl_runner
2759 from IPython.core.pylabtools import mpl_runner
2760 # 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
2761 # 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
2762 # 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
2763 # user_ns_hidden with this information.
2763 # user_ns_hidden with this information.
2764 ns = {}
2764 ns = {}
2765 try:
2765 try:
2766 gui = pylab_activate(ns, gui, import_all, self)
2766 gui = pylab_activate(ns, gui, import_all, self)
2767 except KeyError:
2767 except KeyError:
2768 error("Backend %r not supported" % gui)
2768 error("Backend %r not supported" % gui)
2769 return
2769 return
2770 self.user_ns.update(ns)
2770 self.user_ns.update(ns)
2771 self.user_ns_hidden.update(ns)
2771 self.user_ns_hidden.update(ns)
2772 # 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
2773 # plot updates into account
2773 # plot updates into account
2774 self.enable_gui(gui)
2774 self.enable_gui(gui)
2775 self.magics_manager.registry['ExecutionMagics'].default_runner = \
2775 self.magics_manager.registry['ExecutionMagics'].default_runner = \
2776 mpl_runner(self.safe_execfile)
2776 mpl_runner(self.safe_execfile)
2777
2777
2778 #-------------------------------------------------------------------------
2778 #-------------------------------------------------------------------------
2779 # Utilities
2779 # Utilities
2780 #-------------------------------------------------------------------------
2780 #-------------------------------------------------------------------------
2781
2781
2782 def var_expand(self, cmd, depth=0, formatter=DollarFormatter()):
2782 def var_expand(self, cmd, depth=0, formatter=DollarFormatter()):
2783 """Expand python variables in a string.
2783 """Expand python variables in a string.
2784
2784
2785 The depth argument indicates how many frames above the caller should
2785 The depth argument indicates how many frames above the caller should
2786 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.
2787
2787
2788 The global namespace for expansion is always the user's interactive
2788 The global namespace for expansion is always the user's interactive
2789 namespace.
2789 namespace.
2790 """
2790 """
2791 ns = self.user_ns.copy()
2791 ns = self.user_ns.copy()
2792 ns.update(sys._getframe(depth+1).f_locals)
2792 ns.update(sys._getframe(depth+1).f_locals)
2793 ns.pop('self', None)
2793 ns.pop('self', None)
2794 try:
2794 try:
2795 cmd = formatter.format(cmd, **ns)
2795 cmd = formatter.format(cmd, **ns)
2796 except Exception:
2796 except Exception:
2797 # if formatter couldn't format, just let it go untransformed
2797 # if formatter couldn't format, just let it go untransformed
2798 pass
2798 pass
2799 return cmd
2799 return cmd
2800
2800
2801 def mktempfile(self, data=None, prefix='ipython_edit_'):
2801 def mktempfile(self, data=None, prefix='ipython_edit_'):
2802 """Make a new tempfile and return its filename.
2802 """Make a new tempfile and return its filename.
2803
2803
2804 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
2805 filename internally so ipython cleans it up at exit time.
2805 filename internally so ipython cleans it up at exit time.
2806
2806
2807 Optional inputs:
2807 Optional inputs:
2808
2808
2809 - 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
2810 immediately, and the file is closed again."""
2810 immediately, and the file is closed again."""
2811
2811
2812 filename = tempfile.mktemp('.py', prefix)
2812 filename = tempfile.mktemp('.py', prefix)
2813 self.tempfiles.append(filename)
2813 self.tempfiles.append(filename)
2814
2814
2815 if data:
2815 if data:
2816 tmp_file = open(filename,'w')
2816 tmp_file = open(filename,'w')
2817 tmp_file.write(data)
2817 tmp_file.write(data)
2818 tmp_file.close()
2818 tmp_file.close()
2819 return filename
2819 return filename
2820
2820
2821 # TODO: This should be removed when Term is refactored.
2821 # TODO: This should be removed when Term is refactored.
2822 def write(self,data):
2822 def write(self,data):
2823 """Write a string to the default output"""
2823 """Write a string to the default output"""
2824 io.stdout.write(data)
2824 io.stdout.write(data)
2825
2825
2826 # TODO: This should be removed when Term is refactored.
2826 # TODO: This should be removed when Term is refactored.
2827 def write_err(self,data):
2827 def write_err(self,data):
2828 """Write a string to the default error output"""
2828 """Write a string to the default error output"""
2829 io.stderr.write(data)
2829 io.stderr.write(data)
2830
2830
2831 def ask_yes_no(self, prompt, default=None):
2831 def ask_yes_no(self, prompt, default=None):
2832 if self.quiet:
2832 if self.quiet:
2833 return True
2833 return True
2834 return ask_yes_no(prompt,default)
2834 return ask_yes_no(prompt,default)
2835
2835
2836 def show_usage(self):
2836 def show_usage(self):
2837 """Show a usage message"""
2837 """Show a usage message"""
2838 page.page(IPython.core.usage.interactive_usage)
2838 page.page(IPython.core.usage.interactive_usage)
2839
2839
2840 def extract_input_lines(self, range_str, raw=False):
2840 def extract_input_lines(self, range_str, raw=False):
2841 """Return as a string a set of input history slices.
2841 """Return as a string a set of input history slices.
2842
2842
2843 Parameters
2843 Parameters
2844 ----------
2844 ----------
2845 range_str : string
2845 range_str : string
2846 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",
2847 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
2848 arguments as strings. The number before the / is the session
2848 arguments as strings. The number before the / is the session
2849 number: ~n goes n back from the current session.
2849 number: ~n goes n back from the current session.
2850
2850
2851 Optional Parameters:
2851 Optional Parameters:
2852 - 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
2853 true, the raw input history is used instead.
2853 true, the raw input history is used instead.
2854
2854
2855 Note that slices can be called with two notations:
2855 Note that slices can be called with two notations:
2856
2856
2857 N:M -> standard python form, means including items N...(M-1).
2857 N:M -> standard python form, means including items N...(M-1).
2858
2858
2859 N-M -> include items N..M (closed endpoint)."""
2859 N-M -> include items N..M (closed endpoint)."""
2860 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)
2861 return "\n".join(x for _, _, x in lines)
2861 return "\n".join(x for _, _, x in lines)
2862
2862
2863 def find_user_code(self, target, raw=True, py_only=False):
2863 def find_user_code(self, target, raw=True, py_only=False):
2864 """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.
2865
2865
2866 This is mainly used by magic functions.
2866 This is mainly used by magic functions.
2867
2867
2868 Parameters
2868 Parameters
2869 ----------
2869 ----------
2870
2870
2871 target : str
2871 target : str
2872
2872
2873 A string specifying code to retrieve. This will be tried respectively
2873 A string specifying code to retrieve. This will be tried respectively
2874 as: ranges of input history (see %history for syntax), url,
2874 as: ranges of input history (see %history for syntax), url,
2875 correspnding .py file, filename, or an expression evaluating to a
2875 correspnding .py file, filename, or an expression evaluating to a
2876 string or Macro in the user namespace.
2876 string or Macro in the user namespace.
2877
2877
2878 raw : bool
2878 raw : bool
2879 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
2880 retrieval mechanisms.
2880 retrieval mechanisms.
2881
2881
2882 py_only : bool (default False)
2882 py_only : bool (default False)
2883 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
2884 if unicode fails.
2884 if unicode fails.
2885
2885
2886 Returns
2886 Returns
2887 -------
2887 -------
2888 A string of code.
2888 A string of code.
2889
2889
2890 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
2891 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
2892 message.
2892 message.
2893 """
2893 """
2894 code = self.extract_input_lines(target, raw=raw) # Grab history
2894 code = self.extract_input_lines(target, raw=raw) # Grab history
2895 if code:
2895 if code:
2896 return code
2896 return code
2897 utarget = unquote_filename(target)
2897 utarget = unquote_filename(target)
2898 try:
2898 try:
2899 if utarget.startswith(('http://', 'https://')):
2899 if utarget.startswith(('http://', 'https://')):
2900 return openpy.read_py_url(utarget, skip_encoding_cookie=True)
2900 return openpy.read_py_url(utarget, skip_encoding_cookie=True)
2901 except UnicodeDecodeError:
2901 except UnicodeDecodeError:
2902 if not py_only :
2902 if not py_only :
2903 response = urllib.urlopen(target)
2903 response = urllib.urlopen(target)
2904 return response.read().decode('latin1')
2904 return response.read().decode('latin1')
2905 raise ValueError(("'%s' seem to be unreadable.") % utarget)
2905 raise ValueError(("'%s' seem to be unreadable.") % utarget)
2906
2906
2907 potential_target = [target]
2907 potential_target = [target]
2908 try :
2908 try :
2909 potential_target.insert(0,get_py_filename(target))
2909 potential_target.insert(0,get_py_filename(target))
2910 except IOError:
2910 except IOError:
2911 pass
2911 pass
2912
2912
2913 for tgt in potential_target :
2913 for tgt in potential_target :
2914 if os.path.isfile(tgt): # Read file
2914 if os.path.isfile(tgt): # Read file
2915 try :
2915 try :
2916 return openpy.read_py_file(tgt, skip_encoding_cookie=True)
2916 return openpy.read_py_file(tgt, skip_encoding_cookie=True)
2917 except UnicodeDecodeError :
2917 except UnicodeDecodeError :
2918 if not py_only :
2918 if not py_only :
2919 with io_open(tgt,'r', encoding='latin1') as f :
2919 with io_open(tgt,'r', encoding='latin1') as f :
2920 return f.read()
2920 return f.read()
2921 raise ValueError(("'%s' seem to be unreadable.") % target)
2921 raise ValueError(("'%s' seem to be unreadable.") % target)
2922
2922
2923 try: # User namespace
2923 try: # User namespace
2924 codeobj = eval(target, self.user_ns)
2924 codeobj = eval(target, self.user_ns)
2925 except Exception:
2925 except Exception:
2926 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, "
2927 "nor in the user namespace.") % target)
2927 "nor in the user namespace.") % target)
2928 if isinstance(codeobj, basestring):
2928 if isinstance(codeobj, basestring):
2929 return codeobj
2929 return codeobj
2930 elif isinstance(codeobj, Macro):
2930 elif isinstance(codeobj, Macro):
2931 return codeobj.value
2931 return codeobj.value
2932
2932
2933 raise TypeError("%s is neither a string nor a macro." % target,
2933 raise TypeError("%s is neither a string nor a macro." % target,
2934 codeobj)
2934 codeobj)
2935
2935
2936 #-------------------------------------------------------------------------
2936 #-------------------------------------------------------------------------
2937 # Things related to IPython exiting
2937 # Things related to IPython exiting
2938 #-------------------------------------------------------------------------
2938 #-------------------------------------------------------------------------
2939 def atexit_operations(self):
2939 def atexit_operations(self):
2940 """This will be executed at the time of exit.
2940 """This will be executed at the time of exit.
2941
2941
2942 Cleanup operations and saving of persistent data that is done
2942 Cleanup operations and saving of persistent data that is done
2943 unconditionally by IPython should be performed here.
2943 unconditionally by IPython should be performed here.
2944
2944
2945 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
2946 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
2947 code that has the appropriate information, rather than trying to
2947 code that has the appropriate information, rather than trying to
2948 clutter
2948 clutter
2949 """
2949 """
2950 # 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)
2951 # this must be *before* the tempfile cleanup, in case of temporary
2951 # this must be *before* the tempfile cleanup, in case of temporary
2952 # history db
2952 # history db
2953 self.history_manager.end_session()
2953 self.history_manager.end_session()
2954
2954
2955 # Cleanup all tempfiles left around
2955 # Cleanup all tempfiles left around
2956 for tfile in self.tempfiles:
2956 for tfile in self.tempfiles:
2957 try:
2957 try:
2958 os.unlink(tfile)
2958 os.unlink(tfile)
2959 except OSError:
2959 except OSError:
2960 pass
2960 pass
2961
2961
2962 # Clear all user namespaces to release all references cleanly.
2962 # Clear all user namespaces to release all references cleanly.
2963 self.reset(new_session=False)
2963 self.reset(new_session=False)
2964
2964
2965 # Run user hooks
2965 # Run user hooks
2966 self.hooks.shutdown_hook()
2966 self.hooks.shutdown_hook()
2967
2967
2968 def cleanup(self):
2968 def cleanup(self):
2969 self.restore_sys_module_state()
2969 self.restore_sys_module_state()
2970
2970
2971
2971
2972 class InteractiveShellABC(object):
2972 class InteractiveShellABC(object):
2973 """An abstract base class for InteractiveShell."""
2973 """An abstract base class for InteractiveShell."""
2974 __metaclass__ = abc.ABCMeta
2974 __metaclass__ = abc.ABCMeta
2975
2975
2976 InteractiveShellABC.register(InteractiveShell)
2976 InteractiveShellABC.register(InteractiveShell)
General Comments 0
You need to be logged in to leave comments. Login now