# -*- 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