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