ipkernel.py
387 lines
| 14.8 KiB
| text/x-python
|
PythonLexer
Fernando Perez
|
r2598 | #!/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. | ||||
""" | ||||
epatters
|
r2712 | #----------------------------------------------------------------------------- | ||
# Imports | ||||
#----------------------------------------------------------------------------- | ||||
epatters
|
r2641 | # Standard library imports. | ||
Fernando Perez
|
r2598 | import __builtin__ | ||
import sys | ||||
import time | ||||
import traceback | ||||
epatters
|
r2641 | # System library imports. | ||
Fernando Perez
|
r2598 | import zmq | ||
epatters
|
r2641 | # Local imports. | ||
Brian Granger
|
r2759 | from IPython.config.configurable import Configurable | ||
from IPython.utils.traitlets import Instance | ||||
Fernando Perez
|
r2598 | from completer import KernelCompleter | ||
epatters
|
r2778 | from entry_point import base_launch_kernel, make_argument_parser, make_kernel, \ | ||
start_kernel | ||||
epatters
|
r2796 | from iostream import OutStream | ||
epatters
|
r2778 | from session import Session, Message | ||
from zmqshell import ZMQInteractiveShell | ||||
Fernando Perez
|
r2598 | |||
epatters
|
r2712 | #----------------------------------------------------------------------------- | ||
Brian Granger
|
r2754 | # Main kernel class | ||
epatters
|
r2712 | #----------------------------------------------------------------------------- | ||
epatters
|
r2641 | |||
Brian Granger
|
r2759 | class Kernel(Configurable): | ||
epatters
|
r2778 | #--------------------------------------------------------------------------- | ||
# Kernel interface | ||||
#--------------------------------------------------------------------------- | ||||
Brian Granger
|
r2760 | shell = Instance('IPython.core.interactiveshell.InteractiveShellABC') | ||
epatters
|
r2778 | session = Instance(Session) | ||
Brian Granger
|
r2759 | reply_socket = Instance('zmq.Socket') | ||
pub_socket = Instance('zmq.Socket') | ||||
req_socket = Instance('zmq.Socket') | ||||
epatters
|
r2778 | # Maps user-friendly backend names to matplotlib backend identifiers. | ||
_pylab_map = { 'tk': 'TkAgg', | ||||
'gtk': 'GTKAgg', | ||||
'wx': 'WXAgg', | ||||
'qt': 'Qt4Agg', # qt3 not supported | ||||
'qt4': 'Qt4Agg', | ||||
'payload-svg' : \ | ||||
'module://IPython.zmq.pylab.backend_payload_svg' } | ||||
Brian Granger
|
r2759 | def __init__(self, **kwargs): | ||
super(Kernel, self).__init__(**kwargs) | ||||
Brian Granger
|
r2786 | |||
# Initialize the InteractiveShell subclass | ||||
Brian Granger
|
r2773 | self.shell = ZMQInteractiveShell.instance() | ||
Brian Granger
|
r2786 | self.shell.displayhook.session = self.session | ||
self.shell.displayhook.pub_socket = self.pub_socket | ||||
epatters
|
r2778 | |||
Fernando Perez
|
r2838 | # TMP - hack while developing | ||
self.shell._reply_content = None | ||||
Fernando Perez
|
r2598 | # Build dict of handlers for message types | ||
epatters
|
r2612 | msg_types = [ 'execute_request', 'complete_request', | ||
Brian Granger
|
r2794 | 'object_info_request', 'prompt_request', | ||
'history_request' ] | ||||
Fernando Perez
|
r2598 | self.handlers = {} | ||
epatters
|
r2612 | for msg_type in msg_types: | ||
Fernando Perez
|
r2598 | self.handlers[msg_type] = getattr(self, msg_type) | ||
epatters
|
r2778 | def activate_pylab(self, backend=None, import_all=True): | ||
""" Activates pylab in this kernel's namespace. | ||||
Parameters: | ||||
----------- | ||||
backend : str, optional | ||||
A valid backend name. | ||||
import_all : bool, optional | ||||
If true, an 'import *' is done from numpy and pylab. | ||||
""" | ||||
# FIXME: This is adapted from IPython.lib.pylabtools.pylab_activate. | ||||
epatters
|
r2825 | # Common functionality should be refactored. | ||
epatters
|
r2778 | |||
# We must set the desired backend before importing pylab. | ||||
import matplotlib | ||||
if backend: | ||||
backend_id = self._pylab_map[backend] | ||||
if backend_id.startswith('module://'): | ||||
# Work around bug in matplotlib: matplotlib.use converts the | ||||
# backend_id to lowercase even if a module name is specified! | ||||
matplotlib.rcParams['backend'] = backend_id | ||||
else: | ||||
matplotlib.use(backend_id) | ||||
# Import numpy as np/pyplot as plt are conventions we're trying to | ||||
# somewhat standardize on. Making them available to users by default | ||||
# will greatly help this. | ||||
exec ("import numpy\n" | ||||
"import matplotlib\n" | ||||
"from matplotlib import pylab, mlab, pyplot\n" | ||||
"np = numpy\n" | ||||
"plt = pyplot\n" | ||||
) in self.shell.user_ns | ||||
if import_all: | ||||
exec("from matplotlib.pylab import *\n" | ||||
"from numpy import *\n") in self.shell.user_ns | ||||
matplotlib.interactive(True) | ||||
def start(self): | ||||
""" Start the kernel main loop. | ||||
""" | ||||
Fernando Perez
|
r2598 | while True: | ||
epatters
|
r2778 | ident = self.reply_socket.recv() | ||
assert self.reply_socket.rcvmore(), "Missing message part." | ||||
msg = self.reply_socket.recv_json() | ||||
omsg = Message(msg) | ||||
print>>sys.__stdout__ | ||||
print>>sys.__stdout__, omsg | ||||
handler = self.handlers.get(omsg.msg_type, None) | ||||
if handler is None: | ||||
print >> sys.__stderr__, "UNKNOWN MESSAGE TYPE:", omsg | ||||
Fernando Perez
|
r2598 | else: | ||
epatters
|
r2778 | handler(ident, omsg) | ||
#--------------------------------------------------------------------------- | ||||
# Kernel request handlers | ||||
#--------------------------------------------------------------------------- | ||||
Fernando Perez
|
r2598 | |||
def execute_request(self, ident, parent): | ||||
try: | ||||
code = parent[u'content'][u'code'] | ||||
except: | ||||
print>>sys.__stderr__, "Got bad msg: " | ||||
print>>sys.__stderr__, Message(parent) | ||||
return | ||||
pyin_msg = self.session.msg(u'pyin',{u'code':code}, parent=parent) | ||||
self.pub_socket.send_json(pyin_msg) | ||||
epatters
|
r2722 | |||
Fernando Perez
|
r2598 | try: | ||
epatters
|
r2730 | # Replace raw_input. Note that is not sufficient to replace | ||
# raw_input in the user namespace. | ||||
epatters
|
r2778 | raw_input = lambda prompt='': self._raw_input(prompt, ident, parent) | ||
epatters
|
r2730 | __builtin__.raw_input = raw_input | ||
epatters
|
r2824 | # Set the parent message of the display hook and out streams. | ||
Brian Granger
|
r2786 | self.shell.displayhook.set_parent(parent) | ||
epatters
|
r2824 | sys.stdout.set_parent(parent) | ||
sys.stderr.set_parent(parent) | ||||
epatters
|
r2730 | |||
Fernando Perez
|
r2838 | # FIXME: runlines calls the exception handler itself. We should | ||
# clean this up. | ||||
self.shell._reply_content = None | ||||
Brian Granger
|
r2759 | self.shell.runlines(code) | ||
Fernando Perez
|
r2598 | except: | ||
Fernando Perez
|
r2838 | # 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. | ||||
Fernando Perez
|
r2598 | etype, evalue, tb = sys.exc_info() | ||
Fernando Perez
|
r2838 | tb_list = traceback.format_exception(etype, evalue, tb) | ||
reply_content = self.shell._showtraceback(etype, evalue, tb_list) | ||||
Fernando Perez
|
r2598 | else: | ||
Brian Granger
|
r2814 | payload = self.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. | ||||
self.shell.payload_manager.clear_payload() | ||||
reply_content = { 'status' : 'ok', 'payload' : payload } | ||||
Brian Granger
|
r2791 | |||
# Compute the prompt information | ||||
prompt_number = self.shell.displayhook.prompt_count | ||||
reply_content['prompt_number'] = prompt_number | ||||
prompt_string = self.shell.displayhook.prompt1.peek_next_prompt() | ||||
next_prompt = {'prompt_string' : prompt_string, | ||||
Brian Granger
|
r2803 | 'prompt_number' : prompt_number+1, | ||
'input_sep' : self.shell.displayhook.input_sep} | ||||
Brian Granger
|
r2791 | reply_content['next_prompt'] = next_prompt | ||
Fernando Perez
|
r2838 | # TMP - fish exception info out of shell, possibly left there by | ||
# runlines | ||||
if self.shell._reply_content is not None: | ||||
reply_content.update(self.shell._reply_content) | ||||
epatters
|
r2722 | # Flush output before sending the reply. | ||
sys.stderr.flush() | ||||
sys.stdout.flush() | ||||
# Send the reply. | ||||
Fernando Perez
|
r2598 | reply_msg = self.session.msg(u'execute_reply', reply_content, parent) | ||
print>>sys.__stdout__, Message(reply_msg) | ||||
self.reply_socket.send(ident, zmq.SNDMORE) | ||||
self.reply_socket.send_json(reply_msg) | ||||
if reply_msg['content']['status'] == u'error': | ||||
epatters
|
r2778 | self._abort_queue() | ||
def complete_request(self, ident, parent): | ||||
matches = {'matches' : self._complete(parent), | ||||
'status' : 'ok'} | ||||
completion_msg = self.session.send(self.reply_socket, 'complete_reply', | ||||
matches, parent, ident) | ||||
print >> sys.__stdout__, completion_msg | ||||
def object_info_request(self, ident, parent): | ||||
context = parent['content']['oname'].split('.') | ||||
object_info = self._object_info(context) | ||||
msg = self.session.send(self.reply_socket, 'object_info_reply', | ||||
object_info, parent, ident) | ||||
print >> sys.__stdout__, msg | ||||
epatters
|
r2795 | |||
def prompt_request(self, ident, parent): | ||||
prompt_number = self.shell.displayhook.prompt_count | ||||
prompt_string = self.shell.displayhook.prompt1.peek_next_prompt() | ||||
content = {'prompt_string' : prompt_string, | ||||
'prompt_number' : prompt_number+1} | ||||
msg = self.session.send(self.reply_socket, 'prompt_reply', | ||||
content, parent, ident) | ||||
print >> sys.__stdout__, msg | ||||
Fernando Perez
|
r2598 | |||
epatters
|
r2795 | def history_request(self, ident, parent): | ||
output = parent['content'].get('output', True) | ||||
index = parent['content'].get('index') | ||||
raw = parent['content'].get('raw', False) | ||||
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) | ||||
print >> sys.__stdout__, msg | ||||
epatters
|
r2778 | |||
#--------------------------------------------------------------------------- | ||||
# Protected interface | ||||
#--------------------------------------------------------------------------- | ||||
Fernando Perez
|
r2598 | |||
epatters
|
r2778 | 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() | ||||
print>>sys.__stdout__, "Aborting:" | ||||
print>>sys.__stdout__, Message(msg) | ||||
msg_type = msg['msg_type'] | ||||
reply_type = msg_type.split('_')[0] + '_reply' | ||||
reply_msg = self.session.msg(reply_type, {'status' : 'aborted'}, msg) | ||||
print>>sys.__stdout__, Message(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): | ||||
epatters
|
r2730 | # 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: | ||||
print>>sys.__stderr__, "Got bad raw_input reply: " | ||||
print>>sys.__stderr__, Message(parent) | ||||
value = '' | ||||
return value | ||||
epatters
|
r2778 | |||
def _complete(self, msg): | ||||
Brian Granger
|
r2759 | return self.shell.complete(msg.content.line) | ||
Fernando Perez
|
r2598 | |||
epatters
|
r2778 | def _object_info(self, context): | ||
symbol, leftover = self._symbol_from_context(context) | ||||
epatters
|
r2612 | if symbol is not None and not leftover: | ||
doc = getattr(symbol, '__doc__', '') | ||||
else: | ||||
doc = '' | ||||
object_info = dict(docstring = doc) | ||||
return object_info | ||||
epatters
|
r2778 | def _symbol_from_context(self, context): | ||
epatters
|
r2612 | if not context: | ||
return None, context | ||||
base_symbol_string = context[0] | ||||
Brian Granger
|
r2759 | symbol = self.shell.user_ns.get(base_symbol_string, None) | ||
epatters
|
r2612 | 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, [] | ||||
epatters
|
r2712 | #----------------------------------------------------------------------------- | ||
# Kernel main and launch functions | ||||
#----------------------------------------------------------------------------- | ||||
epatters
|
r2778 | def launch_kernel(xrep_port=0, pub_port=0, req_port=0, independent=False, | ||
pylab=False): | ||||
epatters
|
r2700 | """ 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 | ||||
epatters
|
r2702 | The port to use for the SUB channel. | ||
req_port : int, optional | ||||
The port to use for the REQ (raw input) channel. | ||||
epatters
|
r2641 | |||
epatters
|
r2700 | 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 | ||||
epatters
|
r2712 | to kill kernels manually before exiting. | ||
epatters
|
r2700 | |||
epatters
|
r2778 | 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. | ||||
epatters
|
r2700 | Returns | ||
------- | ||||
A tuple of form: | ||||
epatters
|
r2702 | (kernel_process, xrep_port, pub_port, req_port) | ||
where kernel_process is a Popen object and the ports are integers. | ||||
epatters
|
r2641 | """ | ||
epatters
|
r2778 | 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, independent, | ||||
extra_arguments) | ||||
epatters
|
r2700 | |||
epatters
|
r2778 | 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() | ||||
epatters
|
r2796 | kernel = make_kernel(namespace, Kernel, OutStream) | ||
epatters
|
r2778 | if namespace.pylab: | ||
if namespace.pylab == 'auto': | ||||
kernel.activate_pylab() | ||||
else: | ||||
kernel.activate_pylab(namespace.pylab) | ||||
epatters
|
r2667 | |||
epatters
|
r2778 | start_kernel(namespace, kernel) | ||
Fernando Perez
|
r2598 | |||
if __name__ == '__main__': | ||||
epatters
|
r2667 | main() | ||