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