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