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