ipkernel.py
702 lines
| 25.7 KiB
| text/x-python
|
PythonLexer
|
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. | ||||
""" | ||||
|
r2712 | #----------------------------------------------------------------------------- | ||
# Imports | ||||
#----------------------------------------------------------------------------- | ||||
|
r2856 | from __future__ import print_function | ||
|
r2712 | |||
|
r2641 | # Standard library imports. | ||
|
r2598 | import __builtin__ | ||
|
r2972 | import atexit | ||
|
r2598 | import sys | ||
import time | ||||
import traceback | ||||
|
r3294 | import logging | ||
|
r2641 | # System library imports. | ||
|
r2598 | import zmq | ||
|
r2641 | # Local imports. | ||
|
r2759 | from IPython.config.configurable import Configurable | ||
|
r3970 | from IPython.config.application import boolean_flag | ||
|
r4023 | from IPython.core.application import ProfileDir | ||
|
r3979 | from IPython.core.shellapp import ( | ||
InteractiveShellApp, shell_flags, shell_aliases | ||||
) | ||||
|
r2856 | from IPython.utils import io | ||
|
r4772 | from IPython.utils import py3compat | ||
|
r2948 | from IPython.utils.jsonutil import json_clean | ||
|
r2868 | from IPython.lib import pylabtools | ||
|
r3970 | from IPython.utils.traitlets import ( | ||
List, Instance, Float, Dict, Bool, Int, Unicode, CaselessStrEnum | ||||
) | ||||
|
r3979 | |||
|
r3970 | from entry_point import base_launch_kernel | ||
from kernelapp import KernelApp, kernel_flags, kernel_aliases | ||||
|
r2796 | from iostream import OutStream | ||
|
r2778 | from session import Session, Message | ||
from zmqshell import ZMQInteractiveShell | ||||
|
r2598 | |||
|
r3314 | |||
|
r2712 | #----------------------------------------------------------------------------- | ||
|
r2754 | # Main kernel class | ||
|
r2712 | #----------------------------------------------------------------------------- | ||
|
r2641 | |||
|
r2759 | class Kernel(Configurable): | ||
|
r2778 | #--------------------------------------------------------------------------- | ||
# Kernel interface | ||||
#--------------------------------------------------------------------------- | ||||
|
r2760 | shell = Instance('IPython.core.interactiveshell.InteractiveShellABC') | ||
|
r2778 | session = Instance(Session) | ||
|
r3970 | shell_socket = Instance('zmq.Socket') | ||
iopub_socket = Instance('zmq.Socket') | ||||
stdin_socket = Instance('zmq.Socket') | ||||
log = Instance(logging.Logger) | ||||
|
r2759 | |||
|
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) | ||||
|
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 | ||||
|
r3019 | |||
# This is a dict of port number that the kernel is listening on. It is set | ||||
# by record_ports and used by connect_request. | ||||
|
r3970 | _recorded_ports = Dict() | ||
|
r3294 | |||
|
r2759 | def __init__(self, **kwargs): | ||
super(Kernel, self).__init__(**kwargs) | ||||
|
r2786 | |||
|
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) | ||||
|
r2786 | # Initialize the InteractiveShell subclass | ||
|
r3970 | self.shell = ZMQInteractiveShell.instance(config=self.config) | ||
|
r2786 | self.shell.displayhook.session = self.session | ||
|
r3970 | self.shell.displayhook.pub_socket = self.iopub_socket | ||
|
r3277 | self.shell.display_pub.session = self.session | ||
|
r3970 | self.shell.display_pub.pub_socket = self.iopub_socket | ||
|
r2778 | |||
|
r2838 | # TMP - hack while developing | ||
self.shell._reply_content = None | ||||
|
r2598 | # Build dict of handlers for message types | ||
|
r2612 | msg_types = [ 'execute_request', 'complete_request', | ||
|
r3817 | 'object_info_request', 'history_request', | ||
|
r3024 | 'connect_request', 'shutdown_request'] | ||
|
r2598 | self.handlers = {} | ||
|
r2612 | for msg_type in msg_types: | ||
|
r2598 | self.handlers[msg_type] = getattr(self, msg_type) | ||
|
r2868 | def do_one_iteration(self): | ||
|
r2949 | """Do one iteration of the kernel's evaluation loop. | ||
""" | ||||
|
r4521 | try: | ||
ident,msg = self.session.recv(self.shell_socket, zmq.NOBLOCK) | ||||
except Exception: | ||||
self.log.warn("Invalid Message:", exc_info=True) | ||||
return | ||||
|
r3269 | if msg is None: | ||
return | ||||
|
r4237 | |||
msg_type = msg['header']['msg_type'] | ||||
|
r3127 | # This assert will raise in versions of zeromq 2.0.7 and lesser. | ||
# We now require 2.0.8 or above, so we can uncomment for safety. | ||||
|
r3269 | # print(ident,msg, file=sys.__stdout__) | ||
assert ident is not None, "Missing message part." | ||||
|
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. | ||||
|
r4236 | self.log.debug('\n*** MESSAGE TYPE:'+str(msg_type)+'***') | ||
|
r3970 | self.log.debug(' Content: '+str(msg['content'])+'\n --->\n ') | ||
|
r2926 | |||
# Find and call actual handler for message | ||||
|
r4236 | handler = self.handlers.get(msg_type, None) | ||
|
r2868 | if handler is None: | ||
|
r3970 | self.log.error("UNKNOWN MESSAGE TYPE:" +str(msg)) | ||
|
r2868 | else: | ||
|
r2926 | handler(ident, msg) | ||
|
r2950 | |||
# Check whether we should exit, in case the incoming message set the | ||||
# exit flag on | ||||
if self.shell.exit_now: | ||||
|
r3970 | self.log.debug('\nExiting IPython kernel...') | ||
|
r2950 | # We do a normal, clean exit, which allows any actions registered | ||
# via atexit (such as history saving) to take place. | ||||
sys.exit(0) | ||||
|
r2778 | |||
def start(self): | ||||
""" Start the kernel main loop. | ||||
""" | ||||
|
r3970 | poller = zmq.Poller() | ||
poller.register(self.shell_socket, zmq.POLLIN) | ||||
|
r2598 | while True: | ||
|
r3900 | try: | ||
|
r3970 | # scale by extra factor of 10, because there is no | ||
# reason for this to be anything less than ~ 0.1s | ||||
# since it is a real poller and will respond | ||||
# to events immediately | ||||
|
r4544 | |||
# double nested try/except, to properly catch KeyboardInterrupt | ||||
# due to pyzmq Issue #130 | ||||
try: | ||||
poller.poll(10*1000*self._poll_interval) | ||||
self.do_one_iteration() | ||||
except: | ||||
raise | ||||
|
r3900 | except KeyboardInterrupt: | ||
# Ctrl-C shouldn't crash the kernel | ||||
|
r3901 | io.raw_print("KeyboardInterrupt caught in kernel") | ||
|
r3019 | |||
|
r3970 | def record_ports(self, ports): | ||
|
r3019 | """Record the ports that this kernel is using. | ||
The creator of the Kernel instance must call this methods if they | ||||
want the :meth:`connect_request` method to return the port numbers. | ||||
""" | ||||
|
r3970 | self._recorded_ports = ports | ||
|
r3019 | |||
|
r2778 | #--------------------------------------------------------------------------- | ||
# Kernel request handlers | ||||
#--------------------------------------------------------------------------- | ||||
|
r2598 | |||
|
r2926 | def _publish_pyin(self, code, parent): | ||
"""Publish the code request on the pyin stream.""" | ||||
|
r3970 | pyin_msg = self.session.send(self.iopub_socket, u'pyin',{u'code':code}, parent=parent) | ||
|
r2926 | |||
|
r2598 | def execute_request(self, ident, parent): | ||
|
r3035 | |||
|
r3970 | status_msg = self.session.send(self.iopub_socket, | ||
|
r3035 | u'status', | ||
{u'execution_state':u'busy'}, | ||||
parent=parent | ||||
) | ||||
|
r2598 | try: | ||
|
r2926 | content = parent[u'content'] | ||
code = content[u'code'] | ||||
silent = content[u'silent'] | ||||
|
r2598 | except: | ||
|
r3970 | self.log.error("Got bad msg: ") | ||
self.log.error(str(Message(parent))) | ||||
|
r2598 | return | ||
|
r2722 | |||
|
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) | ||||
|
r4772 | if py3compat.PY3: | ||
__builtin__.input = raw_input | ||||
else: | ||||
__builtin__.raw_input = raw_input | ||||
|
r2926 | |||
# Set the parent message of the display hook and out streams. | ||||
shell.displayhook.set_parent(parent) | ||||
|
r3277 | shell.display_pub.set_parent(parent) | ||
|
r2926 | 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 = {} | ||||
|
r2598 | try: | ||
|
r2926 | if silent: | ||
|
r3096 | # run_code uses 'exec' mode, so no displayhook will fire, and it | ||
|
r2926 | # doesn't call logging or history manipulations. Print | ||
# statements in that code will obviously still execute. | ||||
|
r3096 | shell.run_code(code) | ||
|
r2926 | else: | ||
|
r3087 | # FIXME: the shell calls the exception handler itself. | ||
|
r2967 | shell.run_cell(code) | ||
|
r2598 | except: | ||
|
r2926 | status = u'error' | ||
|
r2838 | # FIXME: this code right now isn't being used yet by default, | ||
|
r3752 | # because the run_cell() call above directly fires off exception | ||
|
r2838 | # 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. | ||||
|
r2598 | etype, evalue, tb = sys.exc_info() | ||
|
r2838 | tb_list = traceback.format_exception(etype, evalue, tb) | ||
|
r2926 | reply_content.update(shell._showtraceback(etype, evalue, tb_list)) | ||
|
r2598 | else: | ||
|
r2926 | status = u'ok' | ||
reply_content[u'status'] = status | ||||
|
r3077 | |||
# Return the execution counter so clients can display prompts | ||||
|
r3085 | reply_content['execution_count'] = shell.execution_count -1 | ||
|
r2926 | |||
# 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) | ||||
|
r3853 | # reset after use | ||
shell._reply_content = None | ||||
|
r2926 | |||
# 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'] = \ | ||||
|
r3050 | shell.user_variables(content[u'user_variables']) | ||
|
r2926 | reply_content[u'user_expressions'] = \ | ||
|
r3050 | shell.user_expressions(content[u'user_expressions']) | ||
|
r2926 | 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'] = {} | ||||
|
r2987 | |||
# Payloads should be retrieved regardless of outcome, so we can both | ||||
# recover partial output (that could have been generated early in a | ||||
# block, before an error) and clear the payload system always. | ||||
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() | ||||
|
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. | ||||
|
r2940 | if self._execute_sleep: | ||
time.sleep(self._execute_sleep) | ||||
|
r2938 | |||
|
r3333 | # Send the reply. | ||
|
r4782 | reply_content = json_clean(reply_content) | ||
|
r3970 | reply_msg = self.session.send(self.shell_socket, u'execute_reply', | ||
|
r3333 | reply_content, parent, ident=ident) | ||
|
r3970 | self.log.debug(str(reply_msg)) | ||
|
r3333 | |||
|
r2598 | if reply_msg['content']['status'] == u'error': | ||
|
r2778 | self._abort_queue() | ||
|
r3970 | status_msg = self.session.send(self.iopub_socket, | ||
|
r3035 | u'status', | ||
{u'execution_state':u'idle'}, | ||||
parent=parent | ||||
) | ||||
|
r2778 | def complete_request(self, ident, parent): | ||
|
r2856 | txt, matches = self._complete(parent) | ||
matches = {'matches' : matches, | ||||
'matched_text' : txt, | ||||
|
r2778 | 'status' : 'ok'} | ||
|
r4782 | matches = json_clean(matches) | ||
|
r3970 | completion_msg = self.session.send(self.shell_socket, 'complete_reply', | ||
|
r2778 | matches, parent, ident) | ||
|
r3970 | self.log.debug(str(completion_msg)) | ||
|
r2778 | |||
def object_info_request(self, ident, parent): | ||||
|
r2931 | object_info = self.shell.object_inspect(parent['content']['oname']) | ||
|
r3051 | # Before we send this object over, we scrub it for JSON usage | ||
oinfo = json_clean(object_info) | ||||
|
r3970 | msg = self.session.send(self.shell_socket, 'object_info_reply', | ||
|
r2948 | oinfo, parent, ident) | ||
|
r3970 | self.log.debug(msg) | ||
|
r2795 | |||
|
r3817 | def history_request(self, ident, parent): | ||
|
r3404 | # We need to pull these out, as passing **kwargs doesn't work with | ||
# unicode keys before Python 2.6.5. | ||||
|
r3817 | hist_access_type = parent['content']['hist_access_type'] | ||
|
r2844 | raw = parent['content']['raw'] | ||
|
r3404 | output = parent['content']['output'] | ||
|
r3817 | if hist_access_type == 'tail': | ||
n = parent['content']['n'] | ||||
hist = self.shell.history_manager.get_tail(n, raw=raw, output=output, | ||||
include_latest=True) | ||||
elif hist_access_type == 'range': | ||||
session = parent['content']['session'] | ||||
start = parent['content']['start'] | ||||
stop = parent['content']['stop'] | ||||
hist = self.shell.history_manager.get_range(session, start, stop, | ||||
raw=raw, output=output) | ||||
elif hist_access_type == 'search': | ||||
pattern = parent['content']['pattern'] | ||||
hist = self.shell.history_manager.search(pattern, raw=raw, output=output) | ||||
else: | ||||
hist = [] | ||||
|
r3397 | content = {'history' : list(hist)} | ||
|
r4782 | content = json_clean(content) | ||
|
r3970 | msg = self.session.send(self.shell_socket, 'history_reply', | ||
|
r2795 | content, parent, ident) | ||
|
r3970 | self.log.debug(str(msg)) | ||
|
r3019 | |||
def connect_request(self, ident, parent): | ||||
if self._recorded_ports is not None: | ||||
content = self._recorded_ports.copy() | ||||
else: | ||||
content = {} | ||||
|
r3970 | msg = self.session.send(self.shell_socket, 'connect_reply', | ||
|
r3019 | content, parent, ident) | ||
|
r3970 | self.log.debug(msg) | ||
|
r3019 | |||
|
r2972 | def shutdown_request(self, ident, parent): | ||
self.shell.exit_now = True | ||||
|
r3089 | self._shutdown_message = self.session.msg(u'shutdown_reply', parent['content'], parent) | ||
|
r2972 | sys.exit(0) | ||
|
r3019 | |||
|
r2778 | #--------------------------------------------------------------------------- | ||
# Protected interface | ||||
#--------------------------------------------------------------------------- | ||||
|
r2598 | |||
|
r2778 | def _abort_queue(self): | ||
while True: | ||||
|
r4521 | try: | ||
ident,msg = self.session.recv(self.shell_socket, zmq.NOBLOCK) | ||||
except Exception: | ||||
self.log.warn("Invalid Message:", exc_info=True) | ||||
continue | ||||
|
r3269 | if msg is None: | ||
break | ||||
|
r2778 | else: | ||
|
r3269 | assert ident is not None, \ | ||
|
r2926 | "Unexpected missing message part." | ||
|
r3322 | |||
|
r3970 | self.log.debug("Aborting:\n"+str(Message(msg))) | ||
|
r4230 | msg_type = msg['header']['msg_type'] | ||
|
r2778 | reply_type = msg_type.split('_')[0] + '_reply' | ||
|
r3970 | reply_msg = self.session.send(self.shell_socket, reply_type, | ||
|
r3269 | {'status' : 'aborted'}, msg, ident=ident) | ||
|
r3970 | self.log.debug(reply_msg) | ||
|
r2778 | # 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): | ||||
|
r2730 | # Flush output before making the request. | ||
sys.stderr.flush() | ||||
sys.stdout.flush() | ||||
# Send the input request. | ||||
|
r4782 | content = json_clean(dict(prompt=prompt)) | ||
|
r3970 | msg = self.session.send(self.stdin_socket, u'input_request', content, parent) | ||
|
r2730 | |||
# Await a response. | ||||
|
r4521 | while True: | ||
try: | ||||
ident, reply = self.session.recv(self.stdin_socket, 0) | ||||
except Exception: | ||||
self.log.warn("Invalid Message:", exc_info=True) | ||||
else: | ||||
break | ||||
|
r2730 | try: | ||
value = reply['content']['value'] | ||||
except: | ||||
|
r3970 | self.log.error("Got bad raw_input reply: ") | ||
self.log.error(str(Message(parent))) | ||||
|
r2730 | value = '' | ||
return value | ||||
|
r2778 | |||
def _complete(self, msg): | ||||
|
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 | ||||
|
r2856 | # least attempt the completion guessing the cursor is at the end of | ||
# the text, if there's any, and otherwise of the line | ||||
|
r2839 | cpos = len(c['text']) | ||
|
r2856 | if cpos==0: | ||
cpos = len(c['line']) | ||||
|
r2839 | return self.shell.complete(c['text'], c['line'], cpos) | ||
|
r2598 | |||
|
r2778 | def _object_info(self, context): | ||
symbol, leftover = self._symbol_from_context(context) | ||||
|
r2612 | if symbol is not None and not leftover: | ||
doc = getattr(symbol, '__doc__', '') | ||||
else: | ||||
doc = '' | ||||
object_info = dict(docstring = doc) | ||||
return object_info | ||||
|
r2778 | def _symbol_from_context(self, context): | ||
|
r2612 | if not context: | ||
return None, context | ||||
base_symbol_string = context[0] | ||||
|
r2759 | symbol = self.shell.user_ns.get(base_symbol_string, None) | ||
|
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, [] | ||||
|
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: | ||||
|
r3970 | self.session.send(self.shell_socket, self._shutdown_message) | ||
self.session.send(self.iopub_socket, self._shutdown_message) | ||||
self.log.debug(str(self._shutdown_message)) | ||||
|
r2972 | # A very short sleep to give zmq time to flush its message buffers | ||
# before Python truly shuts down. | ||||
time.sleep(0.01) | ||||
|
r2868 | |||
class QtKernel(Kernel): | ||||
|
r2872 | """A Kernel subclass with Qt support.""" | ||
|
r2868 | |||
def start(self): | ||||
"""Start a kernel with QtPy4 event loop integration.""" | ||||
|
r2872 | |||
|
r4149 | from IPython.external.qt_for_kernel import QtCore | ||
|
r2972 | from IPython.lib.guisupport import get_app_qt4, start_event_loop_qt4 | ||
|
r2900 | self.app = get_app_qt4([" "]) | ||
self.app.setQuitOnLastWindowClosed(False) | ||||
|
r2872 | self.timer = QtCore.QTimer() | ||
self.timer.timeout.connect(self.do_one_iteration) | ||||
|
r2940 | # Units for the timer are in milliseconds | ||
self.timer.start(1000*self._poll_interval) | ||||
|
r2900 | start_event_loop_qt4(self.app) | ||
|
r2872 | |||
|
r2926 | |||
|
r2872 | class WxKernel(Kernel): | ||
"""A Kernel subclass with Wx support.""" | ||||
|
r2868 | |||
|
r2872 | def start(self): | ||
"""Start a kernel with wx event loop support.""" | ||||
import wx | ||||
|
r2900 | from IPython.lib.guisupport import start_event_loop_wx | ||
|
r2972 | |||
|
r2872 | doi = self.do_one_iteration | ||
|
r2949 | # Wx uses milliseconds | ||
poll_interval = int(1000*self._poll_interval) | ||||
|
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) | ||||
|
r2940 | # Units for the timer are in milliseconds | ||
|
r2949 | self.timer.Start(poll_interval) | ||
|
r2872 | self.Bind(wx.EVT_TIMER, self.on_timer) | ||
self.func = func | ||||
|
r2949 | |||
|
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) | ||||
|
r2900 | start_event_loop_wx(self.app) | ||
|
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 | ||||
|
r2949 | # Tk uses milliseconds | ||
poll_interval = int(1000*self._poll_interval) | ||||
|
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 | ||||
|
r2949 | |||
|
r2872 | def on_timer(self): | ||
self.func() | ||||
|
r2949 | self.app.after(poll_interval, self.on_timer) | ||
|
r2872 | def start(self): | ||
self.on_timer() # Call it once to get things going. | ||||
self.app.mainloop() | ||||
self.timer = Timer(doi) | ||||
self.timer.start() | ||||
|
r2868 | |||
|
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() | ||||
|
r2712 | #----------------------------------------------------------------------------- | ||
|
r3970 | # Aliases and Flags for the IPKernelApp | ||
|
r2712 | #----------------------------------------------------------------------------- | ||
|
r3970 | flags = dict(kernel_flags) | ||
|
r3979 | flags.update(shell_flags) | ||
|
r3970 | |||
addflag = lambda *args: flags.update(boolean_flag(*args)) | ||||
flags['pylab'] = ( | ||||
{'IPKernelApp' : {'pylab' : 'auto'}}, | ||||
"""Pre-load matplotlib and numpy for interactive use with | ||||
the default matplotlib backend.""" | ||||
) | ||||
aliases = dict(kernel_aliases) | ||||
|
r3979 | aliases.update(shell_aliases) | ||
|
r3970 | |||
# it's possible we don't want short aliases for *all* of these: | ||||
aliases.update(dict( | ||||
pylab='IPKernelApp.pylab', | ||||
)) | ||||
|
r2700 | |||
|
r3970 | #----------------------------------------------------------------------------- | ||
# The IPKernelApp class | ||||
#----------------------------------------------------------------------------- | ||||
|
r2700 | |||
|
r3979 | class IPKernelApp(KernelApp, InteractiveShellApp): | ||
|
r3970 | name = 'ipkernel' | ||
aliases = Dict(aliases) | ||||
flags = Dict(flags) | ||||
|
r4015 | classes = [Kernel, ZMQInteractiveShell, ProfileDir, Session] | ||
|
r3970 | # configurables | ||
pylab = CaselessStrEnum(['tk', 'qt', 'wx', 'gtk', 'osx', 'inline', 'auto'], | ||||
config=True, | ||||
help="""Pre-load matplotlib and numpy for interactive use, | ||||
selecting a particular matplotlib backend and loop integration. | ||||
""" | ||||
) | ||||
|
r3979 | def initialize(self, argv=None): | ||
super(IPKernelApp, self).initialize(argv) | ||||
self.init_shell() | ||||
self.init_extensions() | ||||
self.init_code() | ||||
|
r3970 | |||
def init_kernel(self): | ||||
kernel_factory = Kernel | ||||
kernel_map = { | ||||
'qt' : QtKernel, | ||||
'qt4': QtKernel, | ||||
'inline': Kernel, | ||||
'osx': TkKernel, | ||||
'wx' : WxKernel, | ||||
'tk' : TkKernel, | ||||
'gtk': GTKKernel, | ||||
} | ||||
|
r2702 | |||
|
r3970 | if self.pylab: | ||
key = None if self.pylab == 'auto' else self.pylab | ||||
gui, backend = pylabtools.find_gui_and_backend(key) | ||||
kernel_factory = kernel_map.get(gui) | ||||
if kernel_factory is None: | ||||
raise ValueError('GUI is not supported: %r' % gui) | ||||
pylabtools.activate_matplotlib(backend) | ||||
kernel = kernel_factory(config=self.config, session=self.session, | ||||
shell_socket=self.shell_socket, | ||||
iopub_socket=self.iopub_socket, | ||||
stdin_socket=self.stdin_socket, | ||||
log=self.log | ||||
) | ||||
self.kernel = kernel | ||||
kernel.record_ports(self.ports) | ||||
|
r2641 | |||
|
r3970 | if self.pylab: | ||
|
r4143 | import_all = self.pylab_import_all | ||
pylabtools.import_pylab(kernel.shell.user_ns, backend, import_all, | ||||
|
r3970 | shell=kernel.shell) | ||
|
r3979 | |||
def init_shell(self): | ||||
self.shell = self.kernel.shell | ||||
|
r3828 | |||
|
r3812 | |||
|
r3970 | #----------------------------------------------------------------------------- | ||
# Kernel main and launch functions | ||||
#----------------------------------------------------------------------------- | ||||
|
r2700 | |||
|
r3970 | def launch_kernel(*args, **kwargs): | ||
"""Launches a localhost IPython kernel, binding to the specified ports. | ||||
|
r2778 | |||
|
r3970 | This function simply calls entry_point.base_launch_kernel with the right first | ||
command to start an ipkernel. See base_launch_kernel for arguments. | ||||
|
r3173 | |||
|
r2700 | Returns | ||
------- | ||||
A tuple of form: | ||||
|
r3970 | (kernel_process, shell_port, iopub_port, stdin_port, hb_port) | ||
|
r2702 | where kernel_process is a Popen object and the ports are integers. | ||
|
r2641 | """ | ||
|
r2778 | return base_launch_kernel('from IPython.zmq.ipkernel import main; main()', | ||
|
r3970 | *args, **kwargs) | ||
|
r2700 | |||
|
r2926 | |||
|
r2778 | def main(): | ||
|
r3979 | """Run an IPKernel as an application""" | ||
|
r3980 | app = IPKernelApp.instance() | ||
|
r3970 | app.initialize() | ||
app.start() | ||||
|
r2598 | |||
|
r2926 | |||
|
r2598 | if __name__ == '__main__': | ||
|
r2667 | main() | ||