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