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