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