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