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