ipkernel.py
580 lines
| 21.5 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 | ||||
#----------------------------------------------------------------------------- | ||||
Fernando Perez
|
r2856 | from __future__ import print_function | ||
epatters
|
r2712 | |||
epatters
|
r2641 | # Standard library imports. | ||
Fernando Perez
|
r2598 | import __builtin__ | ||
Fernando Perez
|
r2972 | import atexit | ||
Fernando Perez
|
r2598 | 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 | ||
Fernando Perez
|
r2856 | from IPython.utils import io | ||
Fernando Perez
|
r2948 | from IPython.utils.jsonutil import json_clean | ||
Brian Granger
|
r2868 | from IPython.lib import pylabtools | ||
Fernando Perez
|
r2940 | from IPython.utils.traitlets import Instance, Float | ||
Fernando Perez
|
r2972 | 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') | ||||
Fernando Perez
|
r2940 | # Private interface | ||
# Time to sleep after flushing the stdout/err buffers in each execute | ||||
# cycle. While this introduces a hard limit on the minimal latency of the | ||||
# execute cycle, it helps prevent output synchronization problems for | ||||
# clients. | ||||
# Units are in seconds. The minimum zmq latency on local host is probably | ||||
# ~150 microseconds, set this to 500us for now. We may need to increase it | ||||
# a little if it's not enough after more interactive testing. | ||||
_execute_sleep = Float(0.0005, config=True) | ||||
# Frequency of the kernel's event loop. | ||||
# Units are in seconds, kernel subclasses for GUI toolkits may need to | ||||
# adapt to milliseconds. | ||||
_poll_interval = Float(0.05, config=True) | ||||
Fernando Perez
|
r2972 | |||
# If the shutdown was requested over the network, we leave here the | ||||
# necessary reply message so it can be sent by our registered atexit | ||||
# handler. This ensures that the reply is only sent to clients truly at | ||||
# the end of our shutdown process (which happens after the underlying | ||||
# IPython shell's own shutdown). | ||||
_shutdown_message = None | ||||
Fernando Perez
|
r2940 | |||
Brian Granger
|
r2759 | def __init__(self, **kwargs): | ||
super(Kernel, self).__init__(**kwargs) | ||||
Brian Granger
|
r2786 | |||
Fernando Perez
|
r2972 | # Before we even start up the shell, register *first* our exit handlers | ||
# so they come before the shell's | ||||
atexit.register(self._at_shutdown) | ||||
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', | ||
Fernando Perez
|
r2972 | 'object_info_request', 'history_request', | ||
'shutdown_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) | ||
Brian Granger
|
r2868 | def do_one_iteration(self): | ||
Fernando Perez
|
r2949 | """Do one iteration of the kernel's evaluation loop. | ||
""" | ||||
Brian Granger
|
r2868 | try: | ||
ident = self.reply_socket.recv(zmq.NOBLOCK) | ||||
except zmq.ZMQError, e: | ||||
if e.errno == zmq.EAGAIN: | ||||
return | ||||
epatters
|
r2778 | else: | ||
Brian Granger
|
r2868 | raise | ||
# FIXME: Bug in pyzmq/zmq? | ||||
# assert self.reply_socket.rcvmore(), "Missing message part." | ||||
msg = self.reply_socket.recv_json() | ||||
Fernando Perez
|
r2926 | |||
# 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) | ||||
Brian Granger
|
r2868 | if handler is None: | ||
Fernando Perez
|
r2926 | io.raw_print_err("UNKNOWN MESSAGE TYPE:", msg) | ||
Brian Granger
|
r2868 | else: | ||
Fernando Perez
|
r2926 | handler(ident, msg) | ||
Fernando Perez
|
r2950 | |||
# Check whether we should exit, in case the incoming message set the | ||||
# exit flag on | ||||
if self.shell.exit_now: | ||||
io.raw_print('\nExiting IPython kernel...') | ||||
# We do a normal, clean exit, which allows any actions registered | ||||
# via atexit (such as history saving) to take place. | ||||
sys.exit(0) | ||||
epatters
|
r2778 | |||
def start(self): | ||||
""" Start the kernel main loop. | ||||
""" | ||||
Fernando Perez
|
r2598 | while True: | ||
Fernando Perez
|
r2940 | time.sleep(self._poll_interval) | ||
Brian Granger
|
r2868 | self.do_one_iteration() | ||
Fernando Perez
|
r2950 | |||
epatters
|
r2778 | #--------------------------------------------------------------------------- | ||
# Kernel request handlers | ||||
#--------------------------------------------------------------------------- | ||||
Fernando Perez
|
r2598 | |||
Fernando Perez
|
r2926 | 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) | ||||
Fernando Perez
|
r2598 | def execute_request(self, ident, parent): | ||
try: | ||||
Fernando Perez
|
r2926 | content = parent[u'content'] | ||
code = content[u'code'] | ||||
silent = content[u'silent'] | ||||
Fernando Perez
|
r2598 | except: | ||
Fernando Perez
|
r2875 | io.raw_print_err("Got bad msg: ") | ||
io.raw_print_err(Message(parent)) | ||||
Fernando Perez
|
r2598 | return | ||
epatters
|
r2722 | |||
Fernando Perez
|
r2926 | 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 = {} | ||||
Fernando Perez
|
r2598 | try: | ||
Fernando Perez
|
r2926 | 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 | ||||
Fernando Perez
|
r2967 | |||
# Experimental: cell mode! Test more before turning into | ||||
# default and removing the hacks around runlines. | ||||
shell.run_cell(code) | ||||
# For now leave this here until we're sure we can stop using it | ||||
#shell.runlines(code) | ||||
Fernando Perez
|
r2598 | except: | ||
Fernando Perez
|
r2926 | status = u'error' | ||
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) | ||
Fernando Perez
|
r2926 | reply_content.update(shell._showtraceback(etype, evalue, tb_list)) | ||
Fernando Perez
|
r2598 | else: | ||
Fernando Perez
|
r2926 | status = u'ok' | ||
reply_content[u'payload'] = shell.payload_manager.read_payload() | ||||
Brian Granger
|
r2814 | # Be agressive about clearing the payload because we don't want | ||
# it to sit in memory until the next execute_request comes in. | ||||
Fernando Perez
|
r2926 | 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'] = {} | ||||
epatters
|
r2722 | # Send the reply. | ||
Fernando Perez
|
r2598 | reply_msg = self.session.msg(u'execute_reply', reply_content, parent) | ||
Fernando Perez
|
r2926 | io.raw_print(reply_msg) | ||
Fernando Perez
|
r2938 | |||
# Flush output before sending the reply. | ||||
sys.stdout.flush() | ||||
sys.stderr.flush() | ||||
# FIXME: on rare occasions, the flush doesn't seem to make it to the | ||||
# clients... This seems to mitigate the problem, but we definitely need | ||||
# to better understand what's going on. | ||||
Fernando Perez
|
r2940 | if self._execute_sleep: | ||
time.sleep(self._execute_sleep) | ||||
Fernando Perez
|
r2938 | |||
Fernando Perez
|
r2598 | 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): | ||||
Fernando Perez
|
r2856 | txt, matches = self._complete(parent) | ||
matches = {'matches' : matches, | ||||
'matched_text' : txt, | ||||
epatters
|
r2778 | 'status' : 'ok'} | ||
completion_msg = self.session.send(self.reply_socket, 'complete_reply', | ||||
matches, parent, ident) | ||||
Fernando Perez
|
r2875 | io.raw_print(completion_msg) | ||
epatters
|
r2778 | |||
def object_info_request(self, ident, parent): | ||||
Fernando Perez
|
r2931 | object_info = self.shell.object_inspect(parent['content']['oname']) | ||
Fernando Perez
|
r2948 | # Before we send this object over, we turn it into a dict and we scrub | ||
# it for JSON usage | ||||
oinfo = json_clean(object_info._asdict()) | ||||
epatters
|
r2778 | msg = self.session.send(self.reply_socket, 'object_info_reply', | ||
Fernando Perez
|
r2948 | oinfo, parent, ident) | ||
Fernando Perez
|
r2875 | io.raw_print(msg) | ||
epatters
|
r2795 | |||
def history_request(self, ident, parent): | ||||
epatters
|
r2844 | output = parent['content']['output'] | ||
index = parent['content']['index'] | ||||
raw = parent['content']['raw'] | ||||
epatters
|
r2795 | 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) | ||||
Fernando Perez
|
r2875 | io.raw_print(msg) | ||
epatters
|
r2778 | |||
Fernando Perez
|
r2972 | def shutdown_request(self, ident, parent): | ||
self.shell.exit_now = True | ||||
self._shutdown_message = self.session.msg(u'shutdown_reply', {}, parent) | ||||
sys.exit(0) | ||||
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: | ||||
Fernando Perez
|
r2926 | assert self.reply_socket.rcvmore(), \ | ||
"Unexpected missing message part." | ||||
epatters
|
r2778 | msg = self.reply_socket.recv_json() | ||
Fernando Perez
|
r2875 | io.raw_print("Aborting:\n", Message(msg)) | ||
epatters
|
r2778 | msg_type = msg['msg_type'] | ||
reply_type = msg_type.split('_')[0] + '_reply' | ||||
reply_msg = self.session.msg(reply_type, {'status' : 'aborted'}, msg) | ||||
Fernando Perez
|
r2926 | io.raw_print(reply_msg) | ||
epatters
|
r2778 | 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: | ||||
Fernando Perez
|
r2875 | io.raw_print_err("Got bad raw_input reply: ") | ||
io.raw_print_err(Message(parent)) | ||||
epatters
|
r2730 | value = '' | ||
return value | ||||
epatters
|
r2778 | |||
def _complete(self, msg): | ||||
Fernando Perez
|
r2839 | c = msg['content'] | ||
try: | ||||
cpos = int(c['cursor_pos']) | ||||
except: | ||||
# If we don't get something that we can convert to an integer, at | ||||
Fernando Perez
|
r2856 | # least attempt the completion guessing the cursor is at the end of | ||
# the text, if there's any, and otherwise of the line | ||||
Fernando Perez
|
r2839 | cpos = len(c['text']) | ||
Fernando Perez
|
r2856 | if cpos==0: | ||
cpos = len(c['line']) | ||||
Fernando Perez
|
r2839 | return self.shell.complete(c['text'], c['line'], cpos) | ||
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, [] | ||||
Fernando Perez
|
r2972 | def _at_shutdown(self): | ||
"""Actions taken at shutdown by the kernel, called by python's atexit. | ||||
""" | ||||
# io.rprint("Kernel at_shutdown") # dbg | ||||
if self._shutdown_message is not None: | ||||
self.reply_socket.send_json(self._shutdown_message) | ||||
io.raw_print(self._shutdown_message) | ||||
# A very short sleep to give zmq time to flush its message buffers | ||||
# before Python truly shuts down. | ||||
time.sleep(0.01) | ||||
Brian Granger
|
r2868 | |||
class QtKernel(Kernel): | ||||
Brian Granger
|
r2872 | """A Kernel subclass with Qt support.""" | ||
Brian Granger
|
r2868 | |||
def start(self): | ||||
"""Start a kernel with QtPy4 event loop integration.""" | ||||
Brian Granger
|
r2872 | |||
Fernando Perez
|
r2972 | from PyQt4 import QtCore | ||
from IPython.lib.guisupport import get_app_qt4, start_event_loop_qt4 | ||||
Brian Granger
|
r2900 | self.app = get_app_qt4([" "]) | ||
self.app.setQuitOnLastWindowClosed(False) | ||||
Brian Granger
|
r2872 | self.timer = QtCore.QTimer() | ||
self.timer.timeout.connect(self.do_one_iteration) | ||||
Fernando Perez
|
r2940 | # Units for the timer are in milliseconds | ||
self.timer.start(1000*self._poll_interval) | ||||
Brian Granger
|
r2900 | start_event_loop_qt4(self.app) | ||
Brian Granger
|
r2872 | |||
Fernando Perez
|
r2926 | |||
Brian Granger
|
r2872 | class WxKernel(Kernel): | ||
"""A Kernel subclass with Wx support.""" | ||||
Brian Granger
|
r2868 | |||
Brian Granger
|
r2872 | def start(self): | ||
"""Start a kernel with wx event loop support.""" | ||||
import wx | ||||
Brian Granger
|
r2900 | from IPython.lib.guisupport import start_event_loop_wx | ||
Fernando Perez
|
r2972 | |||
Brian Granger
|
r2872 | doi = self.do_one_iteration | ||
Fernando Perez
|
r2949 | # Wx uses milliseconds | ||
poll_interval = int(1000*self._poll_interval) | ||||
Brian Granger
|
r2872 | |||
# 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) | ||||
Fernando Perez
|
r2940 | # Units for the timer are in milliseconds | ||
Fernando Perez
|
r2949 | self.timer.Start(poll_interval) | ||
Brian Granger
|
r2872 | self.Bind(wx.EVT_TIMER, self.on_timer) | ||
self.func = func | ||||
Fernando Perez
|
r2949 | |||
Brian Granger
|
r2872 | 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) | ||||
Brian Granger
|
r2900 | start_event_loop_wx(self.app) | ||
Brian Granger
|
r2872 | |||
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 | ||||
Fernando Perez
|
r2949 | # Tk uses milliseconds | ||
poll_interval = int(1000*self._poll_interval) | ||||
Brian Granger
|
r2872 | # 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 | ||||
Fernando Perez
|
r2949 | |||
Brian Granger
|
r2872 | def on_timer(self): | ||
self.func() | ||||
Fernando Perez
|
r2949 | self.app.after(poll_interval, self.on_timer) | ||
Brian Granger
|
r2872 | def start(self): | ||
self.on_timer() # Call it once to get things going. | ||||
self.app.mainloop() | ||||
self.timer = Timer(doi) | ||||
self.timer.start() | ||||
Brian Granger
|
r2868 | |||
Fernando Perez
|
r2949 | |||
class GTKKernel(Kernel): | ||||
"""A Kernel subclass with GTK support.""" | ||||
def start(self): | ||||
"""Start the kernel, coordinating with the GTK event loop""" | ||||
from .gui.gtkembed import GTKEmbed | ||||
gtk_kernel = GTKEmbed(self) | ||||
gtk_kernel.start() | ||||
epatters
|
r2712 | #----------------------------------------------------------------------------- | ||
# Kernel main and launch functions | ||||
#----------------------------------------------------------------------------- | ||||
Brian Granger
|
r2910 | def launch_kernel(xrep_port=0, pub_port=0, req_port=0, hb_port=0, | ||
independent=False, pylab=False): | ||||
Fernando Perez
|
r2949 | """Launches a localhost kernel, binding to the specified ports. | ||
epatters
|
r2700 | |||
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 | |||
Brian Granger
|
r2910 | hb_port : int, optional | ||
The port to use for the hearbeat REP channel. | ||||
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()', | ||||
Brian Granger
|
r2910 | xrep_port, pub_port, req_port, hb_port, | ||
independent, extra_arguments) | ||||
epatters
|
r2700 | |||
Fernando Perez
|
r2926 | |||
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() | ||||
Brian Granger
|
r2868 | kernel_class = Kernel | ||
Fernando Perez
|
r2949 | kernel_classes = { | ||
Brian Granger
|
r2868 | 'qt' : QtKernel, | ||
Fernando Perez
|
r2949 | 'qt4': QtKernel, | ||
epatters
|
r2913 | 'payload-svg': Kernel, | ||
Brian Granger
|
r2872 | 'wx' : WxKernel, | ||
Fernando Perez
|
r2949 | 'tk' : TkKernel, | ||
'gtk': GTKKernel, | ||||
Brian Granger
|
r2868 | } | ||
epatters
|
r2778 | if namespace.pylab: | ||
if namespace.pylab == 'auto': | ||||
Brian Granger
|
r2868 | gui, backend = pylabtools.find_gui_and_backend() | ||
epatters
|
r2778 | else: | ||
Brian Granger
|
r2868 | gui, backend = pylabtools.find_gui_and_backend(namespace.pylab) | ||
Fernando Perez
|
r2949 | kernel_class = kernel_classes.get(gui) | ||
Brian Granger
|
r2868 | 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) | ||||
epatters
|
r2778 | start_kernel(namespace, kernel) | ||
Fernando Perez
|
r2598 | |||
Fernando Perez
|
r2926 | |||
Fernando Perez
|
r2598 | if __name__ == '__main__': | ||
epatters
|
r2667 | main() | ||