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