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