zmqterminal now uses the zmq mixin app

IPython/frontend/kernelmixinapp.py

@@ -1,366 +1,364
 """ A minimal application base mixin for all ZMQ based IPython frontends.
 
 This is not a complete console app, as subprocess will not be able to receive
 input, there is no real readline support, among other limitations. This is a
 refactoring of what used to be the IPython/frontend/qt/console/qtconsoleapp.py
 
 Authors:
 
 * Evan Patterson
 * Min RK
 * Erik Tollerud
 * Fernando Perez
 * Bussonnier Matthias
 * Thomas Kluyver
 * Paul Ivanov
 
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # stdlib imports
 import json
 import os
 import signal
 import sys
 import uuid
 
 
 # Local imports
 from IPython.config.application import boolean_flag
 from IPython.config.configurable import Configurable
 from IPython.core.profiledir import ProfileDir
 from IPython.lib.kernel import tunnel_to_kernel, find_connection_file
 from IPython.zmq.blockingkernelmanager import BlockingKernelManager
 from IPython.utils.path import filefind
 from IPython.utils.py3compat import str_to_bytes
 from IPython.utils.traitlets import (
     Dict, List, Unicode, CUnicode, Int, CBool, Any
 )
 from IPython.zmq.ipkernel import (
     flags as ipkernel_flags,
     aliases as ipkernel_aliases,
     IPKernelApp
 )
 from IPython.zmq.session import Session, default_secure
 from IPython.zmq.zmqshell import ZMQInteractiveShell
 
 #-----------------------------------------------------------------------------
 # Network Constants
 #-----------------------------------------------------------------------------
 
 from IPython.utils.localinterfaces import LOCALHOST, LOCAL_IPS
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 
 #-----------------------------------------------------------------------------
 # Aliases and Flags
 #-----------------------------------------------------------------------------
 
 flags = dict(ipkernel_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
 app_flags = {
     'existing' : ({'IPythonMixinConsoleApp' : {'existing' : 'kernel*.json'}},
             "Connect to an existing kernel. If no argument specified, guess most recent"),
-    'pure' : ({'IPythonMixinConsoleApp' : {'pure' : True}},
-            "Use a pure Python kernel instead of an IPython kernel."),
-    'plain' : ({'ConsoleWidget' : {'kind' : 'plain'}},
-            "Disable rich text support."),
 }
 app_flags.update(boolean_flag(
     'confirm-exit', 'IPythonMixinConsoleApp.confirm_exit',
     """Set to display confirmation dialog on exit. You can always use 'exit' or 'quit',
        to force a direct exit without any confirmation.
     """,
     """Don't prompt the user when exiting. This will terminate the kernel
        if it is owned by the frontend, and leave it alive if it is external.
     """
 ))
 flags.update(app_flags)
 
 aliases = dict(ipkernel_aliases)
 
+# also scrub aliases from the frontend
 app_aliases = dict(
     hb = 'IPythonMixinConsoleApp.hb_port',
     shell = 'IPythonMixinConsoleApp.shell_port',
     iopub = 'IPythonMixinConsoleApp.iopub_port',
     stdin = 'IPythonMixinConsoleApp.stdin_port',
     ip = 'IPythonMixinConsoleApp.ip',
     existing = 'IPythonMixinConsoleApp.existing',
     f = 'IPythonMixinConsoleApp.connection_file',
 
 
     ssh = 'IPythonMixinConsoleApp.sshserver',
 )
 aliases.update(app_aliases)
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # IPythonMixinConsole
 #-----------------------------------------------------------------------------
 
 
 class IPythonMixinConsoleApp(Configurable):
     name = 'ipython-console-mixin'
     default_config_file_name='ipython_config.py'
 
     description = """
         The IPython Mixin Console.
         
         This class contains the common portions of console client (QtConsole,
         ZMQ-based terminal console, etc).  It is not a full console, in that
         launched terminal subprocesses will not be able to accept input.
         
         The Console using this mixing supports various extra features beyond
         the single-process Terminal IPython shell, such as connecting to
         existing kernel, via:
         
             ipython <appname> --existing
         
         as well as tunnel via SSH
         
     """
 
     classes = [IPKernelApp, ZMQInteractiveShell, ProfileDir, Session]
     flags = Dict(flags)
     aliases = Dict(aliases)
     kernel_manager_class = BlockingKernelManager
 
     kernel_argv = List(Unicode)
 
+    pure = CBool(False, config=True,
+        help="Use a pure Python kernel instead of an IPython kernel.")
     # create requested profiles by default, if they don't exist:
     auto_create = CBool(True)
     # 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!"""
     )
     
     sshserver = Unicode('', config=True,
         help="""The SSH server to use to connect to the kernel.""")
     sshkey = Unicode('', config=True,
         help="""Path to the ssh key to use for logging in to the ssh server.""")
     
     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]")
     connection_file = Unicode('', config=True,
         help="""JSON file in which to store connection info [default: kernel-<pid>.json]
 
         This file will contain the IP, ports, and authentication key needed to connect
         clients to this kernel. By default, this file will be created in the security-dir
         of the current profile, but can be specified by absolute path.
         """)
     def _connection_file_default(self):
         return 'kernel-%i.json' % os.getpid()
 
     existing = CUnicode('', config=True,
         help="""Connect to an already running kernel""")
 
     confirm_exit = CBool(True, config=True,
         help="""
         Set to display confirmation dialog on exit. You can always use 'exit' or 'quit',
         to force a direct exit without any confirmation.""",
     )
     
 
     def parse_command_line(self, argv=None):
-        super(PythonBaseConsoleApp, self).parse_command_line(argv)
+        #super(PythonBaseConsoleApp, self).parse_command_line(argv)
         # make this stuff after this a function, in case the super stuff goes
         # away. Also, Min notes that this functionality should be moved to a
         # generic library of kernel stuff
+        self.swallow_args(app_aliases,app_flags,argv=argv)
+
+    def swallow_args(self, aliases,flags, argv=None):
         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
         swallow_next = False
         was_flag = False
         # copy again, in case some aliases have the same name as a flag
         # argv = list(self.kernel_argv)
         for a in argv:
             if swallow_next:
                 swallow_next = False
                 # last arg was an alias, remove the next one
                 # *unless* the last alias has a no-arg flag version, in which
                 # case, don't swallow the next arg if it's also a flag:
                 if not (was_flag and a.startswith('-')):
                     self.kernel_argv.remove(a)
                     continue
             if a.startswith('-'):
                 split = a.lstrip('-').split('=')
                 alias = split[0]
-                if alias in qt_aliases:
+                if alias in aliases:
                     self.kernel_argv.remove(a)
                     if len(split) == 1:
                         # alias passed with arg via space
                         swallow_next = True
                         # could have been a flag that matches an alias, e.g. `existing`
                         # in which case, we might not swallow the next arg
-                        was_flag = alias in qt_flags
-                elif alias in qt_flags:
+                        was_flag = alias in flags
+                elif alias in flags:
                     # strip flag, but don't swallow next, as flags don't take args
                     self.kernel_argv.remove(a)
     
     def init_connection_file(self):
         """find the connection file, and load the info if found.
         
         The current working directory and the current profile's security
         directory will be searched for the file if it is not given by
         absolute path.
         
         When attempting to connect to an existing kernel and the `--existing`
         argument does not match an existing file, it will be interpreted as a
         fileglob, and the matching file in the current profile's security dir
         with the latest access time will be used.
         """
         if self.existing:
             try:
                 cf = find_connection_file(self.existing)
             except Exception:
                 self.log.critical("Could not find existing kernel connection file %s", self.existing)
                 self.exit(1)
             self.log.info("Connecting to existing kernel: %s" % cf)
             self.connection_file = cf
         # should load_connection_file only be used for existing?
         # as it is now, this allows reusing ports if an existing
         # file is requested
         try:
             self.load_connection_file()
         except Exception:
             self.log.error("Failed to load connection file: %r", self.connection_file, exc_info=True)
             self.exit(1)
     
     def load_connection_file(self):
         """load ip/port/hmac config from JSON connection file"""
         # this is identical to KernelApp.load_connection_file
         # perhaps it can be centralized somewhere?
         try:
             fname = filefind(self.connection_file, ['.', self.profile_dir.security_dir])
         except IOError:
             self.log.debug("Connection File not found: %s", self.connection_file)
             return
         self.log.debug(u"Loading connection file %s", fname)
         with open(fname) as f:
             s = f.read()
         cfg = json.loads(s)
         if self.ip == LOCALHOST and 'ip' in cfg:
             # not overridden by config or cl_args
             self.ip = cfg['ip']
         for channel in ('hb', 'shell', 'iopub', 'stdin'):
             name = channel + '_port'
             if getattr(self, name) == 0 and name in cfg:
                 # not overridden by config or cl_args
                 setattr(self, name, cfg[name])
         if 'key' in cfg:
             self.config.Session.key = str_to_bytes(cfg['key'])
     
     def init_ssh(self):
         """set up ssh tunnels, if needed."""
         if not self.sshserver and not self.sshkey:
             return
         
         if self.sshkey and not self.sshserver:
             # specifying just the key implies that we are connecting directly
             self.sshserver = self.ip
             self.ip = LOCALHOST
         
         # build connection dict for tunnels:
         info = dict(ip=self.ip,
                     shell_port=self.shell_port,
                     iopub_port=self.iopub_port,
                     stdin_port=self.stdin_port,
                     hb_port=self.hb_port
         )
         
         self.log.info("Forwarding connections to %s via %s"%(self.ip, self.sshserver))
         
         # tunnels return a new set of ports, which will be on localhost:
         self.ip = LOCALHOST
         try:
             newports = tunnel_to_kernel(info, self.sshserver, self.sshkey)
         except:
             # even catch KeyboardInterrupt
             self.log.error("Could not setup tunnels", exc_info=True)
             self.exit(1)
         
         self.shell_port, self.iopub_port, self.stdin_port, self.hb_port = newports
         
         cf = self.connection_file
         base,ext = os.path.splitext(cf)
         base = os.path.basename(base)
         self.connection_file = os.path.basename(base)+'-ssh'+ext
         self.log.critical("To connect another client via this tunnel, use:")
         self.log.critical("--existing %s" % self.connection_file)
     
     def _new_connection_file(self):
         return os.path.join(self.profile_dir.security_dir, 'kernel-%s.json' % uuid.uuid4())
 
     def init_kernel_manager(self):
         # Don't let Qt or ZMQ swallow KeyboardInterupts.
         signal.signal(signal.SIGINT, signal.SIG_DFL)
         sec = self.profile_dir.security_dir
         try:
             cf = filefind(self.connection_file, ['.', sec])
         except IOError:
             # file might not exist
             if self.connection_file == os.path.basename(self.connection_file):
                 # just shortname, put it in security dir
                 cf = os.path.join(sec, self.connection_file)
             else:
                 cf = self.connection_file
 
         # Create a KernelManager and start a kernel.
         self.kernel_manager = self.kernel_manager_class(
                                 ip=self.ip,
                                 shell_port=self.shell_port,
                                 iopub_port=self.iopub_port,
                                 stdin_port=self.stdin_port,
                                 hb_port=self.hb_port,
                                 connection_file=cf,
                                 config=self.config,
         )
         # start the kernel
         if not self.existing:
             kwargs = dict(ipython=not self.pure)
             kwargs['extra_arguments'] = self.kernel_argv
             self.kernel_manager.start_kernel(**kwargs)
         elif self.sshserver:
             # ssh, write new connection file
             self.kernel_manager.write_connection_file()
         self.kernel_manager.start_channels()
 
 
     def initialize(self, argv=None):
-        super(IPythonMixinConsoleApp, self).initialize(argv)
+        """
+        Classes which mix this class in should call:
+               IPythonMixinConsoleApp.initialize(self,argv)
+        """
         self.init_connection_file()
         default_secure(self.config)
         self.init_ssh()
         self.init_kernel_manager()
-        self.init_colors()
-
-#-----------------------------------------------------------------------------
-# Main entry point
-#-----------------------------------------------------------------------------
-
-def main():
-    raise NotImplementedError
-
 
-if __name__ == '__main__':
-    main()

IPython/frontend/qt/console/qtconsoleapp.py

@@ -1,371 +1,327
 """ A minimal application using the Qt console-style IPython frontend.
 
 This is not a complete console app, as subprocess will not be able to receive
 input, there is no real readline support, among other limitations.
 
 Authors:
 
 * Evan Patterson
 * Min RK
 * Erik Tollerud
 * Fernando Perez
 * Bussonnier Matthias
 * Thomas Kluyver
 * Paul Ivanov
 
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # stdlib imports
 import json
 import os
 import signal
 import sys
 import uuid
 
 # System library imports
 from IPython.external.qt import QtGui
 
 # Local imports
 from IPython.config.application import boolean_flag, catch_config_error
 from IPython.core.application import BaseIPythonApplication
 from IPython.core.profiledir import ProfileDir
 from IPython.lib.kernel import tunnel_to_kernel, find_connection_file
 from IPython.frontend.qt.console.frontend_widget import FrontendWidget
 from IPython.frontend.qt.console.ipython_widget import IPythonWidget
 from IPython.frontend.qt.console.rich_ipython_widget import RichIPythonWidget
 from IPython.frontend.qt.console import styles
 from IPython.frontend.qt.console.mainwindow import MainWindow
 from IPython.frontend.qt.kernelmanager import QtKernelManager
 from IPython.utils.path import filefind
 from IPython.utils.py3compat import str_to_bytes
 from IPython.utils.traitlets import (
     Dict, List, Unicode, Integer, CaselessStrEnum, CBool, Any
 )
 from IPython.zmq.ipkernel import IPKernelApp
 from IPython.zmq.session import Session, default_secure
 from IPython.zmq.zmqshell import ZMQInteractiveShell
+
 from IPython.frontend.kernelmixinapp import (
         IPythonMixinConsoleApp, app_aliases, app_flags
     )
 
 #-----------------------------------------------------------------------------
 # Network Constants
 #-----------------------------------------------------------------------------
 
 from IPython.utils.localinterfaces import LOCALHOST, LOCAL_IPS
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 _examples = """
 ipython qtconsole                 # start the qtconsole
 ipython qtconsole --pylab=inline  # start with pylab in inline plotting mode
 """
 
 #-----------------------------------------------------------------------------
 # Aliases and Flags
 #-----------------------------------------------------------------------------
 
+# XXX: the app_flags should really be flags from the mixin
 flags = dict(app_flags)
 qt_flags = {
-    #'existing' : ({'IPythonQtConsoleApp' : {'existing' : 'kernel*.json'}},
-    #        "Connect to an existing kernel. If no argument specified, guess most recent"),
     'pure' : ({'IPythonQtConsoleApp' : {'pure' : True}},
             "Use a pure Python kernel instead of an IPython kernel."),
     'plain' : ({'ConsoleWidget' : {'kind' : 'plain'}},
             "Disable rich text support."),
 }
 qt_flags.update(boolean_flag(
     'gui-completion', 'ConsoleWidget.gui_completion',
     "use a GUI widget for tab completion",
     "use plaintext output for completion"
 ))
 flags.update(qt_flags)
 
 aliases = dict(app_aliases)
 
 qt_aliases = dict(
-    existing = 'IPythonQtConsoleApp.existing',
-    f = 'IPythonQtConsoleApp.connection_file',
 
     style = 'IPythonWidget.syntax_style',
     stylesheet = 'IPythonQtConsoleApp.stylesheet',
     colors = 'ZMQInteractiveShell.colors',
 
     editor = 'IPythonWidget.editor',
     paging = 'ConsoleWidget.paging',
 )
 aliases.update(qt_aliases)
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # IPythonQtConsole
 #-----------------------------------------------------------------------------
 
 
 class IPythonQtConsoleApp(BaseIPythonApplication, IPythonMixinConsoleApp):
     name = 'ipython-qtconsole'
-    default_config_file_name='ipython_config.py'
 
     description = """
         The IPython QtConsole.
         
         This launches a Console-style application using Qt.  It is not a full
         console, in that launched terminal subprocesses will not be able to accept
         input.
         
         The QtConsole supports various extra features beyond the Terminal IPython
         shell, such as inline plotting with matplotlib, via:
         
             ipython qtconsole --pylab=inline
         
         as well as saving your session as HTML, and printing the output.
         
     """
     examples = _examples
 
     classes = [IPKernelApp, IPythonWidget, ZMQInteractiveShell, ProfileDir, Session]
     flags = Dict(flags)
     aliases = Dict(aliases)
     kernel_manager_class = QtKernelManager
 
     stylesheet = Unicode('', config=True,
         help="path to a custom CSS stylesheet")
 
-    pure = CBool(False, config=True,
-        help="Use a pure Python kernel instead of an IPython kernel.")
     plain = CBool(False, config=True,
         help="Use a plaintext widget instead of rich text (plain can't print/save).")
 
     def _pure_changed(self, name, old, new):
         kind = 'plain' if self.plain else 'rich'
         self.config.ConsoleWidget.kind = kind
         if self.pure:
             self.widget_factory = FrontendWidget
         elif self.plain:
             self.widget_factory = IPythonWidget
         else:
             self.widget_factory = RichIPythonWidget
 
     _plain_changed = _pure_changed
 
-    confirm_exit = CBool(True, config=True,
-        help="""
-        Set to display confirmation dialog on exit. You can always use 'exit' or 'quit',
-        to force a direct exit without any confirmation.""",
-    )
-    
     # the factory for creating a widget
     widget_factory = Any(RichIPythonWidget)
 
     def parse_command_line(self, argv=None):
         super(IPythonQtConsoleApp, 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
-        swallow_next = False
-        was_flag = False
-        # copy again, in case some aliases have the same name as a flag
-        # argv = list(self.kernel_argv)
-        for a in argv:
-            if swallow_next:
-                swallow_next = False
-                # last arg was an alias, remove the next one
-                # *unless* the last alias has a no-arg flag version, in which
-                # case, don't swallow the next arg if it's also a flag:
-                if not (was_flag and a.startswith('-')):
-                    self.kernel_argv.remove(a)
-                    continue
-            if a.startswith('-'):
-                split = a.lstrip('-').split('=')
-                alias = split[0]
-                if alias in qt_aliases:
-                    self.kernel_argv.remove(a)
-                    if len(split) == 1:
-                        # alias passed with arg via space
-                        swallow_next = True
-                        # could have been a flag that matches an alias, e.g. `existing`
-                        # in which case, we might not swallow the next arg
-                        was_flag = alias in qt_flags
-                elif alias in qt_flags:
-                    # strip flag, but don't swallow next, as flags don't take args
-                    self.kernel_argv.remove(a)
+        IPythonMixinConsoleApp.parse_command_line(self,argv)
+        self.swallow_args(qt_aliases,qt_flags,argv=argv)
+
     
 
 
     def new_frontend_master(self):
         """ Create and return new frontend attached to new kernel, launched on localhost.
         """
         ip = self.ip if self.ip in LOCAL_IPS else LOCALHOST
         kernel_manager = QtKernelManager(
                                 ip=ip,
                                 connection_file=self._new_connection_file(),
                                 config=self.config,
         )
         # start the kernel
         kwargs = dict(ipython=not self.pure)
         kwargs['extra_arguments'] = self.kernel_argv
         kernel_manager.start_kernel(**kwargs)
         kernel_manager.start_channels()
         widget = self.widget_factory(config=self.config,
                                    local_kernel=True)
         widget.kernel_manager = kernel_manager
         widget._existing = False
         widget._may_close = True
         widget._confirm_exit = self.confirm_exit
         return widget
 
     def new_frontend_slave(self, current_widget):
         """Create and return a new frontend attached to an existing kernel.
         
         Parameters
         ----------
         current_widget : IPythonWidget
             The IPythonWidget whose kernel this frontend is to share
         """
         kernel_manager = QtKernelManager(
                                 connection_file=current_widget.kernel_manager.connection_file,
                                 config = self.config,
         )
         kernel_manager.load_connection_file()
         kernel_manager.start_channels()
         widget = self.widget_factory(config=self.config,
                                 local_kernel=False)
         widget._existing = True
         widget._may_close = False
         widget._confirm_exit = False
         widget.kernel_manager = kernel_manager
         return widget
 
     def init_qt_elements(self):
         # Create the widget.
         self.app = QtGui.QApplication([])
 
         base_path = os.path.abspath(os.path.dirname(__file__))
         icon_path = os.path.join(base_path, 'resources', 'icon', 'IPythonConsole.svg')
         self.app.icon = QtGui.QIcon(icon_path)
         QtGui.QApplication.setWindowIcon(self.app.icon)
 
         local_kernel = (not self.existing) or self.ip in LOCAL_IPS
         self.widget = self.widget_factory(config=self.config,
                                         local_kernel=local_kernel)
         self.widget._existing = self.existing
         self.widget._may_close = not self.existing
         self.widget._confirm_exit = self.confirm_exit
 
         self.widget.kernel_manager = self.kernel_manager
         self.window = MainWindow(self.app,
                                 confirm_exit=self.confirm_exit,
                                 new_frontend_factory=self.new_frontend_master,
                                 slave_frontend_factory=self.new_frontend_slave,
                                 )
         self.window.log = self.log
         self.window.add_tab_with_frontend(self.widget)
         self.window.init_menu_bar()
 
         self.window.setWindowTitle('Python' if self.pure else 'IPython')
 
     def init_colors(self):
         """Configure the coloring of the widget"""
         # Note: This will be dramatically simplified when colors
         # are removed from the backend.
 
         if self.pure:
             # only IPythonWidget supports styling
             return
 
         # parse the colors arg down to current known labels
         try:
             colors = self.config.ZMQInteractiveShell.colors
         except AttributeError:
             colors = None
         try:
             style = self.config.IPythonWidget.syntax_style
         except AttributeError:
             style = None
 
         # find the value for colors:
         if colors:
             colors=colors.lower()
             if colors in ('lightbg', 'light'):
                 colors='lightbg'
             elif colors in ('dark', 'linux'):
                 colors='linux'
             else:
                 colors='nocolor'
         elif style:
             if style=='bw':
                 colors='nocolor'
             elif styles.dark_style(style):
                 colors='linux'
             else:
                 colors='lightbg'
         else:
             colors=None
 
         # Configure the style.
         widget = self.widget
         if style:
             widget.style_sheet = styles.sheet_from_template(style, colors)
             widget.syntax_style = style
             widget._syntax_style_changed()
             widget._style_sheet_changed()
         elif colors:
             # use a default style
             widget.set_default_style(colors=colors)
         else:
             # this is redundant for now, but allows the widget's
             # defaults to change
             widget.set_default_style()
 
         if self.stylesheet:
             # we got an expicit stylesheet
             if os.path.isfile(self.stylesheet):
                 with open(self.stylesheet) as f:
                     sheet = f.read()
                 widget.style_sheet = sheet
                 widget._style_sheet_changed()
             else:
                 raise IOError("Stylesheet %r not found."%self.stylesheet)
 
     @catch_config_error
     def initialize(self, argv=None):
         super(IPythonQtConsoleApp, self).initialize(argv)
-        self.init_connection_file()
-        default_secure(self.config)
-        self.init_ssh()
-        self.init_kernel_manager()
+        IPythonMixinConsoleApp.initialize(self,argv)
         self.init_qt_elements()
         self.init_colors()
 
     def start(self):
 
         # draw the window
         self.window.show()
 
         # Start the application main loop.
         self.app.exec_()
 
 #-----------------------------------------------------------------------------
 # Main entry point
 #-----------------------------------------------------------------------------
 
 def main():
     app = IPythonQtConsoleApp()
     app.initialize()
     app.start()
 
 
 if __name__ == '__main__':
     main()

IPython/frontend/zmqterminal/app.py

@@ -1,160 +1,100
-from __future__ import print_function
+""" A minimal application using the ZMQ-based terminal IPython frontend.
 
+This is not a complete console app, as subprocess will not be able to receive
+input, there is no real readline support, among other limitations.
+
+Authors:
+
+* Min RK
+* Paul Ivanov
+
+"""
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
 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.ipkernel import IPKernelApp
+from IPython.zmq.session import Session, default_secure
 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.kernelmixinapp import (
+        IPythonMixinConsoleApp, app_aliases, app_flags
 )
+
 from IPython.frontend.zmqterminal.interactiveshell import ZMQTerminalInteractiveShell
 
 #-----------------------------------------------------------------------------
-# Network Constants
+# Globals
 #-----------------------------------------------------------------------------
 
-from IPython.utils.localinterfaces import LOCALHOST, LOCAL_IPS
+_examples = """
+ipython console # start the ZMQ-based console
+ipython console --pylab # start with pylab plotting mode
+"""
 
 #-----------------------------------------------------------------------------
 # Flags and Aliases
 #-----------------------------------------------------------------------------
 
-
-flags = dict(ipkernel_flags)
-frontend_flags = {
-    'existing' : ({'ZMQTerminalIPythonApp' : {'existing' : True}},
-            "Connect to an existing kernel."),
-}
+# XXX: the app_flags should really be flags from the mixin
+flags = dict(app_flags)
+frontend_flags = { }
 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)
+aliases = dict(app_aliases)
+
+frontend_aliases = dict()
 
-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):
+class ZMQTerminalIPythonApp(TerminalIPythonApp, IPythonMixinConsoleApp):
     """Start a terminal frontend to the IPython zmq kernel."""
     
-    kernel_argv = List(Unicode)
+    classes = List([IPKernelApp, ZMQTerminalInteractiveShell])
     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)
+        IPythonMixinConsoleApp.parse_command_line(self,argv)
+        self.swallow_args(frontend_aliases,frontend_flags,argv=argv)
 
     def init_shell(self):
-        self.init_kernel_manager()
+        IPythonMixinConsoleApp.initialize(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):
         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()