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