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