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