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