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