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