/
ipkernel.py
executable file
·487 lines (406 loc) · 17.7 KB
/
ipkernel.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
#!/usr/bin/env python
"""A simple interactive kernel that talks to a frontend over 0MQ.
Things to do:
* Implement `set_parent` logic. Right before doing exec, the Kernel should
call set_parent on all the PUB objects with the message about to be executed.
* Implement random port and security key logic.
* Implement control messages.
* Implement event loop and poll version.
"""
#-----------------------------------------------------------------------------
# Imports
#-----------------------------------------------------------------------------
from __future__ import print_function
# Standard library imports.
import __builtin__
import sys
import time
import traceback
# System library imports.
import zmq
# Local imports.
from IPython.config.configurable import Configurable
from IPython.utils import io
from IPython.lib import pylabtools
from IPython.utils.traitlets import Instance
from entry_point import base_launch_kernel, make_argument_parser, make_kernel, \
start_kernel
from iostream import OutStream
from session import Session, Message
from zmqshell import ZMQInteractiveShell
#-----------------------------------------------------------------------------
# Main kernel class
#-----------------------------------------------------------------------------
class Kernel(Configurable):
#---------------------------------------------------------------------------
# Kernel interface
#---------------------------------------------------------------------------
shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
session = Instance(Session)
reply_socket = Instance('zmq.Socket')
pub_socket = Instance('zmq.Socket')
req_socket = Instance('zmq.Socket')
def __init__(self, **kwargs):
super(Kernel, self).__init__(**kwargs)
# Initialize the InteractiveShell subclass
self.shell = ZMQInteractiveShell.instance()
self.shell.displayhook.session = self.session
self.shell.displayhook.pub_socket = self.pub_socket
# TMP - hack while developing
self.shell._reply_content = None
# Build dict of handlers for message types
msg_types = [ 'execute_request', 'complete_request',
'object_info_request', 'history_request' ]
self.handlers = {}
for msg_type in msg_types:
self.handlers[msg_type] = getattr(self, msg_type)
def do_one_iteration(self):
try:
ident = self.reply_socket.recv(zmq.NOBLOCK)
except zmq.ZMQError, e:
if e.errno == zmq.EAGAIN:
return
else:
raise
# FIXME: Bug in pyzmq/zmq?
# assert self.reply_socket.rcvmore(), "Missing message part."
msg = self.reply_socket.recv_json()
# Print some info about this message and leave a '--->' marker, so it's
# easier to trace visually the message chain when debugging. Each
# handler prints its message at the end.
# Eventually we'll move these from stdout to a logger.
io.raw_print('\n*** MESSAGE TYPE:', msg['msg_type'], '***')
io.raw_print(' Content: ', msg['content'],
'\n --->\n ', sep='', end='')
# Find and call actual handler for message
handler = self.handlers.get(msg['msg_type'], None)
if handler is None:
io.raw_print_err("UNKNOWN MESSAGE TYPE:", msg)
else:
handler(ident, msg)
def start(self):
""" Start the kernel main loop.
"""
while True:
time.sleep(0.05)
self.do_one_iteration()
#---------------------------------------------------------------------------
# Kernel request handlers
#---------------------------------------------------------------------------
def _publish_pyin(self, code, parent):
"""Publish the code request on the pyin stream."""
pyin_msg = self.session.msg(u'pyin',{u'code':code}, parent=parent)
self.pub_socket.send_json(pyin_msg)
def execute_request(self, ident, parent):
try:
content = parent[u'content']
code = content[u'code']
silent = content[u'silent']
except:
io.raw_print_err("Got bad msg: ")
io.raw_print_err(Message(parent))
return
shell = self.shell # we'll need this a lot here
# Replace raw_input. Note that is not sufficient to replace
# raw_input in the user namespace.
raw_input = lambda prompt='': self._raw_input(prompt, ident, parent)
__builtin__.raw_input = raw_input
# Set the parent message of the display hook and out streams.
shell.displayhook.set_parent(parent)
sys.stdout.set_parent(parent)
sys.stderr.set_parent(parent)
# Re-broadcast our input for the benefit of listening clients, and
# start computing output
if not silent:
self._publish_pyin(code, parent)
reply_content = {}
try:
if silent:
# runcode uses 'exec' mode, so no displayhook will fire, and it
# doesn't call logging or history manipulations. Print
# statements in that code will obviously still execute.
shell.runcode(code)
else:
# FIXME: runlines calls the exception handler itself.
shell._reply_content = None
shell.runlines(code)
except:
status = u'error'
# FIXME: this code right now isn't being used yet by default,
# because the runlines() call above directly fires off exception
# reporting. This code, therefore, is only active in the scenario
# where runlines itself has an unhandled exception. We need to
# uniformize this, for all exception construction to come from a
# single location in the codbase.
etype, evalue, tb = sys.exc_info()
tb_list = traceback.format_exception(etype, evalue, tb)
reply_content.update(shell._showtraceback(etype, evalue, tb_list))
else:
status = u'ok'
reply_content[u'payload'] = shell.payload_manager.read_payload()
# Be agressive about clearing the payload because we don't want
# it to sit in memory until the next execute_request comes in.
shell.payload_manager.clear_payload()
reply_content[u'status'] = status
# Compute the execution counter so clients can display prompts
reply_content['execution_count'] = shell.displayhook.prompt_count
# FIXME - fish exception info out of shell, possibly left there by
# runlines. We'll need to clean up this logic later.
if shell._reply_content is not None:
reply_content.update(shell._reply_content)
# At this point, we can tell whether the main code execution succeeded
# or not. If it did, we proceed to evaluate user_variables/expressions
if reply_content['status'] == 'ok':
reply_content[u'user_variables'] = \
shell.get_user_variables(content[u'user_variables'])
reply_content[u'user_expressions'] = \
shell.eval_expressions(content[u'user_expressions'])
else:
# If there was an error, don't even try to compute variables or
# expressions
reply_content[u'user_variables'] = {}
reply_content[u'user_expressions'] = {}
# Send the reply.
reply_msg = self.session.msg(u'execute_reply', reply_content, parent)
io.raw_print(reply_msg)
self.reply_socket.send(ident, zmq.SNDMORE)
self.reply_socket.send_json(reply_msg)
if reply_msg['content']['status'] == u'error':
self._abort_queue()
def complete_request(self, ident, parent):
txt, matches = self._complete(parent)
matches = {'matches' : matches,
'matched_text' : txt,
'status' : 'ok'}
completion_msg = self.session.send(self.reply_socket, 'complete_reply',
matches, parent, ident)
io.raw_print(completion_msg)
def object_info_request(self, ident, parent):
##context = parent['content']['oname'].split('.')
##object_info = self._object_info(context)
object_info = self.shell.object_inspect(parent['content']['oname'])
msg = self.session.send(self.reply_socket, 'object_info_reply',
object_info._asdict(), parent, ident)
io.raw_print(msg)
def history_request(self, ident, parent):
output = parent['content']['output']
index = parent['content']['index']
raw = parent['content']['raw']
hist = self.shell.get_history(index=index, raw=raw, output=output)
content = {'history' : hist}
msg = self.session.send(self.reply_socket, 'history_reply',
content, parent, ident)
io.raw_print(msg)
#---------------------------------------------------------------------------
# Protected interface
#---------------------------------------------------------------------------
def _abort_queue(self):
while True:
try:
ident = self.reply_socket.recv(zmq.NOBLOCK)
except zmq.ZMQError, e:
if e.errno == zmq.EAGAIN:
break
else:
assert self.reply_socket.rcvmore(), \
"Unexpected missing message part."
msg = self.reply_socket.recv_json()
io.raw_print("Aborting:\n", Message(msg))
msg_type = msg['msg_type']
reply_type = msg_type.split('_')[0] + '_reply'
reply_msg = self.session.msg(reply_type, {'status' : 'aborted'}, msg)
io.raw_print(reply_msg)
self.reply_socket.send(ident,zmq.SNDMORE)
self.reply_socket.send_json(reply_msg)
# We need to wait a bit for requests to come in. This can probably
# be set shorter for true asynchronous clients.
time.sleep(0.1)
def _raw_input(self, prompt, ident, parent):
# Flush output before making the request.
sys.stderr.flush()
sys.stdout.flush()
# Send the input request.
content = dict(prompt=prompt)
msg = self.session.msg(u'input_request', content, parent)
self.req_socket.send_json(msg)
# Await a response.
reply = self.req_socket.recv_json()
try:
value = reply['content']['value']
except:
io.raw_print_err("Got bad raw_input reply: ")
io.raw_print_err(Message(parent))
value = ''
return value
def _complete(self, msg):
c = msg['content']
try:
cpos = int(c['cursor_pos'])
except:
# If we don't get something that we can convert to an integer, at
# least attempt the completion guessing the cursor is at the end of
# the text, if there's any, and otherwise of the line
cpos = len(c['text'])
if cpos==0:
cpos = len(c['line'])
return self.shell.complete(c['text'], c['line'], cpos)
def _object_info(self, context):
symbol, leftover = self._symbol_from_context(context)
if symbol is not None and not leftover:
doc = getattr(symbol, '__doc__', '')
else:
doc = ''
object_info = dict(docstring = doc)
return object_info
def _symbol_from_context(self, context):
if not context:
return None, context
base_symbol_string = context[0]
symbol = self.shell.user_ns.get(base_symbol_string, None)
if symbol is None:
symbol = __builtin__.__dict__.get(base_symbol_string, None)
if symbol is None:
return None, context
context = context[1:]
for i, name in enumerate(context):
new_symbol = getattr(symbol, name, None)
if new_symbol is None:
return symbol, context[i:]
else:
symbol = new_symbol
return symbol, []
class QtKernel(Kernel):
"""A Kernel subclass with Qt support."""
def start(self):
"""Start a kernel with QtPy4 event loop integration."""
from PyQt4 import QtGui, QtCore
from IPython.lib.guisupport import (
get_app_qt4, start_event_loop_qt4
)
self.app = get_app_qt4([" "])
self.app.setQuitOnLastWindowClosed(False)
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.do_one_iteration)
self.timer.start(50)
start_event_loop_qt4(self.app)
class WxKernel(Kernel):
"""A Kernel subclass with Wx support."""
def start(self):
"""Start a kernel with wx event loop support."""
import wx
from IPython.lib.guisupport import start_event_loop_wx
doi = self.do_one_iteration
# We have to put the wx.Timer in a wx.Frame for it to fire properly.
# We make the Frame hidden when we create it in the main app below.
class TimerFrame(wx.Frame):
def __init__(self, func):
wx.Frame.__init__(self, None, -1)
self.timer = wx.Timer(self)
self.timer.Start(50)
self.Bind(wx.EVT_TIMER, self.on_timer)
self.func = func
def on_timer(self, event):
self.func()
# We need a custom wx.App to create our Frame subclass that has the
# wx.Timer to drive the ZMQ event loop.
class IPWxApp(wx.App):
def OnInit(self):
self.frame = TimerFrame(doi)
self.frame.Show(False)
return True
# The redirect=False here makes sure that wx doesn't replace
# sys.stdout/stderr with its own classes.
self.app = IPWxApp(redirect=False)
start_event_loop_wx(self.app)
class TkKernel(Kernel):
"""A Kernel subclass with Tk support."""
def start(self):
"""Start a Tk enabled event loop."""
import Tkinter
doi = self.do_one_iteration
# For Tkinter, we create a Tk object and call its withdraw method.
class Timer(object):
def __init__(self, func):
self.app = Tkinter.Tk()
self.app.withdraw()
self.func = func
def on_timer(self):
self.func()
self.app.after(50, self.on_timer)
def start(self):
self.on_timer() # Call it once to get things going.
self.app.mainloop()
self.timer = Timer(doi)
self.timer.start()
#-----------------------------------------------------------------------------
# Kernel main and launch functions
#-----------------------------------------------------------------------------
def launch_kernel(xrep_port=0, pub_port=0, req_port=0, hb_port=0,
independent=False, pylab=False):
""" Launches a localhost kernel, binding to the specified ports.
Parameters
----------
xrep_port : int, optional
The port to use for XREP channel.
pub_port : int, optional
The port to use for the SUB channel.
req_port : int, optional
The port to use for the REQ (raw input) channel.
hb_port : int, optional
The port to use for the hearbeat REP channel.
independent : bool, optional (default False)
If set, the kernel process is guaranteed to survive if this process
dies. If not set, an effort is made to ensure that the kernel is killed
when this process dies. Note that in this case it is still good practice
to kill kernels manually before exiting.
pylab : bool or string, optional (default False)
If not False, the kernel will be launched with pylab enabled. If a
string is passed, matplotlib will use the specified backend. Otherwise,
matplotlib's default backend will be used.
Returns
-------
A tuple of form:
(kernel_process, xrep_port, pub_port, req_port)
where kernel_process is a Popen object and the ports are integers.
"""
extra_arguments = []
if pylab:
extra_arguments.append('--pylab')
if isinstance(pylab, basestring):
extra_arguments.append(pylab)
return base_launch_kernel('from IPython.zmq.ipkernel import main; main()',
xrep_port, pub_port, req_port, hb_port,
independent, extra_arguments)
def main():
""" The IPython kernel main entry point.
"""
parser = make_argument_parser()
parser.add_argument('--pylab', type=str, metavar='GUI', nargs='?',
const='auto', help = \
"Pre-load matplotlib and numpy for interactive use. If GUI is not \
given, the GUI backend is matplotlib's, otherwise use one of: \
['tk', 'gtk', 'qt', 'wx', 'payload-svg'].")
namespace = parser.parse_args()
kernel_class = Kernel
_kernel_classes = {
'qt' : QtKernel,
'qt4' : QtKernel,
'payload-svg': Kernel,
'wx' : WxKernel,
'tk' : TkKernel
}
if namespace.pylab:
if namespace.pylab == 'auto':
gui, backend = pylabtools.find_gui_and_backend()
else:
gui, backend = pylabtools.find_gui_and_backend(namespace.pylab)
kernel_class = _kernel_classes.get(gui)
if kernel_class is None:
raise ValueError('GUI is not supported: %r' % gui)
pylabtools.activate_matplotlib(backend)
kernel = make_kernel(namespace, kernel_class, OutStream)
if namespace.pylab:
pylabtools.import_pylab(kernel.shell.user_ns)
start_kernel(namespace, kernel)
if __name__ == '__main__':
main()