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