##// END OF EJS Templates
ignore KeyboardInterrupt until we can handle it
ignore KeyboardInterrupt until we can handle it

File last commit:

r5601:fcf7cd58
r5601:fcf7cd58
Show More
interactiveshell.py
252 lines | 9.8 KiB | text/x-python | PythonLexer
# -*- coding: utf-8 -*-
"""Frontend of ipython working with python-zmq
Ipython's frontend, is a ipython interface that send request to kernel and proccess the kernel's outputs.
For more details, see the ipython-zmq design
"""
#-----------------------------------------------------------------------------
# Copyright (C) 2011 The IPython Development Team
#
# Distributed under the terms of the BSD License. The full license is in
# the file COPYING, distributed as part of this software.
#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------
# Imports
#-----------------------------------------------------------------------------
from __future__ import print_function
import bdb
import sys
from Queue import Empty
from IPython.core.alias import AliasManager, AliasError
from IPython.utils.warn import warn, error, fatal
from IPython.utils import io
from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
from IPython.frontend.zmqterminal.completer import ZMQCompleter
class ZMQTerminalInteractiveShell(TerminalInteractiveShell):
"""A subclass of TerminalInteractiveShell that """
def __init__(self, *args, **kwargs):
self.km = kwargs.pop('kernel_manager')
self.session_id = self.km.session.session
super(ZMQTerminalInteractiveShell, self).__init__(*args, **kwargs)
def init_completer(self):
"""Initialize the completion machinery.
This creates completion machinery that can be used by client code,
either interactively in-process (typically triggered by the readline
library), programatically (such as in test suites) or out-of-prcess
(typically over the network by remote frontends).
"""
from IPython.core.completerlib import (module_completer,
magic_run_completer, cd_completer)
self.Completer = ZMQCompleter(self, self.km)
self.set_hook('complete_command', module_completer, str_key = 'import')
self.set_hook('complete_command', module_completer, str_key = 'from')
self.set_hook('complete_command', magic_run_completer, str_key = '%run')
self.set_hook('complete_command', cd_completer, str_key = '%cd')
# Only configure readline if we truly are using readline. IPython can
# do tab-completion over the network, in GUIs, etc, where readline
# itself may be absent
if self.has_readline:
self.set_readline_completer()
def run_cell(self, cell, store_history=True):
"""Run a complete IPython cell.
Parameters
----------
cell : str
The code (including IPython code such as %magic functions) to run.
store_history : bool
If True, the raw and translated cell will be stored in IPython's
history. For user code calling back into IPython's machinery, this
should be set to False.
"""
if (not cell) or cell.isspace():
return
# shell_channel.execute takes 'hidden', which is the inverse of store_hist
msg_id = self.km.shell_channel.execute(cell, not store_history)
while not self.km.shell_channel.msg_ready():
try:
self.handle_stdin_request(timeout=0.05)
except Empty:
pass
self.handle_execute_reply(msg_id)
#-----------------
# message handlers
#-----------------
def handle_execute_reply(self, msg_id):
msg = self.km.shell_channel.get_msg()
if msg["parent_header"]["msg_id"] == msg_id:
if msg["content"]["status"] == 'ok' :
self.handle_iopub()
elif msg["content"]["status"] == 'error':
for frame in msg["content"]["traceback"]:
print(frame, file=io.stderr)
self.execution_count = msg["content"]["execution_count"] + 1
def handle_iopub(self):
""" Method to procces subscribe channel's messages
This method reads a message and processes the content in different
outputs like stdout, stderr, pyout and status
Arguments:
sub_msg: message receive from kernel in the sub socket channel
capture by kernel manager.
"""
while self.km.sub_channel.msg_ready():
sub_msg = self.km.sub_channel.get_msg()
msg_type = sub_msg['header']['msg_type']
if self.session_id == sub_msg['parent_header']['session']:
if msg_type == 'status' :
if sub_msg["content"]["execution_state"] == "busy" :
pass
elif msg_type == 'stream' :
if sub_msg["content"]["name"] == "stdout":
print(sub_msg["content"]["data"], file=io.stdout, end="")
io.stdout.flush()
elif sub_msg["content"]["name"] == "stderr" :
print(sub_msg["content"]["data"], file=io.stderr, end="")
io.stderr.flush()
elif msg_type == 'pyout':
format_dict = sub_msg["content"]["data"]
# taken from DisplayHook.__call__:
hook = self.displayhook
hook.start_displayhook()
hook.write_output_prompt()
hook.write_format_data(format_dict)
hook.log_output(format_dict)
hook.finish_displayhook()
def handle_stdin_request(self, timeout=0.1):
""" Method to capture raw_input
"""
msg_rep = self.km.stdin_channel.get_msg(timeout=timeout)
if self.session_id == msg_rep["parent_header"]["session"] :
raw_data = raw_input(msg_rep["content"]["prompt"])
self.km.stdin_channel.input(raw_data)
def mainloop(self, display_banner=False):
while True:
try:
self.interact(display_banner=display_banner)
#self.interact_with_readline()
# XXX for testing of a readline-decoupled repl loop, call
# interact_with_readline above
break
except KeyboardInterrupt:
# this should not be necessary, but KeyboardInterrupt
# handling seems rather unpredictable...
self.write("\nKeyboardInterrupt in interact()\n")
def interact(self, display_banner=None):
"""Closely emulate the interactive Python console."""
# batch run -> do not interact
if self.exit_now:
return
if display_banner is None:
display_banner = self.display_banner
if isinstance(display_banner, basestring):
self.show_banner(display_banner)
elif display_banner:
self.show_banner()
more = False
if self.has_readline:
self.readline_startup_hook(self.pre_readline)
# exit_now is set by a call to %Exit or %Quit, through the
# ask_exit callback.
while not self.exit_now:
if not self.km.is_alive:
ans = self.raw_input("kernel died, restart ([y]/n)?")
if not ans.lower().startswith('n'):
self.km.restart_kernel(True)
else:
self.exit_now=True
continue
self.hooks.pre_prompt_hook()
if more:
try:
prompt = self.hooks.generate_prompt(True)
except:
self.showtraceback()
if self.autoindent:
self.rl_do_indent = True
else:
try:
prompt = self.hooks.generate_prompt(False)
except:
self.showtraceback()
try:
line = self.raw_input(prompt)
if self.exit_now:
# quick exit on sys.std[in|out] close
break
if self.autoindent:
self.rl_do_indent = False
except KeyboardInterrupt:
#double-guard against keyboardinterrupts during kbdint handling
try:
self.write('\nKeyboardInterrupt\n')
self.input_splitter.reset()
more = False
except KeyboardInterrupt:
pass
except EOFError:
if self.autoindent:
self.rl_do_indent = False
if self.has_readline:
self.readline_startup_hook(None)
self.write('\n')
self.exit()
except bdb.BdbQuit:
warn('The Python debugger has exited with a BdbQuit exception.\n'
'Because of how pdb handles the stack, it is impossible\n'
'for IPython to properly format this particular exception.\n'
'IPython will resume normal operation.')
except:
# exceptions here are VERY RARE, but they can be triggered
# asynchronously by signal handlers, for example.
self.showtraceback()
else:
self.input_splitter.push(line)
more = self.input_splitter.push_accepts_more()
if (self.SyntaxTB.last_syntax_error and
self.autoedit_syntax):
self.edit_syntax_error()
if not more:
source_raw = self.input_splitter.source_reset()
self.run_cell(source_raw)
# Turn off the exit flag, so the mainloop can be restarted if desired
self.exit_now = False