zmqterminal subclasses TerminalInteractiveShell/IPApp

this does a lot of the boiler plate for us, so Omar's communication
code is used in place of run_cell / complete.

Now colors, prompts, indentation, cl-args, etc. are all inherited
from regular existing code.

keyboard interrupts don't work yet, the kernel just dies...

IPython/frontend/zmqterminal/app.py

@@ -0,0 +1,161 b''
+from __future__ import print_function
+
+import signal
+import sys
+import time
+
+from IPython.frontend.terminal.ipapp import TerminalIPythonApp
+
+from IPython.utils.traitlets import (
+    Dict, List, Unicode, Int, CaselessStrEnum, CBool, Any
+)
+from IPython.zmq.ipkernel import (
+    flags as ipkernel_flags,
+    aliases as ipkernel_aliases,
+    IPKernelApp
+)
+from IPython.zmq.session import Session
+from IPython.zmq.zmqshell import ZMQInteractiveShell
+from IPython.zmq.blockingkernelmanager import BlockingKernelManager
+from IPython.zmq.ipkernel import (
+    flags as ipkernel_flags,
+    aliases as ipkernel_aliases,
+    IPKernelApp
+)
+from IPython.frontend.zmqterminal.interactiveshell import ZMQTerminalInteractiveShell
+
+#-----------------------------------------------------------------------------
+# Network Constants
+#-----------------------------------------------------------------------------
+
+from IPython.utils.localinterfaces import LOCALHOST, LOCAL_IPS
+
+#-----------------------------------------------------------------------------
+# Flags and Aliases
+#-----------------------------------------------------------------------------
+
+
+flags = dict(ipkernel_flags)
+frontend_flags = {
+    'existing' : ({'ZMQTerminalIPythonApp' : {'existing' : True}},
+            "Connect to an existing kernel."),
+}
+flags.update(frontend_flags)
+# the flags that are specific to the frontend
+# these must be scrubbed before being passed to the kernel,
+# or it will raise an error on unrecognized flags
+frontend_flags = frontend_flags.keys()
+
+aliases = dict(ipkernel_aliases)
+
+frontend_aliases = dict(
+    hb = 'ZMQTerminalIPythonApp.hb_port',
+    shell = 'ZMQTerminalIPythonApp.shell_port',
+    iopub = 'ZMQTerminalIPythonApp.iopub_port',
+    stdin = 'ZMQTerminalIPythonApp.stdin_port',
+    ip = 'ZMQTerminalIPythonApp.ip',
+)
+aliases.update(frontend_aliases)
+# also scrub aliases from the frontend
+frontend_flags.extend(frontend_aliases.keys())
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+
+class ZMQTerminalIPythonApp(TerminalIPythonApp):
+    """Start a terminal frontend to the IPython zmq kernel."""
+    
+    kernel_argv = List(Unicode)
+    flags = Dict(flags)
+    aliases = Dict(aliases)
+    classes = List([IPKernelApp, ZMQTerminalInteractiveShell])
+    
+    # connection info:
+    ip = Unicode(LOCALHOST, config=True,
+        help="""Set the kernel\'s IP address [default localhost].
+        If the IP address is something other than localhost, then
+        Consoles on other machines will be able to connect
+        to the Kernel, so be careful!"""
+    )
+    pure = False
+    hb_port = Int(0, config=True,
+        help="set the heartbeat port [default: random]")
+    shell_port = Int(0, config=True,
+        help="set the shell (XREP) port [default: random]")
+    iopub_port = Int(0, config=True,
+        help="set the iopub (PUB) port [default: random]")
+    stdin_port = Int(0, config=True,
+        help="set the stdin (XREQ) port [default: random]")
+
+    existing = CBool(False, config=True,
+        help="Whether to connect to an already running Kernel.")
+
+    # from qtconsoleapp:
+    def parse_command_line(self, argv=None):
+        super(ZMQTerminalIPythonApp, self).parse_command_line(argv)
+        if argv is None:
+            argv = sys.argv[1:]
+
+        self.kernel_argv = list(argv) # copy
+        # kernel should inherit default config file from frontend
+        self.kernel_argv.append("--KernelApp.parent_appname='%s'"%self.name)
+        # scrub frontend-specific flags
+        for a in argv:
+            
+            if a.startswith('-'):
+                key = a.lstrip('-').split('=')[0]
+                if key in frontend_flags:
+                    self.kernel_argv.remove(a)
+    
+    def init_kernel_manager(self):
+        """init kernel manager (from qtconsole)"""
+        # Don't let Qt or ZMQ swallow KeyboardInterupts.
+        # signal.signal(signal.SIGINT, signal.SIG_DFL)
+
+        # Create a KernelManager and start a kernel.
+        self.kernel_manager = BlockingKernelManager(
+                                shell_address=(self.ip, self.shell_port),
+                                sub_address=(self.ip, self.iopub_port),
+                                stdin_address=(self.ip, self.stdin_port),
+                                hb_address=(self.ip, self.hb_port),
+                                config=self.config
+        )
+        # start the kernel
+        if not self.existing:
+            kwargs = dict(ip=self.ip, ipython=not self.pure)
+            kwargs['extra_arguments'] = self.kernel_argv
+            self.kernel_manager.start_kernel(**kwargs)
+            # wait for kernel to start
+            time.sleep(0.5)
+        self.kernel_manager.start_channels()
+        # relay sigint to kernel
+        signal.signal(signal.SIGINT, self.handle_sigint)
+
+    def init_shell(self):
+        self.init_kernel_manager()
+        self.shell = ZMQTerminalInteractiveShell.instance(config=self.config,
+                        display_banner=False, profile_dir=self.profile_dir,
+                        ipython_dir=self.ipython_dir, kernel_manager=self.kernel_manager)
+    
+    def handle_sigint(self, *args):
+        # FIXME: this doesn't work, the kernel just dies every time
+        self.shell.write('KeyboardInterrupt\n')
+        self.kernel_manager.interrupt_kernel()
+    
+    def init_code(self):
+        # no-op in the frontend, code gets run in the backend
+        pass
+        
+
+def launch_new_instance():
+    """Create and run a full blown IPython instance"""
+    app = ZMQTerminalIPythonApp.instance()
+    app.initialize()
+    app.start()
+
+
+if __name__ == '__main__':
+    launch_new_instance()
+

IPython/frontend/zmqterminal/interactiveshell.py

@@ -0,0 +1,252 b''
+# -*- 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

IPython/frontend/terminal/ipapp.py

@@ -1,399 +1,402 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 The :class:`~IPython.core.application.Application` object for the command
 line :command:`ipython` program.
 
 Authors
 -------
 
 * Brian Granger
 * Fernando Perez
 * Min Ragan-Kelley
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-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 absolute_import
 
 import logging
 import os
 import sys
 
 from IPython.config.loader import (
     Config, PyFileConfigLoader, ConfigFileNotFound
 )
 from IPython.config.application import boolean_flag, catch_config_error
 from IPython.core import release
 from IPython.core import usage
 from IPython.core.completer import IPCompleter
 from IPython.core.crashhandler import CrashHandler
 from IPython.core.formatters import PlainTextFormatter
 from IPython.core.prompts import PromptManager
 from IPython.core.application import (
     ProfileDir, BaseIPythonApplication, base_flags, base_aliases
 )
 from IPython.core.shellapp import (
     InteractiveShellApp, shell_flags, shell_aliases
 )
 from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
 from IPython.lib import inputhook
 from IPython.utils import warn
 from IPython.utils.path import get_ipython_dir, check_for_old_config
 from IPython.utils.traitlets import (
     Bool, List, Dict, CaselessStrEnum
 )
 
 #-----------------------------------------------------------------------------
 # Globals, utilities and helpers
 #-----------------------------------------------------------------------------
 
 #: The default config file name for this application.
 default_config_file_name = u'ipython_config.py'
 
 _examples = """
 ipython --pylab            # start in pylab mode
 ipython --pylab=qt         # start in pylab mode with the qt4 backend
 ipython --log-level=DEBUG  # set logging to DEBUG
 ipython --profile=foo      # start with profile foo
 
 ipython qtconsole          # start the qtconsole GUI application
 ipython qtconsole -h       # show the help string for the qtconsole subcmd
 
 ipython profile create foo # create profile foo w/ default config files
 ipython profile -h         # show the help string for the profile subcmd
 """
 
 #-----------------------------------------------------------------------------
 # Crash handler for this application
 #-----------------------------------------------------------------------------
 
 class IPAppCrashHandler(CrashHandler):
     """sys.excepthook for IPython itself, leaves a detailed report on disk."""
 
     def __init__(self, app):
         contact_name = release.authors['Fernando'][0]
         contact_email = release.author_email
         bug_tracker = 'https://github.com/ipython/ipython/issues'
         super(IPAppCrashHandler,self).__init__(
             app, contact_name, contact_email, bug_tracker
         )
 
     def make_report(self,traceback):
         """Return a string containing a crash report."""
 
         sec_sep = self.section_sep
         # Start with parent report
         report = [super(IPAppCrashHandler, self).make_report(traceback)]
         # Add interactive-specific info we may have
         rpt_add = report.append
         try:
             rpt_add(sec_sep+"History of session input:")
             for line in self.app.shell.user_ns['_ih']:
                 rpt_add(line)
             rpt_add('\n*** Last line of input (may not be in above history):\n')
             rpt_add(self.app.shell._last_input_line+'\n')
         except:
             pass
 
         return ''.join(report)
 
 #-----------------------------------------------------------------------------
 # Aliases and Flags
 #-----------------------------------------------------------------------------
 flags = dict(base_flags)
 flags.update(shell_flags)
 addflag = lambda *args: flags.update(boolean_flag(*args))
 addflag('autoedit-syntax', 'TerminalInteractiveShell.autoedit_syntax',
         'Turn on auto editing of files with syntax errors.',
         'Turn off auto editing of files with syntax errors.'
 )
 addflag('banner', 'TerminalIPythonApp.display_banner',
         "Display a banner upon starting IPython.",
         "Don't display a banner upon starting IPython."
 )
 addflag('confirm-exit', 'TerminalInteractiveShell.confirm_exit',
     """Set to confirm when you try to exit IPython with an EOF (Control-D
     in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
     you can force a direct exit without any confirmation.""",
     "Don't prompt the user when exiting."
 )
 addflag('term-title', 'TerminalInteractiveShell.term_title',
     "Enable auto setting the terminal title.",
     "Disable auto setting the terminal title."
 )
 classic_config = Config()
 classic_config.InteractiveShell.cache_size = 0
 classic_config.PlainTextFormatter.pprint = False
 classic_config.PromptManager.in_template = '>>> '
 classic_config.PromptManager.in2_template = '... '
 classic_config.PromptManager.out_template = ''
 classic_config.InteractiveShell.separate_in = ''
 classic_config.InteractiveShell.separate_out = ''
 classic_config.InteractiveShell.separate_out2 = ''
 classic_config.InteractiveShell.colors = 'NoColor'
 classic_config.InteractiveShell.xmode = 'Plain'
 
 flags['classic']=(
     classic_config,
     "Gives IPython a similar feel to the classic Python prompt."
 )
 # # log doesn't make so much sense this way anymore
 # paa('--log','-l',
 #     action='store_true', dest='InteractiveShell.logstart',
 #     help="Start logging to the default log file (./ipython_log.py).")
 #
 # # quick is harder to implement
 flags['quick']=(
     {'TerminalIPythonApp' : {'quick' : True}},
     "Enable quick startup with no config files."
 )
 
 flags['i'] = (
     {'TerminalIPythonApp' : {'force_interact' : True}},
     """If running code from the command line, become interactive afterwards.
     Note: can also be given simply as '-i.'"""
 )
 flags['pylab'] = (
     {'TerminalIPythonApp' : {'pylab' : 'auto'}},
     """Pre-load matplotlib and numpy for interactive use with
     the default matplotlib backend."""
 )
 
 aliases = dict(base_aliases)
 aliases.update(shell_aliases)
 
 # it's possible we don't want short aliases for *all* of these:
 aliases.update(dict(
     gui='TerminalIPythonApp.gui',
     pylab='TerminalIPythonApp.pylab',
 ))
 
 #-----------------------------------------------------------------------------
 # Main classes and functions
 #-----------------------------------------------------------------------------
 
 class TerminalIPythonApp(BaseIPythonApplication, InteractiveShellApp):
     name = u'ipython'
     description = usage.cl_usage
     default_config_file_name = default_config_file_name
     crash_handler_class = IPAppCrashHandler
     examples = _examples
 
     flags = Dict(flags)
     aliases = Dict(aliases)
     classes = List()
     def _classes_default(self):
         """This has to be in a method, for TerminalIPythonApp to be available."""
         return [
             InteractiveShellApp, # ShellApp comes before TerminalApp, because
             self.__class__,      # it will also affect subclasses (e.g. QtConsole)
             TerminalInteractiveShell,
             PromptManager,
             ProfileDir,
             PlainTextFormatter,
             IPCompleter,
         ]
 
     subcommands = Dict(dict(
         qtconsole=('IPython.frontend.qt.console.qtconsoleapp.IPythonQtConsoleApp',
             """Launch the IPython Qt Console."""
         ),
         notebook=('IPython.frontend.html.notebook.notebookapp.NotebookApp',
             """Launch the IPython HTML Notebook Server"""
         ),
         profile = ("IPython.core.profileapp.ProfileApp",
             "Create and manage IPython profiles."
         ),
         kernel = ("IPython.zmq.ipkernel.IPKernelApp",
             "Start a kernel without an attached frontend."
         ),
+        zmq=('IPython.frontend.zmqterminal.app.ZMQTerminalIPythonApp',
+            """Launch two-process Terminal session with 0MQ."""
+        ),
     ))
 
     # *do* autocreate requested profile, but don't create the config file.
     auto_create=Bool(True)
     # configurables
     ignore_old_config=Bool(False, config=True,
         help="Suppress warning messages about legacy config files"
     )
     quick = Bool(False, config=True,
         help="""Start IPython quickly by skipping the loading of config files."""
     )
     def _quick_changed(self, name, old, new):
         if new:
             self.load_config_file = lambda *a, **kw: None
             self.ignore_old_config=True
 
     gui = CaselessStrEnum(('qt', 'wx', 'gtk', 'glut', 'pyglet'), config=True,
         help="Enable GUI event loop integration ('qt', 'wx', 'gtk', 'glut', 'pyglet')."
     )
     pylab = CaselessStrEnum(['tk', 'qt', 'wx', 'gtk', 'osx', 'auto'],
         config=True,
         help="""Pre-load matplotlib and numpy for interactive use,
         selecting a particular matplotlib backend and loop integration.
         """
     )
     display_banner = Bool(True, config=True,
         help="Whether to display a banner upon starting IPython."
     )
 
     # if there is code of files to run from the cmd line, don't interact
     # unless the --i flag (App.force_interact) is true.
     force_interact = Bool(False, config=True,
         help="""If a command or file is given via the command-line,
         e.g. 'ipython foo.py"""
     )
     def _force_interact_changed(self, name, old, new):
         if new:
             self.interact = True
 
     def _file_to_run_changed(self, name, old, new):
         if new and not self.force_interact:
                 self.interact = False
     _code_to_run_changed = _file_to_run_changed
 
     # internal, not-configurable
     interact=Bool(True)
 
 
     def parse_command_line(self, argv=None):
         """override to allow old '-pylab' flag with deprecation warning"""
 
         argv = sys.argv[1:] if argv is None else argv
 
         if '-pylab' in argv:
             # deprecated `-pylab` given,
             # warn and transform into current syntax
             argv = argv[:] # copy, don't clobber
             idx = argv.index('-pylab')
             warn.warn("`-pylab` flag has been deprecated.\n"
             "    Use `--pylab` instead, or `--pylab=foo` to specify a backend.")
             sub = '--pylab'
             if len(argv) > idx+1:
                 # check for gui arg, as in '-pylab qt'
                 gui = argv[idx+1]
                 if gui in ('wx', 'qt', 'qt4', 'gtk', 'auto'):
                     sub = '--pylab='+gui
                     argv.pop(idx+1)
             argv[idx] = sub
 
         return super(TerminalIPythonApp, self).parse_command_line(argv)
     
     @catch_config_error
     def initialize(self, argv=None):
         """Do actions after construct, but before starting the app."""
         super(TerminalIPythonApp, self).initialize(argv)
         if self.subapp is not None:
             # don't bother initializing further, starting subapp
             return
         if not self.ignore_old_config:
             check_for_old_config(self.ipython_dir)
         # print self.extra_args
         if self.extra_args:
             self.file_to_run = self.extra_args[0]
         # create the shell
         self.init_shell()
         # and draw the banner
         self.init_banner()
         # Now a variety of things that happen after the banner is printed.
         self.init_gui_pylab()
         self.init_extensions()
         self.init_code()
 
     def init_shell(self):
         """initialize the InteractiveShell instance"""
         # I am a little hesitant to put these into InteractiveShell itself.
         # But that might be the place for them
         sys.path.insert(0, '')
 
         # Create an InteractiveShell instance.
         # shell.display_banner should always be False for the terminal
         # based app, because we call shell.show_banner() by hand below
         # so the banner shows *before* all extension loading stuff.
         self.shell = TerminalInteractiveShell.instance(config=self.config,
                         display_banner=False, profile_dir=self.profile_dir,
                         ipython_dir=self.ipython_dir)
         self.shell.configurables.append(self)
 
     def init_banner(self):
         """optionally display the banner"""
         if self.display_banner and self.interact:
             self.shell.show_banner()
         # Make sure there is a space below the banner.
         if self.log_level <= logging.INFO: print
 
 
     def init_gui_pylab(self):
         """Enable GUI event loop integration, taking pylab into account."""
         gui = self.gui
 
         # Using `pylab` will also require gui activation, though which toolkit
         # to use may be chosen automatically based on mpl configuration.
         if self.pylab:
             activate = self.shell.enable_pylab
             if self.pylab == 'auto':
                 gui = None
             else:
                 gui = self.pylab
         else:
             # Enable only GUI integration, no pylab
             activate = inputhook.enable_gui
 
         if gui or self.pylab:
             try:
                 self.log.info("Enabling GUI event loop integration, "
                               "toolkit=%s, pylab=%s" % (gui, self.pylab) )
                 if self.pylab:
                     activate(gui, import_all=self.pylab_import_all)
                 else:
                     activate(gui)
             except:
                 self.log.warn("Error in enabling GUI event loop integration:")
                 self.shell.showtraceback()
 
     def start(self):
         if self.subapp is not None:
             return self.subapp.start()
         # perform any prexec steps:
         if self.interact:
             self.log.debug("Starting IPython's mainloop...")
             self.shell.mainloop()
         else:
             self.log.debug("IPython not interactive...")
 
 
 def load_default_config(ipython_dir=None):
     """Load the default config file from the default ipython_dir.
 
     This is useful for embedded shells.
     """
     if ipython_dir is None:
         ipython_dir = get_ipython_dir()
     profile_dir = os.path.join(ipython_dir, 'profile_default')
     cl = PyFileConfigLoader(default_config_file_name, profile_dir)
     try:
         config = cl.load_config()
     except ConfigFileNotFound:
         # no config found
         config = Config()
     return config
 
 
 def launch_new_instance():
     """Create and run a full blown IPython instance"""
     app = TerminalIPythonApp.instance()
     app.initialize()
     app.start()
 
 
 if __name__ == '__main__':
     launch_new_instance()

IPython/frontend/zmqterminal/completer.py

@@ -1,41 +1,44 b''
 # -*- coding: utf-8 -*-
 import readline
 from Queue import Empty
 
-class ClientCompleter2p(object):
+class ZMQCompleter(object):
     """Client-side completion machinery.
 
     How it works: self.complete will be called multiple times, with
     state=0,1,2,... When state=0 it should compute ALL the completion matches,
     and then return them for each value of state."""
     
-    def __init__(self,client, km):
+    def __init__(self, shell, km):
+        self.shell = shell
         self.km =  km
         self.matches = []
-        self.client = client
         
     def complete_request(self,text):
         line = readline.get_line_buffer()
         cursor_pos = readline.get_endidx()
         
         # send completion request to kernel
         # Give the kernel up to 0.5s to respond
-        msg_id = self.km.xreq_channel.complete(text=text, line=line,
+        msg_id = self.km.shell_channel.complete(text=text, line=line,
                                                         cursor_pos=cursor_pos)
         
-        msg_xreq = self.km.xreq_channel.get_msg(timeout=0.5)
-        if msg_xreq['parent_header']['msg_id'] == msg_id:
-            return msg_xreq["content"]["matches"]
+        msg = self.km.shell_channel.get_msg(timeout=0.5)
+        if msg['parent_header']['msg_id'] == msg_id:
+            return msg["content"]["matches"]
         return []
     
-    def complete(self, text, state):
+    def rlcomplete(self, text, state):
         if state == 0:
             try:
                 self.matches = self.complete_request(text)
             except Empty:
                 print('WARNING: Kernel timeout on tab completion.')
         
         try:
             return self.matches[state]
         except IndexError:
             return None
+    
+    def complete(self, text, line, cursor_pos=None):
+        return self.rlcomplete(text, 0)