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