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