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