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